Differenza tra decimale, float e double in .NET?

Qual è la differenza tra decimal, floate doublein .NET?

Quando qualcuno userebbe uno di questi?

floate doublesono tipi di punti binari mobili . In altre parole, rappresentano un numero come questo:

10001.10010110011

Il numero binario e la posizione del punto binario sono entrambi codificati all'interno del valore.

decimalè un tipo di virgola decimale mobile . In altre parole, rappresentano un numero come questo:

12345.65789

Ancora una volta, il numero e la posizione del punto decimale sono entrambi codificati all'interno del valore: questo è ciò che rende decimalancora un tipo a virgola mobile anziché un tipo a virgola fissa.

La cosa importante da notare è che gli umani sono abituati a rappresentare numeri non interi in una forma decimale e si aspettano risultati esatti in rappresentazioni decimali; non tutti i numeri decimali sono esattamente rappresentabili in virgola mobile binaria, ad esempio 0,1, quindi se si utilizza un valore in virgola mobile binaria si ottiene effettivamente un'approssimazione a 0,1. Otterrai comunque approssimazioni anche usando un punto decimale mobile, ad esempio il risultato della divisione 1 per 3 non può essere rappresentato esattamente.

Per quanto riguarda cosa usare quando:

• Per valori che sono "decimali esatti per natura" è bene usarli decimal. Questo di solito è adatto a qualsiasi concetto inventato dall'uomo: i valori finanziari sono l'esempio più ovvio, ma ce ne sono anche altri. Considera, ad esempio, il punteggio assegnato ai subacquei o ai pattinatori su ghiaccio.

• Per i valori che sono più artefatti della natura che non possono essere misurati esattamente in ogni caso, float/ doublesono più appropriati. Ad esempio, i dati scientifici sarebbero di solito rappresentati in questo modulo. Qui, i valori originali non saranno "decimalmente precisi" per cominciare, quindi non è importante che i risultati previsti mantengano la "precisione decimale". I tipi di punti binari mobili sono molto più veloci con i decimali.

La precisione è la differenza principale.

Float - 7 cifre (32 bit)

Doppie -15-16 cifre (64 bit)

Decimali -28-29 cifre significative (128 bit)

I decimali hanno una precisione molto più elevata e vengono generalmente utilizzati all'interno di applicazioni finanziarie che richiedono un elevato grado di accuratezza. I decimali sono molto più lenti (fino a 20 volte volte in alcuni test) rispetto a un doppio / float.

Decimali e float / doppi non possono essere confrontati senza un cast, mentre i float e i doppi possono farlo. I decimali consentono anche la codifica o lo zero finale.

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

Risultato:

float: 0.3333333  
double: 0.333333333333333  
decimal: 0.3333333333333333333333333333

La struttura decimale è strettamente orientata ai calcoli finanziari che richiedono precisione, che sono relativamente intolleranti all'arrotondamento. I decimali non sono adeguati per le applicazioni scientifiche, tuttavia, per diversi motivi:

