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

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

Quand quelqu'un utilise un de ces?

InformationsquelleAutor | 2009-03-06
  1. 2137

    float et double sont flottant binaire types de points de. En d'autres termes, ils représentent un nombre comme ceci:

    10001.10010110011

    Le nombre binaire en nombre et l'emplacement des binaires point sont à la fois codées au sein de la valeur.

    decimal est un flottant décimal type de point de. En d'autres termes, ils représentent un nombre comme ceci:

    12345.65789

    Encore une fois, le nombre et l'emplacement de la décimal point sont à la fois codées au sein de la valeur – c'est ce qui rend decimal encore un type à virgule flottante au lieu d'un point fixe de type.

    La chose importante à noter est que les humains sont utilisés pour représenter des nombres non entiers dans une forme décimale, et s'attendre à des résultats exacts en décimal représentations de, pas tous les nombres décimaux sont exactement représentable en virgule flottante binaire – 0.1, par exemple – ainsi, si vous utilisez un fichier binaire à virgule flottante valeur que vous aurez réellement obtenir une approximation de 0.1. Vous aurez toujours des approximations lors de l'utilisation d'une virgule flottante – le résultat de la division de 1 par 3 ne peut pas être représentée exactement, par exemple.

    Que pour ce à utiliser lors de l':

    • Pour les valeurs qui sont "naturellement exacte décimales" c'est bien d'utiliser decimal. C'est généralement adapté pour tous les concepts inventés par l'homme: les valeurs financières sont l'exemple le plus évident, mais il y a aussi les autres. Considérer le score donné à des plongeurs ou du patin à glace, par exemple.

    • Pour les valeurs qui sont plus que des artefacts de la nature qui ne peut pas vraiment être mesurée exactement de toute façon, float/double sont plus appropriés. Par exemple, les données scientifiques seraient habituellement représenté sous cette forme. Ici, les valeurs d'origine ne seront pas "des décimales exactes" pour commencer, de sorte qu'il n'est pas important pour les résultats attendus pour maintenir la "virgule de précision". Flottante binaire types de points sont beaucoup plus rapides à utiliser que les décimales.

    • float/double l'habitude de ne pas représenter les nombres comme 101.101110, normalement, il est représenté comme quelque chose comme 1101010 * 2^(01010010) - un exposant
    • C'est ce que l' "et l'emplacement du binaire point" une partie de la réponse moyen.
    • Je suis surpris qu'il n'ait pas été déjà dit, float est un alias C# mot-clé et n'est pas un .Type de Net. c'est System.Single.. single et double sont flottante binaire types de points.
    • attendre....n'est pas un décimal représenté en 1s et 0s finalement? Je pensais que les ordinateurs ne peut fonctionner que sous forme binaire. alors un nombre décimal est finalement un type binaire n'est-ce pas?
    • Eh bien, que de la même manière que vous pouvez dire tout est un type binaire, à quel point il devient inutile de définition. Décimal est une virgule type, c'est un nombre représenté par un nombre entier significande et une échelle, tels que le résultat est significande * 10^échelle, tandis que les float et double sont significande * 2^échelle. Vous prenez un nombre écrit en décimal, et de déplacer le point décimal assez loin vers la droite que vous avez un nombre entier de travailler sur le significande et l'échelle. Pour float/double vous auriez du commencer par un nombre écrit en binaire.
    • L'autre aspect, c'est la conversion entre ces deux types de données: Simple et Double des types de Données -utiliser le "Flou" de la comparaison de conversion de double à un seul perd de la précision de la conversion du simple au double crée inexactitude conversion/nombre décimal introduit des erreurs d'arrondi entre les bases -la création d'une équipe de consistance[Style Guide] sur le type de données que vous utilisez et de regarder pour la conversion
    • Une autre différence: float 32 bits; double 64-bit; de décimales et de 128 bits.
    • est un alias pour System.Double, decimal est un alias pour System.Double et string est un alias pour System.String.
    • Pour floats/doubles nous obtenons: Console.WriteLine(0.1 + 0.2 == 0.3); // false. Si je comprends bien, ce n'est pas l'égalité en raison de la conversion de la notation décimale nous utilisons dans le code de la notation binaire utilisé dans la mémoire. On peut le faire cependant dans l'autre sens? Initialiser decimal variables avec la notation binaire en code et ensuite obtenir un semblable incompatibilité?
    • Non, parce que chaque valeur binaire est exactement représentable en décimal. (En principe, car 2 est un facteur de 10.)

    InformationsquelleAutor Jon Skeet
  2. 1006

    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)

    Décimales ont beaucoup plus de précision et sont généralement utilisés dans les applications financières qui exigent un degré élevé de précision. Les décimales sont beaucoup plus lents (jusqu'à 20X fois dans certains tests) que d'un lit double ou float.

    Des décimales et des Flotteurs/Double ne peut pas être comparé sans exprimés alors que des Flotteurs et des Doubles peut. Décimales également permettre l'encodage ou les zéros à droite.

    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
    • Cette réponse doit être corrigée. Précision pour la Virgule n'est pas de 128 bits, mais infinie parce que le format est essentiellement différente de flotter. @Skeet réponse est le meilleur. Example: 0.1 = 0.099999.... in float but in decimal it is 0.l, that is infinite precision. If you were to use 128 bits precision like in floats, you would get 0.999999....(upto 29 digits) but that is still not precise as decimal 0.1
    • désolé, mais non. Décimal peut représenter tous les nombres peuvent être représentés en notation décimale, mais pas de 1/3 par exemple. 1.0 m / 3.0 m évaluera à 0.33333333... avec une grande mais dans un nombre limité de 3s à la fin. En le multipliant par 3 ne sera pas de retour exacte 1.0.
    • C'est une erreur avec le nombre lui-même ( 0.3333... dans ce cas), et non sa représentation décimale où elle est produite à 100% fidèle. Lorsque vous avez introduit une erreur dans le nombre, pas de corps pouvez le supprimer (même pas des nombres décimaux). La seule façon d'éliminer l'erreur de ce numéro est à utiliser 1/3 de ne pas 0.333. Certains calculatrice peut prendre du 1/3 moyen de la valeur, mais la plupart d'entre eux ne le font pas. Try this: represent 0.3333 in floating point, you will end up with 0.3332999998..., this is not 0.3333 (you see the error). Now represent this in decimal it is 0.3333 (exactly as it is, no error - 100% accurate).
    • Je pense que vous êtes confus d'exactitude et de précision. Ce sont des choses différentes dans ce contexte. La précision est le nombre de chiffres disponibles pour représenter un nombre. Les plus de précision, moins vous avez besoin de ronde. Aucun type de données n'a une précision infinie.
    • La précision et l'Exactitude est utilisé dans le contexte de la mesure d'une valeur d'un instrument. Dans ce cas, nous ne parlons pas de n'importe quel instrument. Nous ne parlons représentant une valeur fidèlement par virgule vs en virgule flottante. La précision ne s'applique pas ici car nous ne parlons pas de la cohérence de la mesure de la même valeur, plus et plus. Mais la Précision n'. La précision du point décimal à un nombre qui est à sa portée est de 100%, qui est infinie précision.
    • Vous êtes en supposant que la valeur mesurée est exactement 0.1 -- qui est rarement le cas dans le monde réel! Aucun stockage finie format amalgame entre un nombre infini de valeurs possibles pour un nombre fini de configurations de bits. Par exemple, float sera un amalgame entre les 0.1 et 0.1 + 1e-8, tandis que decimal sera un amalgame entre les 0.1 et 0.1 + 1e-29. Bien sûr, à l'intérieur d'une plage donnée, certaines valeurs peuvent être représentées dans un format quelconque avec zéro perte de précision (p. ex. float pouvez stocker tous les entiers jusqu'à 1.6e7 avec zéro perte de précision), mais c'est toujours pas infini précision.
    • Ok je crois float représentent de 0,1 en 0,1, pas que 0,1 + 1e-29. C'est parce que le format est essentiellement différente de flotter. C'est pourquoi il est très lent mais précis. Si vous étiez à droite de la décimale est inutile. Rappelez-vous le principal problème de flotteur if(0.1 = 0.1) cette condition n'est vraie lorsque nous pensons que cela doit être vrai. En décimal, il sera TOUJOURS vrai parce que de 0,1 sera de 0,1 et rien d'autre. Par exemple, il ne sera pas 0.99999999999999999999999999999.
    • Vous avez manqué mon point. 0.1 est ce n'est pas une valeur spéciale! La seule chose qui rend 0.1 "mieux" que 0.10000001 est parce que les êtres humains comme la base 10. Et même avec un float valeur, si vous initialisez les deux valeurs avec 0.1 de la même façon, ils seront tous deux la même valeur. C'est juste que cette valeur ne sera pas exactement 0.1 -- il sera la valeur la plus proche de 0.1 qui peut être représentée exactement comme un float. Bien sûr, avec les binaires de flotteurs, (1.0 / 10) * 10 != 1.0, mais avec décimale flotteurs, (1.0 / 3) * 3 != 1.0 soit. Ni est parfaitement précis.
    • avec un nombre décimal, il sera exactement 0.1. Bien sûr, il n'est pas de l'ordre de 0,1 uniquement. Un grand nombre de décimales des nombres a ce problème. Le fait est en décimal (de 0,1 == 0.1) sera toujours vrai. En float, il peut ou peut ne pas être vrai parce que la réelle valeur binaire peut ne pas être exactement 0.1.
    • Vous ne comprenez toujours pas. Je ne sais pas comment le dire plus clairement: En C, si vous ne double a = 0.1; double b = 0.1; puis a == b sera vrai. C'est juste que a et b sera deux ce n'est pas exactement égale 0.1. En C#, si vous ne decimal a = 1.0m / 3.0m; decimal b = 1.0m / 3.0m; puis a == b sera également vrai. Mais dans ce cas, ni de a ni b sera exactement l'égalité des 1/3 -- ils à la fois l'égalité 0.3333.... Dans deux cas, une certaine exactitude est perdu à cause de la représentation. Vous obstinément de dire que decimal a "infini", de précision, qui est false.
    • Juste au cas où vous ne me croyez pas, voici un exemple de code qui montre que 0.1 == 0.1.
    • Ce qui devrait avoir été marqué comme réponse correcte. Jon Skeet la réponse est un peu déroutant...
    • Skeet la réponse de la traite complètement distincte de différence dans cette réponse ignore complètement. Personnellement, je considère au pigeon d'argile, la réponse à être plus précieux, que sa réponse est plus pertinent pour décider du type de données à utiliser.
    • Ils sont à la fois très précieux, et c'est pourquoi j'ai dit ab initio qu'elles sont incomplètes, l'un sans l'autre. Concernant la question posée cependant, cette réponse va directement à l'essentiel et vous indique les différences essentielles. Vous pouvez faire presque toutes les déductions de Jon Skeet la réponse de celui-ci. 🙂
    • Non, vous ne pouvez pas, parce que cette réponse ne mentionne même pas le décimal/binaire distinction.
    • Je sais que c'est un vieux problème, mais peut-être que je peux aider à clarifier. Le problème ici est que les nombres Décimaux sont exactes à 100% lorsque représenter les nombres qui sont à l'intérieur de la précision du format décimal. Qui est, non pas le résultat de pi, ou 1/3 ou 2/3. C'est pas pertinente parce que ces chiffres exigent une plus grande précision que décimal peut représenter. Si vous effectuez un calcul sur une valeur décimale qui dépasse la précision, alors tous les paris sont éteints. Avec float/double des nombres qui SONT dans la précision du format ne sont pas toujours précis à 100%. .1 pour l'exemple.
    • qu'entendez-vous par "au sein de la précision du format décimal"? Si le nombre que l'on mesure est exactement un nombre entier élevé à une puissance de dix, puis utiliser absolument un decimal. Beaucoup de nombres rencontrés dans la vie quotidienne ont cette propriété (parce que le sont discrètes, pas en continu, mesures), mais beaucoup d'autres ne le font pas. Le type de données approprié pour n'importe quel but dépend toujours de l'effet. S'il vous plaît ne pas abuser de tout ce que je veux dire ici que ce qui implique que n'importe qui devrait toujours utiliser des flotteurs -- je suis simplement en disant qu'on ne devrait pas aveuglément toujours utiliser decimals à la place.
    • Je pense qu'une partie de votre confusion est trahi par le membre de phrase "dans la précision de la forme". Je ne pense pas que le sens -- voulez-vous dire quelque chose comme "au sein de la gamme représentable" à la place? Mais même cela n'est pas de prouver quoi que ce soit: 0.1 n'est plus "à l'intérieur de la précision" d'un double de 2^53+1, et les deux peuvent être également représentées fidèlement.
    • Presque à chaque fois, la question de la précision de la représentation à virgule flottante (en décimal ou binaire) arrive, il s'ensuit une longue conversation de commentaires à contre-courant. Fondamentalement, cela est dû à la question de savoir si le exact valeur représentés par la virgule flottante représentation correspond à la même exact valeur dans le monde réel. Cela ne peut être connu par la recherche à la représentation du nombre lui-même; il ne peut être connu que par les humains qui utilisent la représentation.
    • Voici un petit exemple de code pour C# (qui cet article est sur) qui permet de visualiser le problème (en utilisant la virgule & float). (0.1f == 1f/10) et (0.1m == 1m/10). La première permettra d'évaluer à faux tandis que le second permettra d'évaluer de vrai, même si les deux doivent avoir la valeur true. Cela est dû au fait que le flotteur ne peut pas exactement de stocker la valeur de 0,1.
    • Pourquoi pas égale à 0,1 f 1f/10? Ne devrait pas évaluer à 13421773/134217728?
    • Car comment flotteur fonctionne en interne 0,1 f ne peut pas être représentée exactement en interne format binaire et en raison du fait que les calculs d'utiliser plus de précision à l'interne 1f/10 ne sera pas la même valeur arrondie à 0,1 f, donc ils ne seront pas égales.
    • Le type de compilation de l'expression 1f/10 est float. Vous dites que les compilateurs ne sont pas requis pour arrondir le résultat de la division la plus proche float avant d'effectuer la comparaison? Je considère comme un peu cassé le fait que l'on est autorisé à comparer directement un float à autre chose, ou un double à rien d'autre que le 32 bits ou plus petit des entiers [je pense à un casting devrait être nécessaire], mais je considère sévèrement un compilateur qui a exécuté ce qui était par les règles de la langue d'un flotteur/float comparaison, comme s'il s'agissait d'un float/double comparaison.
    • ce que je voudrais voir serait une langue à la fois avec "lâche" et "strict" 32 - et 64-bits à virgule flottante types, où la stricte ceux à ne pas accepter d'conversions implicites et le "lâche" on pourrait être défini comme une extension de l'opération les résultats de double et généralement permettre implicite down-conversion à float, mais ne permettraient pas d'établir des comparaisons directes entre les versions 32 bits et 64 bits des valeurs. Je postulons que, tandis que le C# n'aura aucun scrupule à propos de double d1=f1*f2; il serait rare que le programmeur de l'intention que d1 pourrait tenir un float-résultat de précision.)
    • La norme binaire à virgule flottante n'a pas de mandat strict de la précision décimale, voir Mark Jones réponse ci-dessous. Il n'est pas défini par la langue. Si vous avez besoin d'une stricte arrondissement vous devez utiliser le type de données décimal qui est un nombre décimal à virgule flottante comme Jon Skeet points dans Mehrdad la réponse ci-dessous. Les différents types d'usages différents et des exigences différentes. Lors du calcul les valeurs du monde réel en physique par exemple, les originaux de vos numéros sont probablement moins précis que votre compilateur, donc les erreurs de calcul ont généralement moins d'impact que les erreurs de mesure.
    • Encore une tentative pour essayer de frapper le clou sur la tête: les Deux float et double pouvez exactement représente les fractions de la forme p/q où q est une puissance de 2. E. g. 0.5, 3.25, 1/256, etc. decimal cependant pouvez exactement représente les fractions de la forme p/q où q est une puissance de 10 (dix). Voir cette réponse. S'il est exact que decimal a plus de chiffres significatifs, il est trompeur de laisser à la représentation est fondamentalement différente de celle float et double qui prête decimal à la précision des décimales dans les calculs.
    • La précision n'est pas la principale différence. Décimale étant la base 10 est la principale différence.
    • -1 aucune mention de gamme ou des bases différentes.
    • -1 tandis que la principale différence entre float et double, c'est la précision, la principale différence entre les float, double, et de la virgule n'est pas. Il est vrai que les décimales ne disposent d'une plus grande précision, mais plus important encore, il stocke également les valeurs en décimal format centré sur, par opposition à float et double, qui stockent leurs valeurs en binaire centrée sur le format. Pour donner un exemple, le nombre ".75" dans la décimale est équivalent à ".11" en binaire, parce que la moitié plus un de suite == trois quarts. Naturellement, certaines fractions des valeurs décimales (même au sein de l' ~7 chiffres) ne peut être approximée par la double et float.
    • décimal peut exactement représentent les fractions de la forme p/q lorsque q est une puissance de 2 ou d'une puissance de 5 (c'est à dire, les facteurs premiers de 10). Envisager 1/2 (0.5) et 1/5 (0.2), par exemple, ni le dénominateur est une puissance de 10.
    • envisager une virgule flottante de base-3 système, où 1/10 (plutôt 1/101) est une fraction extensible à l'infini: 0.00220022.... Toutefois, 1/3 n'est pas; elle est de 0,1. Envisager de Matt commentaire: Fractions qui peuvent être exactement représenté dans une base donnée sont celles qui utilisent les facteurs premiers de la base. Virgule n'a pas une précision infinie; il a 28 décimales de précision. Si il avait vraiment de précision infinie, vous serez en mesure de représenter la moitié de 0.0000000037252902984619140625m. Mais vous ne pouvez pas; diviser par 2 donne 0.0000000018626451492309570312m au lieu de 0.00000000186264514923095703125
    • Il n'est pas nécessaire que p/q mettre en forme la plus simple. Dans vos exemples, 1/2=5/10 et 1/5=2/10 et, par conséquent, ont exactement décimal représentations. Un autre exemple est 1/20=0.05 dont le dénominateur est ni une puissance de 2, 5 ou 10. Vous avez dit "décimal peut exactement représentent les fractions de la forme p/q lorsque q est une puissance de 2 ou d'une puissance de 5". Bien que techniquement correctes, ce est en fait plus restrictive que ce que j'ai dit parce que 1/10, par exemple, ne peut pas être écrit sous la forme p/q, où q est une puissance de 2 ou 5.
    • En plus des valeurs, à l'instar de 0,1, qui peut être représenté comme decimal mais pas comme double, il y a certaines valeurs qui peuvent être représentées exactement comme double mais pas decimal. Considérons la fraction 1 / 2^31. Le decimal représentation est tronqué, alors que le double représentation est exacte. L' .NET représentation de chaîne de la double n'est pas exacte, mais dans la mémoire de bits de la représentation est exacte. Jon Skeet a une classe qui permettra de convertir n'importe quel double à la décimale exacte représentation sous forme de chaîne, qui peut être assez long: csharpindepth.com/Articles/General/FloatingPoint.aspx
    • J'ai aussi simpliste. Le réel exigence est que, après la réduction de la fraction à sa plus simple forme q est le produit d'une puissance de 2 et d'une puissance de 5; qui est, q unique de facteurs premiers doivent être de la même ou d'un sous-ensemble unique de facteurs premiers de la base. Vous pouvez, bien sûr, de manière équivalente, refonte que, comme tous les de q est le premier des facteurs soit un facteur premier de la base ou d'un diviseur de p.
    • Liens dans votre réponse sont morts.

    InformationsquelleAutor cgreeno
  3. 78

    La structure Decimal est strictement axé sur les calculs financiers nécessitant de la précision, qui sont relativement intolérant de l'arrondissement. Les décimales ne sont pas suffisantes pour les 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 un artefact de mesure. La perte de précision n'est pas acceptable dans la finance.
    • Décimal est beaucoup (beaucoup) plus lent que le float et double pour la plupart des opérations, principalement en raison d'opérations en virgule flottante sont fait en binaire, Décimal alors que des trucs se fait en base 10 (c'est à dire les flotteurs et les doubles sont gérées par la FPU matériel, comme le MMX/SSE, alors que les décimales sont calculés dans le logiciel).
    • Décimal est inacceptable valeur inférieure de la gamme de plus du double, en dépit du fait qu'il prend en charge plus de chiffres de précision. Par conséquent, la Virgule ne peut pas être utilisé pour représenter de nombreuses valeurs scientifiques.
    • Si vous êtes en train de faire les calculs financiers, vous devez absolument faire vos propres types de données ou trouver une bonne bibliothèque qui correspond à vos besoins exacts. Précision financier est défini par (humain), organismes de normalisation, et ils ont de très localisées spécifiques (à la fois dans le temps et la géographie) des règles sur la façon de faire les calculs. Des choses comme l'arrondi correct ne sont pas capturés dans le simple types de données numériques dans .Net. La capacité à faire des calculs est seulement une très petite partie du puzzle.
    InformationsquelleAutor Mark Jones
  4. 70
    +---------+----------------+---------+----------+---------------------------------------------+
