Diferença entre decimal, float e double no .net?

Qual é a diferença entre decimal, floate doubleem .NET?

Quando alguém usaria um desses?

floate doublesão tipos de pontos binários flutuantes . Em outras palavras, eles representam um número como este:

10001.10010110011

O número binário e a localização do ponto binário são ambos codificados no valor.

decimalé um tipo de ponto decimal flutuante . Em outras palavras, eles representam um número como este:

12345.65789

Novamente, o número e a localização do ponto decimal são codificados no valor - é o que torna decimalainda um tipo de ponto flutuante em vez de um tipo de ponto fixo.

O importante a ser observado é que os humanos estão acostumados a representar não-inteiros em uma forma decimal e esperam resultados exatos em representações decimais; nem todos os números decimais são exatamente representáveis ​​no ponto flutuante binário - 0,1, por exemplo -, portanto, se você usar um valor de ponto flutuante binário, obterá uma aproximação de 0,1. Você ainda obterá aproximações ao usar um ponto decimal flutuante - o resultado da divisão de 1 por 3 não pode ser exatamente representado, por exemplo.

Quanto ao que usar quando:

• Para valores que são "decimais naturalmente exatos", é bom usar decimal. Isso geralmente é adequado para qualquer conceito inventado por humanos: os valores financeiros são o exemplo mais óbvio, mas também existem outros. Considere a pontuação atribuída a mergulhadores ou patinadores no gelo, por exemplo.

• Para valores que são mais artefactos da natureza que não pode realmente ser medidos exatamente de qualquer maneira, float/ doublesão mais apropriadas. Por exemplo, dados científicos geralmente seriam representados neste formulário. Aqui, os valores originais não serão "decimais precisos" para começar, portanto, não é importante que os resultados esperados mantenham a "precisão decimal". Os tipos de ponto binário flutuante são muito mais rápidos do que os decimais.

Precisão é a principal diferença.

Flutuador - 7 dígitos (32 bits)

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

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

Os decimais têm uma precisão muito maior e geralmente são usados ​​em aplicativos financeiros que exigem um alto grau de precisão. Os decimais são muito mais lentos (até 20 vezes mais em alguns testes) do que um double / float.

Decimais e Bóias / Dobros não podem ser comparados sem um elenco, enquanto Bóias e Dobros podem. Os decimais também permitem a codificação ou zeros à direita.

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

A estrutura decimal é estritamente voltada para cálculos financeiros que exigem precisão, que são relativamente intolerantes ao arredondamento. Os decimais não são adequados para aplicações científicas, no entanto, por várias razões:

• Uma certa perda de precisão é aceitável em muitos cálculos científicos devido aos limites práticos do problema ou artefato físico sendo medido. Perda de precisão não é aceitável em finanças.
• Decimal é muito (muito) mais lento que float e duplicado para a maioria das operações, principalmente porque as operações de ponto flutuante são feitas em binário, enquanto as coisas decimais são feitas na base 10 (ou seja, flutuações e duplas são tratadas pelo hardware da FPU, como MMX / SSE , enquanto os decimais são calculados em software).
• O decimal tem uma faixa de valor inaceitavelmente menor que o dobro, apesar de suportar mais dígitos de precisão. Portanto, Decimal não pode ser usado para representar muitos 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                               |
+---------+----------------+---------+----------+---------------------------------------------+

Veja aqui para mais informações .

Não reiterarei toneladas de informações boas (e ruins) já respondidas em outras respostas e comentários, mas responderei sua pergunta de acompanhamento com uma dica:

Quando alguém usaria um desses?

Use decimal para valores contados

Use float / double para valores medidos

Alguns exemplos:

• dinheiro (contamos dinheiro ou medimos dinheiro?)

• distance (contamos distância ou medimos distância? *)

• pontuações (contamos pontuações ou medimos pontuações?)

Sempre contamos dinheiro e nunca devemos medi-lo. Normalmente medimos a distância. Contamos frequentemente pontuações.

