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

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

Quand quelqu’un utiliserait-il l’un de ces outils?

    float et double sont des types de points binarys flottants . En d’autres termes, ils représentent un nombre comme celui-ci:

     10001.10010110011 

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

    decimal est un type de point décimal flottant . 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 decimal rest 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 une forme décimale et attendent des résultats exacts dans les représentations décimales; tous les nombres décimaux ne sont pas exactement représentables en virgule flottante binary – 0.1, par exemple – donc si vous utilisez une valeur binary en virgule flottante, vous obtiendrez une approximation de 0.1. Vous obtiendrez toujours des approximations lors de l’utilisation d’un point décimal flottant – le résultat de la division de 1 par 3 ne peut pas être exactement représenté, par exemple.

    Quant à quoi utiliser quand:

    • Pour les valeurs qui sont “des décimales naturellement exactes”, il est bon d’utiliser des decimal . 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 y en a d’autres aussi. Considérez le score donné aux plongeurs ou aux patineurs, par exemple.

    • Pour des valeurs qui sont davantage des artefacts de la nature qui ne peuvent pas vraiment être mesurés de toute façon, float / double est plus 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 “précises” pour commencer, il n’est donc pas important que les résultats attendus conservent la “précision décimale”. Les types de points binarys flottants sont beaucoup plus rapides à utiliser que les nombres décimaux.

    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 sont beaucoup plus précises et sont généralement utilisées dans des applications financières nécessitant un degré élevé de précision. Les décimales sont beaucoup plus lentes (jusqu’à 20 fois dans certains tests) qu’un double / flottant.

    Les décimales et les flotteurs / doubles ne peuvent pas être comparés sans une dissortingbution alors que les flotteurs et les doubles peuvent le faire. Les décimales permettent également l’encodage ou les zéros à la 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 ssortingctement adaptée aux calculs financiers nécessitant une précision relativement intolérante à l’arrondi. Les décimales ne conviennent pas aux applications scientifiques, cependant, pour plusieurs raisons:

    • Une certaine perte de précision est acceptable dans de nombreux calculs scientifiques 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.
    • Decimal est beaucoup (beaucoup) plus lent que float et double pour la plupart des opérations, principalement parce que les opérations en virgule flottante sont exécutées en binary, alors que les valeurs décimales se font en base 10 (les flottants et les doubles sont gérés par le , alors que les décimales sont calculées dans le logiciel).
    • Decimal a une plage de valeurs inacceptablement plus petite que le 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 plusieurs valeurs scientifiques.

    entrer la description de l'image ici

    pour plus d’informations vous pouvez aller à la source de cette photo:

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

    float 7 chiffres de précision

    double a environ 15 chiffres de précision

    decimal a environ 28 chiffres de précision

    Si vous avez besoin d’une meilleure précision, utilisez le double au lieu de float. Dans les processeurs 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. Pratiquement, cela ne compte que si vous en avez beaucoup.

    J’ai trouvé cela intéressant. Ce que chaque informaticien devrait savoir sur l’arithmétique en virgule flottante

    Personne n’a mentionné cela

    Dans les parameters par défaut, Floats (System.Single) et doubles (System.Double) n’utiliseront jamais la vérification de dépassement, tandis que Decimal (System.Decimal) utilisera toujours la vérification de dépassement de capacité.

    je veux dire

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

    jette OverflowException .

    Mais ceux-ci ne:

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

    Et

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

    Je ne vais pas réitérer des tonnes de bonnes (et quelques mauvaises) informations déjà répondues dans d’autres réponses et commentaires, mais je vais répondre à votre question de suivi avec un conseil:

    Quand quelqu’un utiliserait-il l’un de ces outils?

    Utilisez un nombre décimal pour les valeurs comptées

    Utiliser float / double pour les valeurs mesurées

    Quelques exemples:

    • argent (comptez-vous de l’argent ou mesurez-vous de l’argent?)

    • distance (comptez-vous la distance ou mesurez-vous la distance? *)

    • scores (comptez-vous les scores ou les scores de mesure?)

    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 la distance nominale , nous pourrions en effet vouloir «compter» la distance. Par exemple, nous avons peut-être affaire à des signes de pays qui montrent des distances par rapport aux villes et nous soaps que ces distances n’ont jamais plus d’un chiffre décimal (xxx.x km).

    1. Le double et le flottant peuvent être divisés par un entier sans exception à la fois à la compilation et à l’exécution.
    2. La décimale ne peut pas être divisée par un entier zéro. La compilation échouera toujours si vous faites cela.

    Les types de variables Decimal, Double et Float sont différents dans la manière dont ils stockent les valeurs. La précision est la principale différence lorsque float est un type de données à virgule flottante simple (32 bits), 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.

    Flotteur – 32 bits (7 chiffres)

    Double – 64 bits (15-16 chiffres)

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

    La principale différence est que Floats et Doubles sont des types à virgule flottante et que Decimal stockera la valeur sous forme de virgule flottante. Les décimales sont donc beaucoup plus précises et sont généralement utilisées dans des applications de calcul monétaires (financières) ou scientifiques nécessitant un degré élevé de précision. En termes de performances, les décimales sont plus lentes que les doubles et flottantes.

    La décimale peut représenter à 100% avec précision tout nombre compris dans la précision du format décimal, tandis que Float et Double, ne peuvent pas représenter avec précision tous les nombres, les nombres pairs se trouvant dans la précision de leurs formats respectifs.

    Décimal

    Dans le cas d’applications financières ou de calculs scientifiques, il est préférable d’utiliser les types décimaux, car cela vous donne un niveau élevé de précision et vous évite les erreurs d’arrondi.

    Double

    Les types doubles sont probablement le type de données le plus utilisé pour les valeurs réelles, à l’exception de la gestion de l’argent.

    Flotte

    Il est principalement utilisé dans les bibliothèques graphiques, car les exigences élevées en matière de puissance de traitement utilisent également des situations pouvant entraîner des erreurs d’arrondi.

    Les entiers, comme cela a été mentionné, sont des nombres entiers. Ils ne peuvent pas stocker le point quelque chose comme 7, 42 et 007. Si vous avez besoin de 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 flottant. Vous définissez ces types de variables exactement de la même manière: au lieu d’utiliser le mot int , vous tapez double ou float . Comme ça:

     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 le float , vous pouvez avoir jusqu’à 7 chiffres dans votre numéro. Pour les double , 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 de 32 bits et double un nombre de 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.ToSsortingng()); 

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

     myDouble = 0.007; myDouble = 12345678.1234567; 

    Exécutez votre programme et cliquez sur votre double bouton. Le message affiche correctement le numéro. Ajoutez un autre numéro à la fin, cependant, et C # arrondira à nouveau. La morale est que si vous voulez de la précision, faites attention à l’arrondi!

    Cela a été un fil intéressant pour moi, car aujourd’hui, nous venons d’avoir un petit bug désagréable, concernant le decimal ayant moins de précision qu’un float .

    Dans notre code C #, nous lisons des valeurs numériques à partir d’une feuille de calcul Excel, les convertissant en un nombre decimal , puis en renvoyant ce nombre decimal à un service pour l’enregistrer dans une firebase database SQL Server .

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

    Maintenant, pour presque toutes nos valeurs Excel, cela a fonctionné à merveille. Mais pour certaines, très petites valeurs Excel, utiliser decimal.TryParse perdu la valeur. Un exemple est

    • cellValue = 0.00006317592

    • Decimal.TryParse (cellValue.ToSsortingng (), valeur out); // retournerait 0

    La solution, bizarrement, consistait à convertir les valeurs Excel en une double première, puis en une decimal :

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

    Même si le double a moins de précision qu’une decimal , cela permettait en fait de reconnaître de petits nombres. Pour une raison quelconque, double.TryParse était en fait capable de récupérer des nombres aussi petits, alors que decimal.TryParse les définissait à zéro.

    Impair. Très étrange.

    flottant ~ ± 1,5 x 10-45 à ± 3,4 x 1038 ——– 7 chiffres
    double ~ ± 5,0 x 10-324 à ± 1,7 x 10308 —— 15 ou 16 chiffres
    décimale ~ ± 1,0 x 10-28 à ± 7,9 x 1028 ——– 28 ou 29 chiffres

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

    Les types de variables Decimal, Double et Float sont différents dans la manière dont ils stockent les valeurs. La précision est la principale différence lorsque float est un type de données à virgule flottante simple (32 bits), 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.

    Flotteur – 32 bits (7 chiffres)

    Double – 64 bits (15-16 chiffres)

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

    Plus d’informations sur … la différence entre décimal, flottant et double

    Le problème avec tous ces types est qu’une certaine imprécision subsiste ET que ce problème peut survenir 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 est la valeur de la variable bLower?

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

    Si je remplace Double par Decimal, bLower contient FALSE, 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 plus élevée et que la précision a toujours une limite.

    En fait, Double, Float et Decimal correspondent à la décimale BINARY dans 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) 

    La principale différence entre chacune d’elles est la précision.

    float est un nombre 32-bit , le double est un nombre 64-bit et le nombre decimal est un nombre 128-bit .

    En termes simples:

    1. Les types de variables Decimal, Double et Float sont différents dans la manière dont ils stockent les valeurs.
    2. La différence principale est la différence (Notez que ce n’est pas la seule différence) où float est un type de données à virgule flottante simple (32 bits), double est un type de données à virgule flottante double précision (64 bits) et décimal est un bit 128 type de données à virgule flottante.
    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 en lire plus ici , Float , Double et Decimal .