| 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/en-US/csharpgeneral/thread/921a8ffc-9829-4145-bdc9-a96c1ec174a5

    • Vous avez laissé de côté la plus grande différence, qui est la base utilisée pour le type décimal (virgule est stocké en base 10, tous les autres types numériques sont énumérés en base 2).
    • Les gammes de valeur pour les Simples et Doubles ne sont pas représentés correctement dans l'image ci-dessus ou de la source de post sur le forum. Puisque nous ne pouvons pas facilement en exposant le texte ici, utiliser l'accent circonflexe: Unique doit être de 10^-45 et 10^38, et le Double doit être de 10^-324 et 10^308. Aussi, MSDN a le flotteur avec une plage de -3.4x10^38 à +3.4x10^38. Recherche MSDN pour le Système.Unique et du Système.Double en cas de changements de liaison. Unique: msdn.microsoft.com/en-us/library/b1e65aza.aspx Double: msdn.microsoft.com/en-us/library/678hzkk9.aspx
    • Virgule est de 128 bits ... signifie qu'il occupe 16 octets et non pas 12
    InformationsquelleAutor
  5. 46

    float 7 chiffres de précision

    double a environ une précision de 15 chiffres

    decimal a environ 28 chiffres de précision

    Si vous avez besoin de plus de précision, utilisez le double au lieu de flotter.
    Dans les Processeurs modernes les deux types de données ont presque les mêmes performances. Le seul avantage de l'aide du flotteur est qu'ils prennent moins d'espace. Pratiquement questions uniquement si vous avez beaucoup d'entre eux.

    J'ai trouvé ce qui est intéressant. Ce Que Tout Informaticien Devez Savoir À Propos De L'Arithmétique À Virgule Flottante

    • Je considère double bon dans les applications de comptabilité dans ces cas (et en gros les seuls cas) où aucun type entier de plus de 32 bits est disponible, et le double a été utilisé comme s'il s'agissait d'un 53 bits de type entier (par exemple, avoir un nombre entier de pièces de monnaie, ou un nombre entier de centièmes de pour cent). Pas beaucoup d'utilisation pour de telles choses de nos jours, mais de nombreuses langues, a acquis la capacité à utiliser la double-precision floating-point des valeurs à long avant qu'ils acquis de 64 bits (ou, dans certains cas, même en 32 bits!) math entier.
    • Votre réponse implique la précision est la seule différence entre ces types de données. Donnée binaire arithmétique à virgule flottante est généralement mis en œuvre dans matériel FPU, la performance est une différence importante. Cela peut être sans conséquence pour certaines applications, mais il est essentiel pour les autres.
    • double est jamais bon dans les applications de comptabilité. Parce que le Double peut seulement se rapprocher des valeurs décimales (même à l'intérieur de la portée de sa propre précision). C'est parce que double stocke les valeurs dans une base 2 (binaire) centrée sur le format.
    • Utiliser les types à virgule flottante à maintenir non-ensemble-numéro les quantités d'être mauvaise, mais il a été historiquement très commun pour les langues pour avoir les types à virgule flottante qui pourrait représenter ensemble plus grand nombre de valeurs que leurs types d'entiers pourrait représenter. Peut-être l'exemple le plus extrême est Turbo-87 dont les seuls types d'entiers ont été limitées à -32768 à +32767, mais dont Real pourrait IIRC représentent des valeurs jusqu'à 1,8 E+19 avec l'unité de précision. Je pense qu'il serait beaucoup plus saine pour une application de comptabilité à l'utilisation Real pour représenter un nombre entier de pièces de monnaie de...
    • ...pour elle d'essayer d'exécuter multi-mathématiques de précision à l'aide d'un tas de valeurs de 16 bits. Pour la plupart des autres langues, la différence n'était pas extrême, mais pour un long moment, il a eu très commun pour les langues n'ont pas de type entier qui est allé au-delà de 4E9, mais ont une double type qui avait la précision de l'unité jusqu'à 9E15. Si l'on a besoin de stocker des nombres entiers qui sont plus grands que le plus grand disponible de type entier, à l'aide de double est apte à être plus simple et plus efficace que d'essayer de fudge multi-mathématiques de précision, d'autant plus que les processeurs ont des instructions pour exécuter 16x16->32 ou...
    • ...32x32->64 multiplication, les langages de programmation n'ont généralement pas.

    InformationsquelleAutor CharithJ
  6. 41

    Je ne vais pas réitérer des tonnes de bons (et mauvais) informations déjà répondu dans d'autres réponses et les commentaires, mais je vais répondre à votre question de suivi avec une astuce:

    Quand quelqu'un utilise un de ces?

    Décimal pour compté valeurs

    Utiliser float/double pour mesurée valeurs

    Quelques exemples:

    • de l'argent (nous ne compter l'argent ou de la mesure de l'argent?)

    • distance (nous ne décompte de la distance ou de mesurer la distance? *)

    • scores (ne nous compter les scores ou de mesurer les scores?)

    Nous comptons toujours de l'argent et ne devrait jamais mesurer. Nous avons l'habitude de mesurer la distance. Nous comptons souvent scores.

    * Dans certains cas, ce que j'appellerais distance nominale, on peut en effet vouloir "comte" de distance. Par exemple, peut-être que nous avons affaire avec des pays les signes qui montrent les distances vers les villes, et nous savons que ces distances ne jamais avoir plus d'un chiffre décimal (xxx.x km).

    • J'aime vraiment cette réponse, en particulier la question "faites-nous de comptage ou de mesure de l'argent?" Cependant, d'autres que de l'argent, je ne peux pas penser à tout ce qui est "compté" qui n'est pas simplement entier. J'ai vu certaines applications qui utilisent la virgule simplement parce que double a trop peu chiffres significatifs. En d'autres termes, virgule peut être utilisé parce que le C# n'est pas un quadruple type en.wikipedia.org/wiki/Quadruple-precision_floating-point_format
    InformationsquelleAutor tomosius
  7. 35

    Personne n'a mentionné que

    Dans les paramètres par défaut, de Flotteurs (Système d'.Unique) et en double (Système d'.Double) n'utilisera jamais
    vérification de dépassement tout en Décimal (le Système.Décimal) toujours utiliser
    vérification de dépassement.

    Je veux dire 

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

    jette OverflowException.

    Mais ceux-ci n':

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

    &

    double myNumber = double.MaxValue;
myNumber += 1;
    • float.MaxValue+1 == float.MaxValue, tout comme decimal.MaxValue+0.1D == decimal.MaxValue. Peut-être que vous avez voulu dire quelque chose comme float.MaxValue*2?
    • Mais il n'est pas vrai que la virgule.MaxValue + 1 == décimal.MaxValue
    • décimal.MaxValue + 0,1 m == décimal.MaxValue ok
    • Le System.Decimal déclenche une exception juste avant qu'il devient impossible de distinguer des unités entières, mais si une application est censée être traiter avec, par exemple, des dollars et des cents, qui pourrait être trop tard.
    InformationsquelleAutor GorkemHalulu
  8. 28

    Entiers, comme cela a été mentionné, sont des nombres entiers. Ils ne peuvent pas stocker le point de 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 autre type de variable. Vous pouvez utiliser le type double ou le type float. Vous définissez ces types de variables jusqu'exactement 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 seulement d'un nombre avec un point de quelque chose sur la fin.)

    La différence entre les deux réside dans la taille des nombres qu'ils peuvent tenir. Pour float, vous pouvez avoir jusqu'à 7 chiffres de votre numéro. Pour 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 de 32 bits, et double est un nombre de 64 bits.

    Double cliquez sur le bouton nouveau pour obtenir le code. Ajouter les trois lignes suivantes à votre code du bouton:

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

    Arrêter votre programme et revenir à la fenêtre de codage. Modifier cette ligne:

    myDouble = 0.007;