* Em alguns casos, o que eu chamaria de distância nominal , podemos realmente querer 'contar' a distância. Por exemplo, talvez estejamos lidando com sinais de países que mostram distâncias para cidades e sabemos que essas distâncias nunca têm mais de um dígito decimal (xxx.x km).

float 7 dígitos de precisão

double tem cerca de 15 dígitos de precisão

decimal tem cerca de 28 dígitos de precisão

Se você precisar de uma precisão melhor, use duplo em vez de flutuar. Nas CPUs modernas, os dois tipos de dados têm quase o mesmo desempenho. O único benefício de usar float é que eles ocupam menos espaço. Praticamente importa apenas se você tiver muitos deles.

Achei isso interessante. O que todo cientista da computação deve saber sobre aritmética de ponto flutuante

Ninguém mencionou isso

Nas configurações padrão, os flutuadores (System.Single) e os duplos (System.Double) nunca usarão a verificação de estouro, enquanto Decimal (System.Decimal) sempre usará a verificação de estouro.

Quero dizer

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

lança OverflowException .

Mas estes não:

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

&

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

1. Double e float podem ser divididos pelo número inteiro zero, sem uma exceção, tanto na compilação quanto no tempo de execução.
2. O decimal não pode ser dividido pelo número inteiro zero. A compilação sempre falhará se você fizer isso.

Inteiros, como foi mencionado, são números inteiros. Eles não podem armazenar algo do ponto, como 0,7, 0,42 e 0,007. Se você precisar armazenar números que não sejam números inteiros, precisará de um tipo diferente de variável. Você pode usar o tipo duplo ou flutuante. Você configura esses tipos de variáveis ​​exatamente da mesma maneira: em vez de usar a palavra int, você digita doubleou float. Como isso:

float myFloat;
double myDouble;

( floaté a abreviação de "ponto flutuante" e significa apenas um número com um ponto no final.)

A diferença entre os dois está no tamanho dos números que eles podem conter. Para float, você pode ter até 7 dígitos no seu número. Para doubles, você pode ter até 16 dígitos. Para ser mais preciso, eis o tamanho oficial:

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

floaté um número de 32 bits e doubleé um número de 64 bits.

Clique duas vezes no seu novo botão para obter o código. Adicione as três linhas a seguir ao código do botão:

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

Pare o seu programa e retorne à janela de codificação. Mude esta linha:

myDouble = 0.007;
myDouble = 12345678.1234567;

Execute seu programa e clique no botão duplo. A caixa de mensagem exibe corretamente o número. Adicione outro número no final, porém, e o C # será novamente arredondado para cima ou para baixo. A moral é que se você quer precisão, tenha cuidado ao arredondar!

• float: ± 1,5 x 10 ^ -45 a ± 3,4 x 10 ^ 38 (~ 7 números significativos
• duplo: ± 5,0 x 10 ^ -324 a ± 1,7 x 10 ^ 308 (15-16 figuras significativas)
• decimal: ± 1,0 x 10 ^ -28 a ± 7,9 x 10 ^ 28 (28-29 algarismos significativos)

Esta tem sido uma discussão interessante para mim, pois hoje, tivemos apenas um bug desagradável, por decimalter menos precisão que a float.

Em nosso código C #, estamos lendo valores numéricos de uma planilha do Excel, convertendo-os em um decimale enviando-os decimalnovamente para um Serviço para salvar em um banco de dados do SQL Server .

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

Agora, para quase todos os nossos valores do Excel, isso funcionou perfeitamente. Mas, para alguns valores muito pequenos do Excel, o uso decimal.TryParsedo valor foi perdido completamente. Um exemplo é

• cellValue = 0.00006317592

• Decimal.TryParse (cellValue.ToString (), valor out); // retornaria 0

A solução, estranhamente, foi converter os valores do Excel em um doubleprimeiro e depois em um 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;
    …
}

