¿Diferencia entre decimal, flotante y doble en .NET?

¿Qué es la diferencia entre decimal, floaty doubleen .NET?

¿Cuándo alguien usaría uno de estos?

floaty doubleson tipos de punto binario flotante . En otras palabras, representan un número como este:

10001.10010110011

El número binario y la ubicación del punto binario están codificados dentro del valor.

decimales un flotante decimal tipo de punto . En otras palabras, representan un número como este:

12345.65789

Nuevamente, el número y la ubicación del punto decimal están codificados dentro del valor; eso es lo que hace que sea decimalun tipo de punto flotante en lugar de un tipo de punto fijo.

Lo importante a tener en cuenta es que los humanos están acostumbrados a representar no enteros en forma decimal, y esperan resultados exactos en representaciones decimales; no todos los números decimales son exactamente representables en coma flotante binaria - 0.1, por ejemplo - así que si usa un valor de coma flotante binaria, obtendrá una aproximación de 0.1. También obtendrá aproximaciones cuando utilice un punto decimal flotante; por ejemplo, el resultado de dividir 1 por 3 no puede representarse exactamente.

En cuanto a qué usar cuando:

• Para valores que son "decimales exactos de forma natural" es bueno usarlo decimal. Esto suele ser adecuado para cualquier concepto inventado por los humanos: los valores financieros son el ejemplo más obvio, pero también hay otros. Considere la puntuación dada a los buceadores o patinadores sobre hielo, por ejemplo.

• Para valores que son más objetos de la naturaleza que en realidad no puede medirse con exactitud todos modos, float/ doubleson más apropiados. Por ejemplo, los datos científicos generalmente se representarían de esta forma. Aquí, los valores originales no serán "decimalmente precisos" para comenzar, por lo que no es importante que los resultados esperados mantengan la "precisión decimal". Los tipos de punto binario flotante son mucho más rápidos para trabajar que los decimales.

La precisión es la principal diferencia.

Flotador : 7 dígitos (32 bits)

Doble -15-16 dígitos (64 bits)

Decimal -28-29 dígitos significativos (128 bits)

Los decimales tienen una precisión mucho mayor y generalmente se usan en aplicaciones financieras que requieren un alto grado de precisión. Los decimales son mucho más lentos (hasta 20 veces más en algunas pruebas) que un doble / flotante.

Los decimales y los flotadores / dobles no se pueden comparar sin un yeso, mientras que los flotadores y los dobles sí. Los decimales también permiten la codificación o ceros finales.

float flt = 1F/3;
double dbl = 1D/3;
decimal dcm = 1M/3;
Console.WriteLine("float: {0} double: {1} decimal: {2}", flt, dbl, dcm);

Resultado:

float: 0.3333333  
double: 0.333333333333333  
decimal: 0.3333333333333333333333333333

La estructura decimal está estrictamente orientada a cálculos financieros que requieren precisión, que son relativamente intolerantes al redondeo. Los decimales no son adecuados para aplicaciones científicas, sin embargo, por varias razones:

• Una cierta pérdida de precisión es aceptable en muchos cálculos científicos debido a los límites prácticos del problema físico o artefacto que se está midiendo. La pérdida de precisión no es aceptable en las finanzas.
• El decimal es mucho (mucho) más lento que el flotante y el doble para la mayoría de las operaciones, principalmente porque las operaciones de coma flotante se realizan en binario, mientras que el decimal se realiza en la base 10 (es decir, los flotadores y los dobles son manejados por el hardware de la FPU, como MMX / SSE , mientras que los decimales se calculan en software).
• Decimal tiene un rango de valores inaceptablemente menor que el doble, a pesar del hecho de que admite más dígitos de precisión. Por lo tanto, Decimal no se puede usar para representar muchos valores científicos.