myDouble = 12345678.1234567;

    Exécuter votre programme et cliquez sur votre bouton double. La boîte de message affiche correctement le nombre. Ajouter un autre numéro sur la fin, cependant, et C# sera de nouveau en rond vers le haut ou vers le bas. La morale est que si vous voulez de la précision, être prudent de l'arrondissement!

    • Upvoted pour l'utilisation .42 et .007 dans votre exemple. : D
    • Le point "quelque chose" que vous avez mentionné est généralement dénommée "la partie fractionnaire" d'un nombre. "À virgule flottante" ne signifie pas "d'un nombre avec un point de quelque chose sur la fin", mais plutôt "à virgule Flottante" qui distingue le type de nombre, par opposition à un "Point Fixe" nombre (qui peut également stocker une valeur fractionnaire); la différence est de savoir si la précision est fixe ou flottant. -- Nombres de virgule flottante de vous donner un beaucoup plus grand de la gamme dynamique de valeurs (Min et Max), au prix de la précision, alors que d'un point fixe, les numéros de vous donner une quantité constante de la précision, le coût de gamme.
    InformationsquelleAutor daniel
  9. 27
    1. Double et float peut être divisé par le nombre entier zéro, sans exception, à la fois de la compilation et de l'exécution.
    2. Décimal ne peut pas être divisé par le nombre entier zéro. La Compilation échouera toujours, si vous faites cela.
    • Il est certain qu'ils peuvent! Ils ont également ont également un couple de "magie" des valeurs telles que l'Infini, l'Infini Négatif, et NaN (pas un nombre) qui font qu'il est très utile pour la détection de lignes verticales, même si le calcul des pentes... en Outre, si vous avez besoin de décider entre un appel à flotteur.TryParse, double.TryParse, et décimal.TryParse (pour détecter si une chaîne est un nombre, par exemple), je recommande l'utilisation de double ou float, comme ils vont analyser "l'Infini", "l'Infini", et "NaN" correctement, alors que la virgule ne sera pas.
    • Compilation seulement échoue si vous essayez de diviser un littéral decimal par zéro (CS0020), et le même est vrai de l'ensemble des littéraux. Toutefois, si l'exécution, la valeur décimale est divisé par zéro, vous aurez une exception et non une erreur de compilation.
    • Cependant, vous pourriez ne pas vouloir analyser "l'Infini" ou "NaN" selon le contexte. Semble être une bonne exploiter pour la saisie de l'utilisateur si le développeur n'est pas assez rigoureux.
    InformationsquelleAutor xport
  10. 13

    Cela a été un sujet intéressant pour moi, car aujourd'hui, nous avons juste eu un petit méchant bug, concernant decimal d'avoir moins de précision qu'un float.

    Dans notre code C#, nous sommes à la lecture des valeurs numériques à partir d'une feuille de calcul Excel, en les convertissant en un decimal, puis l'envoi de ce decimal retour à un Service pour enregistrer dans un SQL Server base de données.

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

    Maintenant, pour presque tous les de nos valeurs Excel, cela a fonctionné à merveille. Mais pour certains, de très petites valeurs Excel, à l'aide de decimal.TryParse perdu totalement la valeur. Un exemple est

    • cellValue = 0.00006317592

    • Décimal.TryParse(cellValue.ToString(), valeur); //serait de retour 0

    La solution, bizarrement, était de convertir les valeurs Excel dans un double d'abord, et ensuite dans 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;
