Différence entre décimal, float et double dans .NET?

StackOverflow https://stackoverflow.com/questions/618535

Question

Quelle est la différence entre décimal , float et double dans .NET?

Quand quelqu'un utilisera-t-il l'un de ceux-ci?

Était-ce utile?

La solution

float et double sont flottant < em> types de points binaires . En d'autres termes, ils représentent un nombre comme celui-ci: 

10001.10010110011

Le nombre binaire et l'emplacement du point binaire sont tous deux codés dans la valeur.

décimal est un point décimal flottant . tapez . En d'autres termes, ils représentent un nombre comme celui-ci: 

12345.65789

Encore une fois, le nombre et l'emplacement du point décimal sont tous deux codés dans la valeur - c'est ce qui fait que décimal reste un type à virgule flottante au lieu d'un type à virgule fixe .

La chose importante à noter est que les humains sont habitués à représenter des non-entiers sous forme décimale et attendent des résultats exacts sous forme de représentations décimales; tous les nombres décimaux ne sont pas exactement représentables en virgule flottante binaire - 0,1 par exemple - donc si vous utilisez une valeur à virgule flottante binaire, vous obtiendrez une approximation de 0,1. Vous aurez toujours des approximations lorsque vous utilisez également une virgule décimale flottante - le résultat de la division de 1 par 3 ne peut pas être représenté exactement, par exemple.

Quant à savoir quoi utiliser quand:

  • Pour les valeurs qui sont des "décimales naturellement exactes" il est bon d’utiliser décimal . Cela convient généralement à tous les concepts inventés par l'homme: les valeurs financières en sont l'exemple le plus évident, mais il en existe d'autres aussi. Considérez par exemple le score attribué aux plongeurs ou aux patineurs.

  • Pour les valeurs qui sont davantage des artefacts de la nature qui ne peuvent vraiment pas être mesurés exactement , float / double sont davantage approprié. Par exemple, les données scientifiques seraient généralement représentées sous cette forme. Ici, les valeurs d'origine ne seront pas "décimalement précises". pour commencer, il n’est donc pas important pour les résultats escomptés de conserver la "précision décimale". Les types de points binaires flottants sont beaucoup plus rapides à utiliser que les décimales.

Autres conseils

La précision est la principale différence.

Flotteur - 7 chiffres (32 bits)

Double -15-16 chiffres (64 bits)

Décimal -28-29 chiffres significatifs (128 bits) )

