Parece que tiene las ventajas de utilizar un tipo de punto flotante. Tiendo a diseñar decimales en todos los casos, y confío en un generador de perfiles para saber si las operaciones en decimal están causando cuellos de botella o ralentizaciones. En esos casos, voy a "lanzar hacia abajo" para doblar o flotar, pero solo lo hago internamente, y trato de manejar la pérdida de precisión al limitar el número de dígitos significativos en la operación matemática que se está realizando.
En general, si su valor es transitorio (no reutilizado), puede usar un tipo de coma flotante. El problema real con los tipos de coma flotante son los siguientes tres escenarios.
- Usted está agregación de valores de punto flotante (en cuyo caso el compuesto errores de precisión)
- A construir valores basados en el valor de punto flotante (por ejemplo en un algoritmo recursivo)
- Usted está haciendo matemáticas con una muy amplio número de dígitos significativos (por ejemplo,
123456789.1 * .000000000000000987654321
)
EDITAR
A egún el reference documentation on C# decimals:
El decimal palabra denota un tipo de datos de 128 bits. Comparado con tipos de punto flotante, el tipo decimal tiene una mayor precisión y un rango más pequeño , lo que lo hace adecuado para cálculos financieros y monetarios .
Así que para aclarar mi declaración anterior:
tiendo a diseñar para los decimales en todos casos, y confiar en un generador de perfiles para dejar quisiera saber si las operaciones en decimal es cuellos de botella que causan o lenta -descendientes.
Solo he trabajado en industrias donde los decimales son favorables. Si está trabajando en motores gráficos o de gráficos, probablemente sea mucho más beneficioso diseñar para un tipo de punto flotante (flotante o doble).
decimal no es infinitamente preciso (es imposible representar precisión infinita para no integral en un tipo de datos primitivo), pero es mucho más preciso que el doble:
- decimales = 28-29 dígitos significativos
- dobles = 15-16 dígitos significativos
- flotador = 7 dígitos significativos
EDIT 2
En respuesta al comentario de Konrad Rudolph, el elemento 1 (arriba) es definitivamente correcto. La agregación de la imprecisión sí es compuesta. Ver el código de abajo para ver un ejemplo:
private const float THREE_FIFTHS = 3f/5f;
private const int ONE_MILLION = 1000000;
public static void Main(string[] args)
{
Console.WriteLine("Three Fifths: {0}", THREE_FIFTHS.ToString("F10"));
float asSingle = 0f;
double asDouble = 0d;
decimal asDecimal = 0M;
for (int i = 0; i < ONE_MILLION; i++)
{
asSingle += THREE_FIFTHS;
asDouble += THREE_FIFTHS;
asDecimal += (decimal) THREE_FIFTHS;
}
Console.WriteLine("Six Hundred Thousand: {0:F10}", THREE_FIFTHS * ONE_MILLION);
Console.WriteLine("Single: {0}", asSingle.ToString("F10"));
Console.WriteLine("Double: {0}", asDouble.ToString("F10"));
Console.WriteLine("Decimal: {0}", asDecimal.ToString("F10"));
Console.ReadLine();
}
Esto da el siguiente resultado:
Three Fifths: 0.6000000000
Six Hundred Thousand: 600000.0000000000
Single: 599093.4000000000
Double: 599999.9999886850
Decimal: 600000.0000000000
Como se puede ver, a pesar de que estamos añadiendo a la misma fuente constante y los resultados de la doble es menos preciso (aunque probablemente se redondee correctamente), y el flotador es mucho menos preciso, hasta el punto en que se ha reducido a solo dos dígitos significativos.
ver también http://stackoverflow.com/questions/2545567/in-net-how-do-i-choose-between-a-decimal-and-a-double –
Esto se actualiza bastante regularmente y todavía me cuesta con eso. Por ejemplo, estoy trabajando en una aplicación que hace cálculos financieros, así que estoy usando decimales en todas partes. Pero las funciones Math y VisualBasic.Financial usan el doble, por lo que hay una gran cantidad de conversiones que me hacen dudar constantemente sobre el uso del decimal. –
@JamieIde que está loco. Las funciones financieras usan el doble, el dinero siempre debe estar en decimales. –