…
}

    Même si double a moins de précision qu'un decimal, c'est en fait assurée petit nombre serait encore reconnu. Pour une raison quelconque, double.TryParse été réellement en mesure de récupérer ces petits nombres, alors que decimal.TryParse serait de les mettre à zéro.

    Bizarre. Très bizarre.

    • Par curiosité, quelle est la valeur brute de cellValue.ToString()? Décimal.TryParse("0.00006317592", hors val) semble fonctionner...
    • -1 Ne m'obtenez pas le mal, si c'est vrai, c'est très intéressant, mais c'est une question distincte, ce n'est certainement pas une réponse à cette question.
    • Peut-être parce que la cellule Excel a été le retour d'un lit double et ToString() la valeur a été "6.31759 E-05" donc la virgule.Parse() n'aimait pas la notation. Je parie que si vous avez coché la valeur de retour de la Virgule.TryParse (), il aurait été faux.
    • Réponses souvent en complément d'autres réponses en remplissant les nuances qu'ils ont manqué. Cette réponse met en évidence une différence en termes de l'analyse. Il est très bien une réponse à la question!
    • Euh... decimal.Parse("0.00006317592") fonctionne, vous avez quelque chose d'autre se passe. - Peut-être la notation scientifique?
    InformationsquelleAutor Mike Gledhill
  11. 13
    • float: ±1,5 x 10^-45 à ±3,4 x 10^38 (~7 chiffres significatifs
    • double: ±5,0 x 10^-324 ±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)
    • La différence est plus que juste une précision. -- decimal est en fait stockée dans le format décimal (par opposition à la base 2; afin de ne pas perdre ou rond chiffres en raison de la conversion entre les deux systèmes numériques); en outre, decimal n'a pas de notion de valeurs spéciales telles que NaN, -0, ∞ ou -∞.
    InformationsquelleAutor Mukesh Kumar
  12. 8

    Pour des applications telles que des jeux et des systèmes embarqués où la mémoire et les performances sont à la fois critique, le float est généralement le type numérique de choix car il est plus rapide et la moitié de la taille d'un double. Les entiers utilisés pour être l'arme de choix, mais de performance en virgule flottante a dépassé entier dans les processeurs modernes. Virgule est juste!

    • À peu près tous les systèmes modernes, même les téléphones portables, matériel de soutien pour le double; et si vous le jeu a encore de la physique simple, vous remarquerez une grande différence entre le double et float. (Par exemple, le calcul de la vitesse / la friction dans un simple Astéroïdes clone, doubles permettre l'accélération des flux beaucoup plus fluide que le flotteur. -- Me semble qu'il ne devrait pas, mais c'est parfaitement fait.)
    • Les chambres Doubles sont également de doubler la taille de la flotte, ce qui signifie que vous besoin de mâcher à travers deux fois plus de données, qui fait mal aux performances du cache. Comme toujours, de mesurer et d'agir en conséquence.
    InformationsquelleAutor yoyo
  13. 7

    De la Virgule, Double et Float types de variables sont différentes dans la manière dont ils stocker les valeurs. La précision est la principale différence où float est une simple précision (32 bits) de données à virgule flottante double est double précision (64 bits) virgule flottante et le type de données décimal est une virgule flottante 128 bits type de données.

    Float 32 bits (7 chiffres)

    Double - 64 bits (de 15 à 16 chiffres)

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

    Plus sur...la différence entre Décimal, Float et Double

    InformationsquelleAutor warnerl
  14. 5

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

    Réponse: Sur un ordinateur 32 bits ventilateur contient de VRAI !!!

    Si je remplace le Double en Décimal, ventilateur contient de FAUX qui est la bonne réponse.

    En double, le problème est que fMean-fDelta = 1.09999999999 qui est plus faible que 1.1.

    Attention: je pense que le même problème existe bel et bien pour d'autres nombre, parce que la Décimale est un double avec plus de précision et de la précision a toujours une limite.

    En fait, Double, Float et Décimal correspondent à BINAIRE décimal en COBOL !

    Il est regrettable que d'autres types numériques mis en œuvre dans le COBOL n'existent pas .Net. Pour ceux qui ne connaissent pas COBOL, il existe en COBOL suivant type numérique

    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)
    InformationsquelleAutor schlebe
  15. 4

    En termes simples:

    1. De la Virgule, Double et Float types de variables sont différentes dans la manière dont ils stocker les valeurs.
    2. La précision est la principale différence (Notez que ce n'est pas la seule différence) où float est une simple précision (32 bits) de données à virgule flottante type, double est un double précision (64 bits) de données à virgule flottante type et décimal est de 128 bits à virgule flottante type de données.
    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, Flotteur, Double, et Décimal.

    • Qu'est-ce répondre à ajouter qui n'est pas déjà couvert dans les réponses? BTW, votre "ou" dans la "virgule" est incorrect: la barre oblique dans la page web que vous copiez à partir de indique une division plutôt qu'une autre.
    • Et je me ferais un litige fortement que la précision est la principale différence. La principale différence est la base: en virgule flottante rapport binaire à virgule flottante. Cette différence est ce qui fait Decimal adapté pour les applications financières, et c'est le principal critère à utiliser au moment de décider entre Decimal et Double. Il est rare que Double précision n'est pas suffisante pour les applications scientifiques, par exemple (et Decimal est souvent inadaptés pour les applications scientifiques, en raison de sa portée limitée).
    InformationsquelleAutor GntS
  16. 3

    La principale différence entre chacun de ces est la précision.

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

    InformationsquelleAutor user3776645