décimal vs double! – Lequel dois-je utiliser et quand?

Je continue de voir des personnes utilisant des doubles en C #. Je sais que j’ai lu quelque part que les doubles perdent parfois de la précision. Ma question est de savoir quand utiliser un double et quand dois-je utiliser un type décimal? Quel type convient aux calculs de l’argent? (c.-à-d. plus de 100 millions de dollars)

Pour l’argent, toujours décimal. C’est pourquoi il a été créé.

Si les chiffres doivent s’append correctement ou s’équilibrer, utilisez le nombre décimal. Cela comprend tout stockage financier ou calculs, scores ou autres nombres que les gens pourraient faire à la main.

Si la valeur exacte des nombres n’est pas importante, utilisez le double pour la vitesse. Cela inclut les calculs graphiques, physiques ou autres sciences physiques où il existe déjà un “nombre de chiffres significatifs”.

Ma question est de savoir quand utiliser un double et quand dois-je utiliser un type décimal?

decimal lorsque vous travaillez avec des valeurs comsockets entre 10 ^ (+/- 28) et les attentes relatives au comportement basées sur des représentations de base 10 – essentiellement de l’argent.

double lorsque vous avez besoin d’ une précision relative (c.-à-d. perdre la précision des derniers chiffres sur les grandes valeurs n’est pas un problème) sur des grandeurs très différentes – les double couvrent plus de 10 ^ (+/- 300). Les calculs scientifiques sont le meilleur exemple ici.

quel type convient aux calculs de l’argent?

décimal, décimal , décimal

Ne pas accepter de substituts.

Le facteur le plus important est que le double , étant implémenté en tant que fraction binary, ne peut pas représenter avec précision de nombreuses fractions decimal (comme 0.1) et son nombre total de chiffres est plus petit puisqu’il est de 64 bits contre 128 bits en decimal . Enfin, les applications financières doivent souvent suivre des modes d’arrondi spécifiques (parfois prescrits par la loi). decimal soutient ; double ne le fait pas.

System.Single / float – 7 chiffres
System.Double / double – 15-16 chiffres
System.Decimal / decimal – 28-29 chiffres significatifs

La façon dont j’ai été piqué en utilisant le mauvais type (il y a quelques années) est de gros montants:

  • 520.532.52 £ – 8 chiffres
  • £ 1,323,523.12 – 9 chiffres

Vous êtes à 1 million pour un float.

Une valeur monétaire de 15 chiffres:

  • £ 1,234,567,890,123,45

9 milliards de dollars avec un double. Mais avec la division et les comparaisons, c’est plus compliqué (je ne suis certainement pas un expert des nombres à virgule flottante et des nombres irrationnels – voir le sharepoint Marc ). Le mélange de nombres décimaux et de doublons pose des problèmes:

Une opération mathématique ou de comparaison qui utilise un nombre à virgule flottante peut ne pas donner le même résultat si un nombre décimal est utilisé, car le nombre à virgule flottante pourrait ne pas correspondre exactement au nombre décimal.

Quand devrais-je utiliser double au lieu de décimal? a des réponses similaires et plus approfondies.

Utiliser le double au lieu du decimal pour les applications monétaires est une micro-optimisation – c’est la manière la plus simple de la regarder.

La décimale est pour les valeurs exactes. Double est pour des valeurs approximatives.

 USD: $12,345.67 USD (Decimal) CAD: $13,617.27 (Decimal) Exchange Rate: 1.102932 (Double) 

Pour de l’argent: decimal . Cela coûte un peu plus de mémoire, mais n’a pas de problèmes d’arrondi comme le double parfois.

Utilisez des types entiers pour vos calculs d’argent. Cela ne peut pas être assez souligné, car à première vue, un type à virgule flottante peut sembler suffisant.

Voici un exemple en code python:

 >>> amount = float(100.00) # one hundred dollars >>> print amount 100.0 >>> new_amount = amount + 1 >>> print new_amount 101.0 >>> print new_amount - amount >>> 1.0 

semble assez normal.

Maintenant, essayez à nouveau avec 10 ^ 20 dollars du Zimbabwe

 >>> amount = float(1e20) >>> print amount 1e+20 >>> new_amount = amount + 1 >>> print new_amount 1e+20 >>> print new_amount-amount 0.0 

Comme vous pouvez le voir, le dollar a disparu.

Si vous utilisez le type entier, cela fonctionne bien:

 >>> amount = int(1e20) >>> print amount 100000000000000000000 >>> new_amount = amount + 1 >>> print new_amount 100000000000000000001 >>> print new_amount - amount 1 

Je pense que la principale différence avec la largeur de bit est que la décimale a la base de l’exposant 10 et que le double a 2

http://software-product-development.blogspot.com/2008/07/net-double-vs-decimal.html