Diferencia entre decimal, flotante y doble in.NET?

La precisión es la principal diferencia.

Float - 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 utilizan en aplicaciones financieras que requieren un alto grado de precisión. Los decimales son mucho más lentos (hasta 20 veces en algunas pruebas) que un double/float.

Los decimales y los Flotadores / Dobles no se pueden comparar sin un lanzamiento mientras que los Flotadores y los dobles pueden. Los decimales también permiten la codificación o los 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 finanzas.
• El decimal es mucho (mucho) más lento que float y double para la mayoría de las operaciones, principalmente porque las operaciones de coma flotante se realizan en binario, mientras que las cosas decimales se realizan en base 10 (es decir, los flotadores y los dobles son manejados por el hardware FPU, como MMX/SSE, mientras que los decimales se calculan en software).
• El 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 utilizar para representar muchos valores científicos.

Para más información puede ir a la fuente de esta imagen:

Http://social.msdn.microsoft.com/Forums/en-US/csharpgeneral/thread/921a8ffc-9829-4145-bdc9-a96c1ec174a5

float 7 dígitos de precisión

double tiene cerca de 15 dígitos de precisión

decimal tiene cerca de 28 dígitos de precisión

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

Me pareció que esto es interesante. Lo Que Todo Científico Informático Debe Saber Sobre El Punto Flotante Aritmética

Nadie ha mencionado que

En la configuración predeterminada, Flota (Sistema.Individual) y dobles (Sistema.Doble) nunca usará comprobación de desbordamiento mientras Decimal (Sistema.Decimal) siempre utilizará comprobación de desbordamiento.

Quiero decir

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

Lanza OverflowException.

Pero estos no:

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

&

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

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

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

Use decimal para contados valores

Use float / double para valores medidos

Algunos ejemplos:

• Dinero (¿contamos dinero o medimos dinero?)

• Distancia (contamos la distancia o medir la distancia? *)

• Puntuaciones (¿contamos las puntuaciones o medimos las puntuaciones?)

Siempre contamos el dinero y nunca debemos medirlo. Solemos medir la distancia. A menudo contamos las puntuaciones.

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

Los tipos de variable Decimal, Doble y Flotante son diferentes en la forma en que almacenan los valores. La precisión es la principal diferencia donde float es un tipo de datos de punto flotante de precisión única (32 bits), double es un tipo de datos de punto flotante de precisión doble (64 bits) y decimal es un tipo de datos de punto flotante de 128 bits.

Float-32 bit (7 dígitos)

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

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

La principal diferencia son los flotadores y los dobles son tipos binarios de punto flotante y un decimal almacenará el valor como un tipo de punto decimal flotante. Por lo tanto, los decimales tienen una precisión mucho mayor y generalmente se utilizan dentro de las aplicaciones de cálculo monetario (financiero) o científico que requieren un alto grado de precisión. Pero en cuanto al rendimiento, los decimales son más lentos que los tipos double y float.

El decimal puede representar con 100% de precisión cualquier número dentro de la precisión del formato decimal, mientras que Float y Double no pueden representar con precisión todos los números, incluso los números que están dentro de sus respectivos formatos de precisión.

Decimal

En caso de aplicaciones financieras, o cálculos científicos, es mejor usar tipos decimales porque le da un alto nivel de precisión y fácil de evitar errores de redondeo

Doble

Los tipos dobles son probablemente el tipo de datos más utilizado para los valores reales, excepto el manejo dinero.

Float

Se utiliza principalmente en bibliotecas gráficas debido a las altas demandas de potencia de procesamiento, también se utilizan situaciones que pueden soportar errores de redondeo.

1. Double y float se pueden dividir por entero cero sin excepción tanto en tiempo de compilación como de ejecución.
2. El decimal no se puede dividir por el número 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 utilizar 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 double o float. Así:

float myFloat;
double myDouble;

(float es la abreviatura de "punto flotante", y solo significa un número con un punto algo en 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 double s, 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

float es un número de 32 bits, y double es un número de 64 bits.

Haga doble clic en el botón nuevo 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 vuelva a la codificación ventana. Cambiar esta línea:

myDouble = 0.007;
myDouble = 12345678.1234567;

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

Este ha sido un hilo interesante para mí, ya que hoy, acabamos de tener un pequeño error desagradable, concerniente a decimal tener menos precisión que un float.

En nuestro código C#, estamos leyendo valores numéricos de una hoja de cálculo de Excel, convirtiéndolos en un decimal, luego enviando esto decimal de vuelta a un Servicio para guardarlo en una base de datos 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 de nuestros valores de Excel, esto funcionó maravillosamente. Pero para algunos, valores de Excel muy pequeños, utilizando decimal.TryParse perdió el valor por completo. Un ejemplo de ello es

• CellValue = 0.00006317592

• Decimal.TryParse (CellValue.toString (), out value); / / devolvería 0

La solución, extrañamente, fue convertir los valores de Excel en un double primero, 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 double tiene menos precisión que un decimal, esto en realidad aseguró que los números pequeños todavía serían reconocer. Por alguna razón, double.TryParse en realidad fue capaz de recuperar números tan pequeños, mientras que decimal.TryParse los pondría a cero.

Impar. Muy extraño.

Flotación ~ ±1,5 x 10-45 a ±3,4 x 1038 --------7 figuras
doble ~ ±5.0 x 10-324 a ±1.7 x 10308 ------15 o 16 cifras
decimal ~ ±1.0 x 10-28 a ±7.9 x 1028 --------28 o 29 figuras

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

Los tipos de variable Decimal, Doble y Flotante son diferentes en la forma en que almacenan los valores. La precisión es la principal diferencia donde float es un tipo de datos de punto flotante de precisión única (32 bits), double es un tipo de datos de punto flotante de precisión doble (64 bits) y decimal es un tipo de datos de punto flotante de 128 bits.

Float-32 bit (7 dígitos)

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

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

Más sobre... el diferencia entre Decimal, Flotante y Doble

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 el soplador contiene TRUE!!!

Si remplazo Doble por Decimal, bLower contiene FALSE que es la buena respuesta.

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

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

De hecho, Doble, Flotante 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 siguiendo el 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, Doble y Flotante son diferentes en la forma en que almacenan los valores.
2. La precisión es la diferencia principal (Observe que esta no es la única diferencia) donde float es un tipo de datos de punto flotante de precisión única (32 bits), double es un tipo de datos de punto flotante de precisión doble (64 bits) y decimal es un tipo de datos de punto flotante de 128 bits.
3. El resumen cuadro:

/==========================================================================================
    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 ellos es la precisión.

float es un número 32-bit, double es un número 64-bit y decimal es un número 128-bit.

También puede consultar la documentación aquí:

Https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/decimal

Https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/float

Https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/double