+---------+----------------+---------+----------+---------------------------------------------+
| C#      | .Net Framework | Signed? | Bytes    | Possible Values                             |
| Type    | (System) type  |         | Occupied |                                             |
+---------+----------------+---------+----------+---------------------------------------------+
| sbyte   | System.Sbyte   | Yes     | 1        | -128 to 127                                 |
| short   | System.Int16   | Yes     | 2        | -32768 to 32767                             |
| int     | System.Int32   | Yes     | 4        | -2147483648 to 2147483647                   |
| long    | System.Int64   | Yes     | 8        | -9223372036854775808 to 9223372036854775807 |
| byte    | System.Byte    | No      | 1        | 0 to 255                                    |
| ushort  | System.Uint16  | No      | 2        | 0 to 65535                                  |
| uint    | System.UInt32  | No      | 4        | 0 to 4294967295                             |
| ulong   | System.Uint64  | No      | 8        | 0 to 18446744073709551615                   |
| float   | System.Single  | Yes     | 4        | Approximately ±1.5 x 10-45 to ±3.4 x 1038   |
|         |                |         |          |  with 7 significant figures                 |
| double  | System.Double  | Yes     | 8        | Approximately ±5.0 x 10-324 to ±1.7 x 10308 |
|         |                |         |          |  with 15 or 16 significant figures          |
| decimal | System.Decimal | Yes     | 12       | Approximately ±1.0 x 10-28 to ±7.9 x 1028   |
|         |                |         |          |  with 28 or 29 significant figures          |
| char    | System.Char    | N/A     | 2        | Any Unicode character (16 bit)              |
| bool    | System.Boolean | N/A     | 1 / 2    | true or false                               |
+---------+----------------+---------+----------+---------------------------------------------+

Ver aquí para más información .

No reiteraré toneladas de buena (y alguna mala) información ya respondida en otras respuestas y comentarios, pero responderé su pregunta de seguimiento con un consejo:

¿Cuándo alguien usaría uno de estos?

Usar decimal para valores contados

Use flotante / doble para valores medidos

Algunos ejemplos:

• dinero (¿contamos dinero o medimos dinero?)

• distancia (¿contamos la distancia o medimos la distancia? *)

• puntajes (¿contamos puntajes o medimos puntajes?)

Siempre contamos el dinero y nunca debemos medirlo. Usualmente medimos la distancia. A menudo contamos los puntajes.

* En algunos casos, lo que yo llamaría distancia nominal , es posible que deseemos 'contar' la distancia. Por ejemplo, tal vez estamos tratando con signos de país que muestran distancias a ciudades, y sabemos que esas distancias nunca tienen más de un dígito decimal (xxx.x km).

float 7 dígitos de precisión

double tiene unos 15 dígitos de precisión

decimal tiene unos 28 dígitos de precisión

Si necesita una mayor precisión, use doble en lugar de flotante. En las CPU modernas, ambos tipos de datos tienen casi el mismo rendimiento. El único beneficio de usar flotador es que ocupan menos espacio. Prácticamente solo importa si tienes muchos de ellos.

Encontré que esto es interesante. Lo que todo informático debe saber sobre la aritmética de coma flotante

Nadie ha mencionado eso

En la configuración predeterminada, los flotantes (System.Single) y los dobles (System.Double) nunca usarán la verificación de desbordamiento, mientras que Decimal (System.Decimal) siempre usará la verificación de desbordamiento.

quiero decir

decimal myNumber = decimal.MaxValue;
myNumber += 1;

lanza OverflowException .

Pero estos no:

float myNumber = float.MaxValue;
myNumber += 1;

Y

double myNumber = double.MaxValue;
myNumber += 1;

1. Double y float se pueden dividir por entero cero sin una excepción tanto en la compilación como en el tiempo de ejecución.
2. El decimal no se puede dividir por el entero cero. La compilación siempre fallará si haces eso.

Los enteros, como se mencionó, son números enteros. No pueden almacenar el punto algo, como .7, .42 y .007. Si necesita almacenar números que no son números enteros, necesita un tipo diferente de variable. Puede usar el tipo doble o el tipo flotante. Configura estos tipos de variables exactamente de la misma manera: en lugar de usar la palabra int, escribe doubleo float. Me gusta esto:

float myFloat;
double myDouble;

( floates la abreviatura de "punto flotante", y solo significa un número con un punto algo al final).

La diferencia entre los dos está en el tamaño de los números que pueden contener. Para float, puede tener hasta 7 dígitos en su número. Para doubles, puede tener hasta 16 dígitos. Para ser más precisos, aquí está el tamaño oficial:

float:  1.5 × 10^-45  to 3.4 × 10^38  
double: 5.0 × 10^-324 to 1.7 × 10^308

floates un número de 32 bits y doublees un número de 64 bits.

Haga doble clic en su nuevo botón para obtener el código. Agregue las siguientes tres líneas a su código de botón:

double myDouble;
myDouble = 0.007;
MessageBox.Show(myDouble.ToString());

Detenga su programa y regrese a la ventana de codificación. Cambia esta línea:

myDouble = 0.007;
myDouble = 12345678.1234567;

Ejecute su programa y haga clic en su botón doble. El cuadro de mensaje muestra correctamente el número. Sin embargo, agregue otro número al final y C # nuevamente se redondeará hacia arriba o hacia abajo. La moraleja es que si quieres precisión, ¡ten cuidado de redondear!

• flotante: ± 1.5 x 10 ^ -45 a ± 3.4 x 10 ^ 38 (~ 7 cifras significativas
• doble: ± 5.0 x 10 ^ -324 a ± 1.7 x 10 ^ 308 (15-16 cifras significativas)
• decimal: ± 1.0 x 10 ^ -28 a ± 7.9 x 10 ^ 28 (28-29 cifras significativas)

Este ha sido un hilo interesante para mí, ya que hoy, hemos tenido un pequeño error desagradable, con respecto a decimaltener menos precisión que a float.

En nuestro código C #, leemos valores numéricos de una hoja de cálculo de Excel, los convertimos en a decimaly luego los enviamos de decimalvuelta a un Servicio para guardarlos en una base de datos de SQL Server .

Microsoft.Office.Interop.Excel.Range cell = …
object cellValue = cell.Value2;
if (cellValue != null)
{
    decimal value = 0;
    Decimal.TryParse(cellValue.ToString(), out value);
}

Ahora, para casi todos nuestros valores de Excel, esto funcionó maravillosamente. Pero para algunos valores de Excel muy pequeños, el uso decimal.TryParseperdió el valor por completo. Uno de esos ejemplos es

• cellValue = 0.00006317592

• Decimal. TryParse (cellValue.ToString (), valor de salida); // devolvería 0

La solución, extrañamente, fue convertir los valores de Excel en un doubleprimero, y luego en un decimal:

Microsoft.Office.Interop.Excel.Range cell = …
object cellValue = cell.Value2;
if (cellValue != null)
{
    double valueDouble = 0;
    double.TryParse(cellValue.ToString(), out valueDouble);
    decimal value = (decimal) valueDouble;
    …
}

A pesar de que doubletiene menos precisión que a decimal, esto realmente aseguró que aún se reconocerían números pequeños. Por alguna razón, double.TryParsefue capaz de recuperar números tan pequeños, mientras decimal.TryParseque los puso a cero.

Impar. Muy raro.

Para aplicaciones como juegos y sistemas embebidos donde la memoria y el rendimiento son críticos, el flotante suele ser el tipo numérico de elección, ya que es más rápido y la mitad del tamaño de un doble. Los enteros solían ser el arma preferida, pero el rendimiento de coma flotante ha superado a los enteros en los procesadores modernos. ¡Decimal ya está listo!

Los tipos de variable Decimal, Double y Float son diferentes en la forma en que almacenan los valores. La precisión es la principal diferencia donde flotante es un tipo de datos de coma flotante de precisión simple (32 bits), el doble es un tipo de datos de coma flotante de doble precisión (64 bits) y el decimal es un tipo de datos de coma flotante de 128 bits.

Flotador: 32 bits (7 dígitos)

Doble - 64 bit (15-16 dígitos)

Decimal: 128 bits (28-29 dígitos significativos)

Más sobre ... la diferencia entre Decimal, Float y Double

El problema con todos estos tipos es que subsiste una cierta imprecisión Y que este problema puede ocurrir con números decimales pequeños como en el siguiente ejemplo

Dim fMean as Double = 1.18
Dim fDelta as Double = 0.08
Dim fLimit as Double = 1.1

If fMean - fDelta < fLimit Then
    bLower = True
Else
    bLower = False
End If

Pregunta: ¿Qué valor contiene la variable bLower?

Respuesta: ¡En una máquina de 32 bits, bLower contiene VERDADERO!

Si reemplazo Double por Decimal, bLower contiene FALSE, que es la buena respuesta.

En doble, el problema es que fMean-fDelta = 1.09999999999 que es menor que 1.1.

Precaución: Creo que el mismo problema ciertamente puede existir para otro número porque Decimal es solo un doble con mayor precisión y la precisión siempre tiene un límite.

De hecho, ¡Double, Float y Decimal corresponden al decimal BINARIO en COBOL!

Es lamentable que otros tipos numéricos implementados en COBOL no existan en .Net. Para aquellos que no conocen COBOL, existen en COBOL después del tipo numérico

BINARY or COMP like float or double or decimal
PACKED-DECIMAL or COMP-3 (2 digit in 1 byte)
ZONED-DECIMAL (1 digit in 1 byte) 

En palabras simples:

1. Los tipos de variable Decimal, Double y Float son diferentes en la forma en que almacenan los valores.
2. La precisión es la principal diferencia (tenga en cuenta que esta no es la única diferencia) donde flotante es un tipo de datos de coma flotante de precisión simple (32 bits), doble es un tipo de datos de coma flotante de precisión doble (64 bits) y decimal es un 128 bits tipo de datos de punto flotante.
3. La tabla resumen:

/==========================================================================================
    Type       Bits    Have up to                   Approximate Range 
/==========================================================================================
    float      32      7 digits                     -3.4 × 10 ^ (38)   to +3.4 × 10 ^ (38)
    double     64      15-16 digits                 ±5.0 × 10 ^ (-324) to ±1.7 × 10 ^ (308)
    decimal    128     28-29 significant digits     ±7.9 x 10 ^ (28) or (1 to 10 ^ (28)
/==========================================================================================

La principal diferencia entre cada uno de estos es la precisión.

floates un 32-bitnúmero, doublees un 64-bitnúmero y decimales un 128-bitnúmero.

• Decimal de 128 bits (28-29 dígitos significativos) En el caso de aplicaciones financieras, es mejor usar tipos decimales porque le brinda un alto nivel de precisión y es fácil evitar errores de redondeo. Use decimal para cálculos no enteros donde se necesita precisión (p. Ej. dinero y moneda)

• Doble tipo de 64 bits (15-16 dígitos) Los tipos dobles son probablemente el tipo de datos más utilizado para valores reales, excepto el manejo de dinero. Use el doble para las matemáticas no enteras donde la respuesta más precisa no es necesaria.

• Flotante de 32 bits (7 dígitos) Se utiliza principalmente en bibliotecas gráficas porque las demandas de potencia de procesamiento son muy altas, también se utilizan situaciones que pueden soportar errores de redondeo.

Decimals son mucho más lentos que un double/float .

Decimalsy Floats/Doublesno se puede comparar sin un yeso mientras que FloatsyDoubles puede.

Decimals también permite la codificación o ceros finales.

Para definir decimal, flotante y doble en .Net (c #)

debe mencionar valores como:

Decimal dec = 12M/6;
Double dbl = 11D/6;
float fl = 15F/6;

y verifica los resultados.

Y los bytes ocupados por cada uno son

Float - 4
Double - 8
Decimal - 12