• Una certa perdita di precisione è accettabile in molti calcoli scientifici a causa dei limiti pratici del problema fisico o artefatto da misurare. La perdita di precisione non è accettabile in finanza.
• Il decimale è molto (molto) più lento del float e del doppio per la maggior parte delle operazioni, principalmente perché le operazioni in virgola mobile vengono eseguite in binario, mentre le operazioni decimali vengono eseguite in base 10 (ovvero float e double sono gestiti dall'hardware FPU, come MMX / SSE , mentre i decimali sono calcolati nel software).
• Il decimale ha un intervallo di valori inaccettabilmente inferiore rispetto al doppio, nonostante supporti più cifre di precisione. Pertanto, Decimal non può essere utilizzato per rappresentare molti valori scientifici.

+---------+----------------+---------+----------+---------------------------------------------+
| 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                               |
+---------+----------------+---------+----------+---------------------------------------------+

Vedi qui per maggiori informazioni .

Non ribadirò tonnellate di informazioni buone (e alcune cattive) già risposte in altre risposte e commenti, ma risponderò alla tua domanda di follow-up con un suggerimento:

Quando qualcuno userebbe uno di questi?

Usa i decimali per i valori conteggiati

Utilizzare float / double per i valori misurati

Qualche esempio:

• denaro (contiamo i soldi o misuriamo i soldi?)

• distanza (contiamo la distanza o misuriamo la distanza? *)

• punteggi (contiamo i punteggi o misuriamo i punteggi?)

Contiamo sempre il denaro e non dovremmo mai misurarlo. Di solito misuriamo la distanza. Contiamo spesso i punteggi.

* In alcuni casi, ciò che definirei distanza nominale , potremmo davvero voler "contare" la distanza. Ad esempio, forse abbiamo a che fare con segni di paesi che mostrano le distanze dalle città e sappiamo che tali distanze non hanno mai più di una cifra decimale (xxx.x km).

float 7 cifre di precisione

double ha circa 15 cifre di precisione

decimal ha circa 28 cifre di precisione

Se hai bisogno di una maggiore precisione, usa double invece di float. Nelle CPU moderne entrambi i tipi di dati hanno quasi le stesse prestazioni. L'unico vantaggio dell'utilizzo di float è che occupano meno spazio. Praticamente conta solo se ne hai molti.

Ho trovato questo interessante. Ciò che ogni scienziato informatico dovrebbe sapere sull'aritmetica a virgola mobile

Nessuno lo ha menzionato

Nelle impostazioni predefinite, Floats (System.Single) e doppi (System.Double) non useranno mai il controllo di overflow mentre Decimal (System.Decimal) utilizzerà sempre il controllo di overflow.

intendo

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

genera OverflowException .

Ma questi non:

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

&

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

1. Double e float possono essere divisi per zero intero senza eccezioni sia in fase di compilazione che di runtime.
2. Il decimale non può essere diviso per zero intero. La compilazione fallirà sempre se lo fai.

I numeri interi, come detto, sono numeri interi. Non possono memorizzare il punto qualcosa, come .7, .42 e .007. Se è necessario memorizzare numeri che non sono numeri interi, è necessario un diverso tipo di variabile. È possibile utilizzare il tipo doppio o il tipo float. Puoi impostare questi tipi di variabili esattamente nello stesso modo: invece di usare la parola int, digiti doubleo float. Come questo:

float myFloat;
double myDouble;

(float è l'abbreviazione di "virgola mobile" e significa solo un numero con un punto alla fine.)

La differenza tra i due sta nella dimensione dei numeri che possono contenere. Per float, puoi avere fino a 7 cifre nel tuo numero. Per doubles, puoi avere fino a 16 cifre. Per essere più precisi, ecco la dimensione ufficiale:

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

float è un numero a 32 bit e double è un numero a 64 bit.

Fare doppio clic sul nuovo pulsante per accedere al codice. Aggiungi le tre righe seguenti al codice del tuo pulsante:

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

Arrestare il programma e tornare alla finestra di codifica. Cambia questa riga:

myDouble = 0.007;
myDouble = 12345678.1234567;

Esegui il programma e fai clic sul doppio pulsante. La finestra di messaggio visualizza correttamente il numero. Aggiungi un altro numero alla fine, tuttavia, e C # arrotolerà nuovamente verso l'alto o verso il basso. La morale è se vuoi la precisione, stai attento a arrotondare!

• galleggiante: da ± 1,5 x 10 ^ da -45 a ± 3,4 x 10 ^ 38 (~ 7 cifre significative
• doppio: ± 5,0 x 10 ^ da -324 a ± 1,7 x 10 ^ 308 (15-16 cifre significative)
• decimale: ± 1,0 x 10 ^ da -28 a ± 7,9 x 10 ^ 28 (28-29 cifre significative)

Questo è stato un thread interessante per me, dato che oggi abbiamo appena avuto un brutto bug, per quanto riguarda decimalavere meno precisione di un float.

Nel nostro codice C #, stiamo leggendo valori numerici da un foglio di calcolo Excel, li convertiamo in un decimal, quindi li rispediamo decimala un servizio per salvarli in un database di SQL Server .

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

Ora, per quasi tutti i nostri valori di Excel, ha funzionato magnificamente. Ma per alcuni valori di Excel molto piccoli, l'utilizzo ha decimal.TryParseperso completamente il valore. Un esempio è

• cellValue = 0,00006317592

• Decimal.TryParse (cellValue.ToString (), valore out); // restituirebbe 0

La soluzione, stranamente, era convertire i valori di Excel in un doubleprimo e poi in 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;
    …
}

Anche se doubleha meno precisione di un decimal, questo in realtà assicura che piccoli numeri saranno comunque riconosciuti. Per qualche motivo, è double.TryParsestato effettivamente in grado di recuperare numeri così piccoli, mentre decimal.TryParseli avrebbe impostati a zero.

Dispari. Molto strano.

Per applicazioni come giochi e sistemi embedded in cui memoria e prestazioni sono entrambi fondamentali, il float è in genere il tipo di scelta numerica in quanto è più veloce e la metà delle dimensioni di un doppio. I numeri interi erano l'arma preferita, ma le prestazioni in virgola mobile hanno superato i numeri interi nei processori moderni. Decimale è subito!

I tipi di variabili Decimal, Double e Float sono diversi nel modo in cui memorizzano i valori. La precisione è la principale differenza in cui float è un tipo di dati a virgola mobile a precisione singola (32 bit), double è un tipo di dati a virgola mobile a precisione doppia (64 bit) e decimale è un tipo di dati a virgola mobile a 128 bit.

Float - 32 bit (7 cifre)

Doppio - 64 bit (15-16 cifre)

Decimale - 128 bit (28-29 cifre significative)

Maggiori informazioni su ... la differenza tra Decimale, Virgola mobile e Doppio

Il problema con tutti questi tipi è che sussiste una certa imprecisione E che questo problema può verificarsi con piccoli numeri decimali come nell'esempio seguente

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

Domanda: quale valore contiene la variabile bLower?

Risposta: su una macchina a 32 bit bLower contiene TRUE !!!

Se sostituisco Double con Decimal, bLower contiene FALSE che è la buona risposta.

In doppio, il problema è che fMean-fDelta = 1.09999999999 che è inferiore a 1.1.

Attenzione: penso che lo stesso problema possa certamente esistere per un altro numero perché Decimale è solo un doppio con maggiore precisione e la precisione ha sempre un limite.

In effetti, Double, Float e Decimal corrispondono al decimale BINARY in COBOL!

È deplorevole che altri tipi numerici implementati in COBOL non esistano in .Net. Per coloro che non conoscono COBOL, in COBOL esiste il seguente tipo numerico

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) 

In parole semplici:

1. I tipi di variabili Decimal, Double e Float sono diversi nel modo in cui memorizzano i valori.
2. La precisione è la differenza principale (si noti che questa non è la singola differenza) in cui float è un tipo di dati a virgola mobile a precisione singola (32 bit), double è un tipo di dati a virgola mobile a precisione doppia (64 bit) e decimale è a 128 bit tipo di dati in virgola mobile.
3. La tabella riassuntiva:

/==========================================================================================
    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 principale differenza tra ciascuno di questi è la precisione.

floatè un 32-bitnumero, doubleè un 64-bitnumero ed decimalè un 128-bitnumero.

• Decimale 128 bit (28-29 cifre significative) In caso di applicazioni finanziarie è meglio usare i tipi decimali perché offre un alto livello di accuratezza e facile da evitare errori di arrotondamento Utilizzare decimale per la matematica non intera dove è necessaria la precisione (ad es. denaro e valuta)

• Doppio 64 bit (15-16 cifre) I doppi tipi sono probabilmente il tipo di dati più comunemente usato per valori reali, ad eccezione della gestione del denaro. Usa double per la matematica non intera dove non è necessaria la risposta più precisa.

• Float a 32 bit (7 cifre) Viene utilizzato principalmente nelle librerie grafiche perché richieste molto elevate di potenza di elaborazione, utilizza anche situazioni che possono sopportare errori di arrotondamento.

Decimalssono molto più lenti di a double/float.

Decimalse Floats/Doublesnon può essere paragonato senza un cast mentre Floatse Doublespuò.

Decimals consentire anche la codifica o gli zeri finali.

Per definire Decimal, Float e Double in .Net (c #)

devi menzionare i valori come:

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

e controlla i risultati.

E i byte occupati da ciascuno sono

Float - 4
Double - 8
Decimal - 12