Les décimales ont une précision beaucoup plus élevée et sont généralement utilisées dans les applications financières qui nécessitent un degré élevé de précision. Les décimales sont beaucoup plus lentes (jusqu'à 20 fois plus souvent dans certains tests) qu'un double / float.

Les nombres décimaux et les flotteurs / doubles ne peuvent être comparés sans la distribution, alors que les flotteurs et les doubles le peuvent. Les décimales permettent également le codage ou les zéros de fin. 

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

Résultat: 

float: 0.3333333  
double: 0.333333333333333  
decimal: 0.3333333333333333333333333333

La structure décimale est strictement axée sur les calculs financiers exigeant une précision, qui sont relativement intolérants à l’arrondi. Les décimales ne conviennent pas aux applications scientifiques, mais pour plusieurs raisons:

  • Dans de nombreux calculs scientifiques, une certaine perte de précision est acceptable en raison des limites pratiques du problème physique ou de l’artéfact mesuré. La perte de précision n’est pas acceptable en finance.
  • Le nombre décimal est beaucoup (beaucoup) plus lent que float et double pour la plupart des opérations, principalement parce que les opérations à virgule flottante sont effectuées en binaire, alors que les commandes décimales sont effectuées en base 10 (les flottants et les doubles sont gérés par le matériel de la FPU, tels que MMX / SSE, alors que les décimales sont calculées dans le logiciel).
  • Le nombre décimal a une plage de valeurs inacceptablement inférieure au double, malgré le fait qu’il supporte plus de chiffres de précision. Par conséquent, Decimal ne peut pas être utilisé pour représenter de nombreuses valeurs scientifiques. 
+---------+----------------+---------+----------+---------------------------------------------+
| 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                               |
+---------+----------------+---------+----------+---------------------------------------------+

Pour plus d'informations, voir:
http: //social.msdn .microsoft.com / Forums / fr-FR / csharpgeneral / thread / 921a8ffc-9829-4145-bdc9-a96c1ec174a5

float 7 chiffres de précision

double a environ 15 chiffres de précision

décimal a environ 28 chiffres de précision

Si vous avez besoin d’une plus grande précision, utilisez double au lieu de float. Dans les CPU modernes, les deux types de données ont presque les mêmes performances. Le seul avantage de l'utilisation de float est qu'ils prennent moins de place. Ne compte pratiquement que si vous en avez beaucoup.

J'ai trouvé cela intéressant. Ce que tout informaticien devrait savoir sur l'arithmétique à virgule flottante

Je ne répéterai pas des tonnes de bonnes (et de quelques mauvaises) informations déjà répondues dans d'autres réponses et commentaires, mais je répondrai à votre question suivante par un conseil:

  

Quand quelqu'un utiliserait-il l'un de ces logiciels?

Utiliser le nombre décimal pour les comptés valeurs

Utilisez float / double pour les valeurs mesurées

.

Quelques exemples:

  • argent (compte-t-on de l'argent ou le mesurons-nous?)

  • distance (comptons-nous la distance ou mesurons-nous la distance? *)

  • scores (comptons-nous les scores ou mesurons-nous les scores?)

Nous comptons toujours de l'argent et ne devrions jamais le mesurer. Nous mesurons habituellement la distance. Nous comptons souvent des scores.

* Dans certains cas, ce que j'appellerais distance nominale , nous pouvons en effet vouloir "compter" la distance. Par exemple, nous avons peut-être affaire à des panneaux de pays indiquant les distances par rapport aux villes, et nous savons que ces distances ne comportent jamais plus d’un chiffre décimal (xxx.x km).

Personne n'a mentionné que

  

Par défaut, Floats (System.Single) et doubles (System.Double) ne seront jamais utilisés.   contrôle de débordement alors que Decimal (System.Decimal) utilisera toujours   vérification de débordement.

je veux dire 

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

lève OverflowException .

Mais ce n'est pas le cas: 

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

& amp; 

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

Les entiers, comme il a été mentionné, sont des nombres entiers. Ils ne peuvent pas stocker le point quelque chose, comme .7, .42 et .007. Si vous devez stocker des nombres qui ne sont pas des nombres entiers, vous avez besoin d'un type de variable différent. Vous pouvez utiliser le type double ou le type float. Vous définissez ces types de variables de la même manière: au lieu d’utiliser le mot int , vous tapez double ou float . Comme ceci: 

float myFloat;
double myDouble;

( float est l'abréviation de "virgule flottante", et signifie simplement un nombre avec un point quelque chose à la fin.)

La différence entre les deux réside dans la taille des nombres qu’ils peuvent contenir. Pour float , vous pouvez avoir jusqu'à 7 chiffres dans votre numéro. Pour les doubles , vous pouvez avoir jusqu'à 16 chiffres. Pour être plus précis, voici la taille officielle: 

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

float est un nombre 32 bits et double est un nombre 64 bits.

Double-cliquez sur votre nouveau bouton pour accéder au code. Ajoutez les trois lignes suivantes à votre code de bouton: 

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

Arrêtez votre programme et retournez à la fenêtre de codage. Changer cette ligne: 

myDouble = 0.007;
myDouble = 12345678.1234567;

Lancez votre programme et cliquez sur votre double bouton. La boîte de message affiche correctement le numéro. Ajoutez un autre numéro à la fin, cependant, et C # sera arrondi à nouveau. La morale est que si vous voulez de l'exactitude, faites attention à l'arrondi!

  1. Double et float peuvent être divisés par un entier zéro sans exception à la fois lors de la compilation et de l'exécution.
  2. Le nombre décimal ne peut pas être divisé par un nombre entier zéro. La compilation échouera toujours si vous le faites.

Cela a été un sujet intéressant pour moi, car aujourd’hui, nous avons un petit bug méchant, concernant décimal ayant moins de précision qu’un float .

Dans notre code C #, nous lisons des valeurs numériques dans une feuille de calcul Excel, nous les convertissons en un décimal , puis nous renvoyons ce décimal à un service pour le sauvegarder dans un fichier. Base de données SQL Server . 

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

Maintenant, pour la quasi-totalité de nos valeurs Excel, cela a fonctionné à merveille. Mais pour certaines valeurs Excel très petites, l’utilisation de decimal.TryParse a complètement perdu la valeur. Un tel exemple est

  • cellValue = 0,00006317592

  • Decimal.TryParse (cellValue.ToString (), valeur out); // renverrait 0

La solution, bizarrement, était de convertir les valeurs Excel en un double , puis en un décimal : 

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;
    …
}

Même si double a moins de précision qu'un décimal , cela garantit en fait que les petits nombres seront toujours reconnus. Pour une raison quelconque, double.TryParse était en mesure de récupérer des nombres aussi petits, alors que decimal.TryParse définissait les mettre à zéro.

Bizarre. Très étrange.

  • float: & # 177; 1,5 x 10 ^ -45 à & 177; 3,4 x 10 ^ 38 (~ 7 chiffres significatifs
  • double: & # 177; 5,0 x 10 ^ -324 à & 177; 1,7 x 10 ^ 308 (15 à 16 chiffres significatifs)
  • décimal: 1,0 x 10 ^ -28 à 7,9 x 10 ^ 28 (28-29 chiffres significatifs)

Pour les applications telles que les jeux et les systèmes embarqués où la mémoire et les performances sont essentielles, float est généralement le type de choix numérique, car il est plus rapide et double de la taille d'un double. Les entiers étaient l’arme de choix, mais les performances en virgule flottante ont dépassé les entiers des processeurs modernes. La décimale est juste dehors!

Les types de variable Decimal, Double et Float sont différents dans la manière dont ils stockent les valeurs. La précision est la principale différence où float est un type de données à virgule flottante simple précision (32 bits), double est un type de données à virgule flottante double précision (64 bits) et decimal est un type de données à virgule flottante 128 bits.

Flottant - 32 bits (7 chiffres)

Double - 64 bits (15-16 chiffres)

Décimal - 128 bits (28 à 29 chiffres significatifs)

En savoir plus sur ... la différence entre Decimal, Float et Double

Le problème avec tous ces types est qu’une certaine imprécision subsiste ET que ce problème puisse se produire avec de petits nombres décimaux, comme dans l'exemple suivant 

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

Question: Quelle valeur la variable bLower contient-elle?

Réponse: sur une machine 32 bits, bLower contient TRUE !!!

Si je remplace Double par Decimal, bLower contient FALSE, ce qui est la bonne réponse.

En double, le problème est que fMean-fDelta = 1.09999999999 est inférieur à 1.1.

Attention: Je pense que le même problème peut certainement exister pour d'autres nombres, car Decimal n'est qu'un double avec une précision supérieure et la précision a toujours une limite.

En fait, Double, Float et Decimal correspondent à BINARY decimal en COBOL!

Il est regrettable que d’autres types numériques implémentés dans COBOL n’existent pas dans .Net. Pour ceux qui ne connaissent pas COBOL, il existe en COBOL le type numérique suivant 

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 termes simples:

  1. Les types de variable Decimal, Double et Float sont différents dans la manière dont ils stockent les valeurs.
  2. La précision est la différence principale (notez qu'il ne s'agit pas de la différence unique), où float correspond à un flottant simple précision (32 bits) type de données en point, double est un type de données à virgule flottante à double précision (64 bits) et décimal est un type de données à virgule flottante de 128 bits.
  3. Le tableau récapitulatif: 

/==========================================================================================
    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)
/==========================================================================================
Vous pouvez lire davantage de ici , Float , Double , et Decimal .

La principale différence entre chacun d'eux est la précision.

float est un numéro 32 bits , double est un numéro 64 bits et decimal est un 128 bits .

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top