Embora doubletenha menos precisão que a decimal, isso realmente garantiu que pequenos números ainda seriam reconhecidos. Por alguma razão, double.TryParsefoi realmente capaz de recuperar números tão pequenos, enquanto decimal.TryParseos definiria como zero.

Ímpar. Muito estranho.

Para aplicativos como jogos e sistemas incorporados nos quais a memória e o desempenho são críticos, o float geralmente é o tipo numérico de escolha, pois é mais rápido e tem a metade do tamanho de um dobro. Os números inteiros costumavam ser a arma preferida, mas o desempenho do ponto flutuante ultrapassou o número inteiro nos processadores modernos. Decimal está certo!

Os tipos de variável Decimal, Double e Float são diferentes na maneira como eles armazenam os valores. Precisão é a principal diferença em que float é um tipo de dados de ponto flutuante de precisão única (32 bits), double é um tipo de dados de ponto flutuante de precisão dupla (64 bits) e decimal é um tipo de dados de ponto flutuante de 128 bits.

Flutuador - 32 bits (7 dígitos)

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

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

Mais sobre ... a diferença entre Decimal, Float e Double

O problema com todos esses tipos é que uma certa imprecisão subsiste E que esse problema pode ocorrer com pequenos números decimais, como no exemplo a seguir

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

Pergunta: Qual valor a variável bLower contém?

Resposta: Em uma máquina de 32 bits, o bLower contém VERDADEIRO !!!

Se substituir Double por Decimal, o bLower conterá FALSE, que é a boa resposta.

Em dobro, o problema é que fMean-fDelta = 1.09999999999 é menor que 1.1.

Cuidado: Eu acho que esse mesmo problema certamente pode existir para outro número, porque Decimal é apenas um duplo com maior precisão e a precisão sempre tem um limite.

De fato, Double, Float e Decimal correspondem ao decimal BINARY em COBOL!

É lamentável que outros tipos numéricos implementados no COBOL não existam no .Net. Para aqueles que não conhecem COBOL, existem em COBOL seguindo o 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) 

Em palavras simples:

1. Os tipos de variável Decimal, Double e Float são diferentes na maneira como eles armazenam os valores.
2. Precisão é a principal diferença (observe que essa não é a única diferença) em que float é um tipo de dados de ponto flutuante de precisão única (32 bits), double é um tipo de dados de ponto flutuante de precisão dupla (64 bits) e decimal é 128 bits tipo de dados de ponto flutuante.
3. A tabela de resumo:

/==========================================================================================
    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)
/==========================================================================================

A principal diferença entre cada um deles é a precisão.

floaté um 32-bitnúmero, doubleé um 64-bitnúmero e decimalé um 128-bitnúmero.

• Decimal de 128 bits (28-29 dígitos significativos) No caso de aplicativos financeiros, é melhor usar os tipos decimais, pois fornece um alto nível de precisão e é fácil evitar erros de arredondamento. Use decimal para matemática não inteira onde a precisão é necessária (por exemplo, dinheiro e moeda)

• Tipo duplo de 64 bits (15 a 16 dígitos) Os tipos duplos são provavelmente o tipo de dados mais usado para valores reais, exceto manipulando dinheiro. Use double para matemática não inteira, onde a resposta mais precisa não é necessária.

• Flutuar 32 bits (7 dígitos) É usado principalmente em bibliotecas gráficas, porque demandas muito altas de capacidade de processamento também usavam situações que podem suportar erros de arredondamento.

Decimalssão muito mais lentos que um double/float.

Decimalse Floats/Doublesnão pode ser comparado sem um elenco enquanto Floatse Doublespode.

Decimals também permite a codificação ou zeros à direita.

Para definir decimal, flutuar e dobrar em .Net (c #)

você deve mencionar valores como:

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

e verifique os resultados.

E os bytes ocupados por cada um são

Float - 4
Double - 8
Decimal - 12