Quelle est la longueur maximale en caractères nécessaires pour représenter le double de la valeur?

Quand je convertir un entier non signé de 8 bits int en string puis je sais que le résultat sera toujours au plus 3 caractères (pour 255) et pour une 8 bits signé int nous avons besoin de 4 caractères, par exemple "-128".

Maintenant, ce que je suis en train de me demander qui est la même chose pour les valeurs à virgule flottante. Quel est le nombre maximum de caractères requis pour représenter un "double" ou "float" valeur une chaîne de caractères?

Assumer régulièrement un C/C++ double (IEEE 754) et la normale de décimal de l'expansion (c'est à dire pas de %e printf mise en forme).

Je ne suis même pas sûr si c'est vraiment petit nombre (c'est à dire 0.234234) sera plus long que le très grand nombre (les doubles représentant des entiers)?

Jalf.com, pourquoi quelqu'un mentionner que? Qui a dit qu'il est demandant comment grand d'une taille fixe de la mémoire tampon devra être? Peut-être qu'il veut savoir combien de colonnes de caractères, il doit réserve sur la console pour un texte basé sur la table.
Sans notation scientifique, il serait long pour les valeurs extrêmes de la gamme de magnitude, mais à quoi servirait-il? Qui voudrait lire un tel nombre - un lit double (généralement) est d'environ 15 chiffres décimaux significatifs - tout le reste serait d'un grand nombre de leaders ou traiining zéros.
Non, vous pouvez avoir plus de 15 chiffres significatifs pour les chiffres décimaux, mais seulement 15 chiffres significatifs pour l'entier. C'est parce que tandis que vous pouvez représenter tous les entiers vous ne pouvez pas représenter toutes les décimales expansions donc moins de bits peut être utilisée pour couvrir une plus grande gamme.
Je ne suis pas l'impression de numéros pour les gens à lire, j'essaie de trouver le nécessaire char buffer de la taille nécessaire pour être sûr que l'inverse de strtod (j'.e "dtoa(double d, char* sortie)") peut finir en toute sécurité, sans risque de débordements de tampon.
J'ai essayé avec une boucle for et multiplié le nombre tant qu'il a donné 1.#INF00, le plus grand nombre était de 286 octets de long. Donc je suppose que vous êtes en sécurité avec 512 octets? (à l'aide de printf).
Le problème est que je ne connais pas de moyen valable de format std::string en utilisant la norme printf format. Donc, si je reçois un double, j'ai besoin de créer char[X] tampon.

InformationsquelleAutor martin | 2009-11-09

c c++floating-point

34

L'en-tête standard <float.h> en C, ou <cfloat> en C++, contient plusieurs constantes à voir avec la plage et d'autres mesures de la virgule flottante types. L'un de ces est DBL_MAX_10_EXP, la plus grande puissance de 10 exposant nécessaires pour représenter tous les double valeurs. Depuis 1eN besoins N+1 chiffres pour représenter, et il pourrait être un signe négatif ainsi, alors la réponse est
```
int max_digits = DBL_MAX_10_EXP + 2;
```
Cela suppose que l'exposant est plus grand que le nombre de chiffres nécessaires pour représenter la plus grande possible de la mantisse valeur; sinon, il sera aussi un point décimal suivi par plus de chiffres.

CORRECTION

Le plus long nombre est en réalité représentable le plus faible nombre négatif: il a besoin de suffisamment de chiffres pour couvrir à la fois l'exposant et la mantisse. Cette valeur est -pow(2, DBL_MIN_EXP - DBL_MANT_DIG), où DBL_MIN_EXP est négatif. Il est assez facile de voir (et de prouver par induction) que -pow(2,-N) besoins 3+N caractères pour un non-scientifique de la représentation décimale ("-0.", suivie par N chiffres). Donc la réponse est
```
int max_digits = 3 + DBL_MANT_DIG - DBL_MIN_EXP
```
Pour un 64 bits IEEE double, nous avons
```
DBL_MANT_DIG = 53
DBL_MIN_EXP = -1023
max_digits = 3 + 53 - (-1023) = 1079
```
- Désolé, c'est faux - la plus longue numéros seront très petits, pas très grand, et il est plus compliqué de travailler hors de leur longueur. Il devrait être possible de travailler à partir de DBL_MIN_EXP et DBL_MANT_DIG; je vais mettre à jour la réponse si je peux travailler.
- J'ai corrigé maintenant.
- Merci pour la réponse très Mike. Dans le cas où quelqu'un a besoin de précisions: en gros, à virgule flottante a une règle spéciale qui dit que si tous les bits de l'exposant sont à zéro, alors le nombre est appelé "anormale" et l'implicite de pointe "1." (qui est par ailleurs toujours précédé sur la partie fractionnaire) n'est pas inclus. Cela signifie que par le réglage des bits d'exposant à tous les zéro, vous pouvez utiliser la partie fractionnaire pour obtenir un autre 15-16 chiffres sur la longueur de la base10 décimal expansion (c'est à dire comme 0.000...0001*2^-1023 où -1023 est l'exposant qui est codé comme tous les zéros en raison du biais de l'exposant).
- La partie fractionnaire (pour le dénormalisée cas) a un implicite "0." de sorte que vous pouvez toujours compter 52 décimales chiffres pour qui et pas 53. Donc la réponse est 1023 + 52 + 3 = 1078 chiffres. Je me demande pourquoi Java est livré avec de 1077 à Fred de l'exemple ci-dessous, si?
- Juste en ajoutant de référence pour l'avenir: par le même calcul d'un seul flotteur est: 3 + 24 + 127 = 154 (ou 153 si martin est correct)
- -1023 comme le DBL_MIN_EXP est bits et non de chiffres, de sorte que le calcul de max_digits ici ne semble pas droit
- Comme je l'ai dit, "Il est assez facile de voir (et de prouver par induction) que -pow(2,-N) besoins 3+N caractères pour un non-scientifique de la représentation décimale ("-0.", suivie par N chiffres)." N=1 donne -0.5 (1 chiffre fractionnaire); N=2 donne -0.25 (2 chiffres); et ainsi de suite, en augmentant la par un à chaque fois.
- Vous devez être te moques de moi... 1079 chiffres? Pourriez-vous faire un exemple de programme C qui génère un nombre dans stdout?
- Cette réponse est (encore) MAL. Le nombre maximum de caractères qui seront nécessaires pour imprimer une virgule double valeur (c'est à dire dans "%f" format) sera pour la valeur de -DBL_MIN (c-à -0x1p-1022, en supposant binary64 IEEE 754 est votre double). Pour cela, vous aurez besoin exactement 325 caractères. C'est: DBL_DIG + abs(DBL_MIN_10_EXP) + strlen("-0."). C'est évidemment parce qu' log10(fabs(DBL_MIN)) est de 308, qui est aussi abs(DBL_MIN_10_EXP)+1 (le +1 est parce que de le premier chiffre à gauche de la virgule), et c'est le nombre de zéros à gauche de l'chiffres significatifs.
- printf("%0.320lf\n", -DBL_MIN);
InformationsquelleAutor Mike Seymour
15

Selon IEEE 754-1985, la plus longue de la notation de la valeur représentée par le type double, à savoir:

-2.2250738585072020 E-308

a 24 caractères.
- Cool, pouvez-vous expliquer pourquoi c'est la plus longue? Pourquoi pas par exemple un petit 0.033211233457645...234234 devenir de plus?
- Si vous ne voulez pas la notation scientifique qui vous donnent 308 plus de caractères, alors...
- Parce que la mantisse de la double, à la suite de l'IEEE 754-1985, peuvent représenter des nombres avec une précision maximale de 17 chiffres après le point. Ajouter à la fois des inconvénients pour la mantisse et de la période, point, e-char et les 3 chiffres de la période (8 bits), et vous obtiendrez exacte de 24 caractères.
- 0.00000000000000000 ... approx 308 ... 00002225073858507202 ==> environ 326 caractères 🙂
- l'op dit pas explicitement en notation scientifique.
- Bonjour, pourriez-vous me dire pourquoi IEEE 754-1985, peuvent représenter des nombres avec une précision maximale de 17 chiffres après le point. Pourquoi 17 chiffres? Merci.
- 16 en fait. À partir de wiki: Le nombre de décimales de précision est calculée à l'aide d'number_of_mantissa_bits * Log10(2). Ainsi ~7.2 et ~15.9 pour simple et double précision, respectivement.
- Salut, merci de vous répondre. Est-ce dire que: nous avons 53bits en double de la mantisse, de sorte que le max décimal peut être représentée est de 2^53=9007199254740992 qui a 16 chiffres? Donc le max de précision est de 16 chiffres.
- basé sur la façon dont les décimales sont représentés en binaire, vous êtes à la recherche pour les 1/2^53 ~ 1e-16, ce qui correspond à 16 chiffres après le point décimal.
InformationsquelleAutor Vitaliy Ulantikov

Vous pouvez utiliser snprintf() pour vérifier le nombre de caractères dont vous avez besoin.
snprintf() renvoie le nombre de caractères nécessaires pour imprimer tout ce qui est transmis.

/* NOT TESTED */
#include <stdio.h>
#include <stdlib.h>
int main(void) {
    char dummy[1];
    double value = 42.000042; /* or anything else */
    int siz;
    char *representation;
    siz = snprintf(dummy, sizeof dummy, "%f", value);
    printf("exact length needed to represent 'value' "
           "(without the '\/* NOT TESTED */
#include <stdio.h>
#include <stdlib.h>
int main(void) {
char dummy[1];
double value = 42.000042; /* or anything else */
int siz;
char *representation;
siz = snprintf(dummy, sizeof dummy, "%f", value);
printf("exact length needed to represent 'value' "
"(without the '\\0' terminator) is %d.\n", siz);
representation = malloc(siz + 1);
if (representation) {
sprintf(representation, "%f", value);
/* use `representation` */
free(representation);
} else {
/* no memory */
}
return 0;
}
' terminator) is %d.\n", siz);
    representation = malloc(siz + 1);
    if (representation) {
        sprintf(representation, "%f", value);
        /* use `representation` */
        free(representation);
    } else {
        /* no memory */
    }
    return 0;
}

Note: snprintf() est un C99 fonction. Si un C89 compilateur fournit comme une extension, il ne peut pas faire ce que le programme ci-dessus en attend.

Modifier:
Changé le lien pour snprintf() à qui décrit les fonctionnalités imposées par le Standard C99; la description dans le original link est faux.

2013: changement du lien retour POSIX site que je préfère sur le site de la première édition.

Maintenant pour répondre à la question, il suffit de comprendre le nombre à attribuer à double value = ??;

InformationsquelleAutor pmg

4

Une bonne source d'information qui va plus dans le détail que le La norme IEEE-754 la Spécification sont ces notes de cours de l'UC Berkely à la page 4, plus un peu de BRICOLAGE calculs. Ces conférences diapositives sont également bonnes pour les étudiants en génie.

Recommandé Tailles De Tampon
```
| Single| Double | Extended | Quad  |
|:-----:|:------:|:--------:|:-----:|
|   16  |  24    |    30    |  45   |
```
Ces chiffres sont basés sur les calculs suivants:

Maximum de Décimales Comte de la Partie Intégrante
```
| Single| Double | Extended | Quad  |
|:-----:|:------:|:--------:|:-----:|
|   9   |   17   |    21    |  36   |

* Quantities listed in decimals.
```
Décimal comptes sont fondés sur la formule: À la plupart de Plafond(1 + NLog_10(2)) décimales, où N est le nombre de bits dans la partie intégrante*.

Maximum Exposant Longueurs
```
| Single| Double | Extended | Quad  |
|:-----:|:------:|:--------:|:-----:|
|   5   |   5    |     7    |   7   |
* Standard format is `e-123`.
```
Plus Rapide De L'Algorithme De

L'algorithme le plus rapide pour l'impression des nombres à virgule flottante est la Grisu2 algorithme détaillé dans le document de recherche L'impression des Nombres à virgule Flottante Rapidement et avec Précision. Le meilleur test que j'ai pu trouver peut être trouvé ici.

InformationsquelleAutor
2

Vous pouvez contrôler le nombre de chiffres dans la représentation de chaîne lorsque vous convertissez le float/double, d'une chaîne de caractères en paramètre de la précision. Le nombre maximum de chiffres serait alors égale à la représentation de chaîne de std::numeric_limits<double>::max() à la précision que vous spécifiez.
```
#include <iostream>
#include <limits>
#include <sstream>
#include <iomanip>

int main()
{
 double x = std::numeric_limits<double>::max();

 std::stringstream ss;
 ss << std::setprecision(10) << std::fixed << x;

 std::string double_as_string = ss.str();
 std::cout << double_as_string.length() << std::endl;
}
```
Donc, le plus grand nombre de chiffres dans un double avec une précision de 10 à 320 chiffres.

InformationsquelleAutor Charles Salvia
1

Dépend de ce que tu veux dire par "représenter". Fraction décimale n'ont pas exact à virgule flottante représentation. Lorsque vous convertissez fraction décimale -> binaire fraction -> décimal, vous n'avez pas exact décimal représentations et aura du bruit bits à la fin de la représentation binaire.

La question n'implique pas de départ de nombre décimal, mais tout le code source (et la saisie de l'utilisateur) est décimal, et implique le possible problème de troncature. Ce n'est "exact" signifie dans ces circonstances?

Fondamentalement, cela dépend de votre représentation à virgule flottante.

Si vous avez 48 bits de la mantisse, cela prend environ 16 chiffres décimaux. L'exposant peut-être le reste de 14 bits (environ 5 chiffres après la virgule).

La règle de base est que le nombre de bits est environ 3x le nombre de chiffres après la virgule.
- En fait, ils ne peuvent pas avoir infini de chiffres parce que toute fraction binaire peut être exprimé avec précision dans la notation décimale.
- Je veux dire représenter comme une base exacte 10 décimal d'extension (par exemple, pas de %e genre de trucs). Et je suis en supposant que nous sommes face à des C/C++ standard double à l'aide de la norme IEEE 754.
- Bien sûr. Je veux dire, dans la mémoire de la double est stocké dans une notation binaire comme 1101010.101000110101. Le nombre de chiffres après le binaire point est assez bien fini et peut donc être représenté précisément en décimal. 1/2 est représenté que 0,5; 1/4 est représenté comme 0.25; 1/8 est représenté comme 0.125; etc. Ai-je raté quelque chose?
- Le problème, c'est l'inverse. Chaque fraction décimale n'ont pas une représentation binaire exacte. Donc, si votre "original" le nombre est un nombre décimal, le float->décimale sera mal pour commencer. Le nombre de chiffres après la virgule n'est pas grave si ce que vous êtes en comparant avec a été décimal.
- Bien sûr, les fractions décimales ne peut pas être représenté précisément en binaire fractions. Je n'ai jamais dit le contraire. Mais binaire fractions peut être représenté précisément dans les fractions décimales, donc à mon humble avis "des valeurs à virgule Flottante n'ont pas exact décimal représentations et peut avoir un nombre infini de répétition de chiffres après la virgule." n'est pas correct.
- Je prie de différer. J'aurais mis "bien sûr, pas toutes les fractions décimales peut être représenté précisément en binaire fractions."
InformationsquelleAutor S.Lott

1024 n'est pas assez, le plus petit négatif double de la valeur a 1077 chiffres après la virgule. Voici le code Java.

double x = Double.longBitsToDouble(0x8000000000000001L);
BigDecimal bd = new BigDecimal(x);
String s = bd.toPlainString();
System.out.println(s.length());
System.out.println(s);

Ici est la sortie du programme.

1077
-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004940656458412465441765687928682213723650598026143247644255856825006755072702087518652998363616359923797965646954457177309266567103559397963987747960107818781263007131903114045278458171678489821036887186360569987307230500063874091535649843873124733972731696151400317153853980741262385655911710266585566867681870395603106249319452715914924553293054565444011274801297099995419319894090804165633245247571478690147267801593552386115501348035264934720193790268107107491703332226844753335720832431936092382893458368060106011506169809753078342277318329247904982524730776375927247874656084778203734469699533647017972677717585125660551199131504891101451037862738167250955837389733598993664809941164205702637090279242767544565229087538682506419718265533447265625

// affiche une est plus longue que 1077: import java.les mathématiques.BigDecimal; public class Program { public static void print_bigdecimal(String nom, BigDecimal bd) { String s = bd.toPlainString(); System.out.println ("NUM" + nom + ": "+ s + " (" + s.length() + " caractères)"); } public static void main(String[] args) { print_bigdecimal("-2^-1075==", new BigDecimal(-1).diviser (new BigDecimal(2).pow(1075))); print_bigdecimal("0x80...01L", new BigDecimal(Double.longBitsToDouble(0x8000000000000001L))); } }
2^-1075 est valide parce que c'est 2^-52 + 2^-1023
Ce que vous voyez est une mauvaise impression de l'algorithme. On peut utiliser une Grisu3 algorithme pour ce cas limite.
affaire"? L' (quoique) très petite valeur est une valeur de "faible valeur" - rien de plus, rien de moins, Le tempreal de 10 octets type réel permet, même les plus petites valeurs. Le gmplib bibliothèques plus petites encore.

InformationsquelleAutor Fred

1

"Quelle est la longueur maximale en caractères nécessaires pour représenter le double de la valeur?"

La réponse exacte à cette question est: 8 caractères ASCII dans un hexadicimal format, à l'exclusion de la " 0x " préfixe - 100% de précision 🙂 (mais ce n'est pas juste une blague)

Le seuil de précision de la norme IEEE-754 double est d'environ 16 chiffres décimaux - donc à l'exclusion des fins éducatives, des représentations plus que qui sont juste un gaspillage de ressources et de puissance de calcul:
- Les utilisateurs ne reçoivent pas plus informés quand ils voient un 700 chiffres sur l'écran de mesure.
- Variables de Configuration stockées dans la "plus précis" formulaire sont inutiles -, toute opération sur le nombre va détruire l'exactitude. (à l'exclusion changeant le bit de signe)
Si quelqu'un a besoin de mieux réel de précision, puis il y a 80 bits de long double, avec près de 18 chiffres de l'exactitude ou de la f.e. libquadmath.

Ce qui concerne.

InformationsquelleAutor vtomazzi
0

Le nombre maximum de caractères qui seront nécessaires pour imprimer une virgule double valeur (c'est à dire dans "%f" format) sera pour la valeur de -DBL_MIN (c-à -0x1p-1022, en supposant binary64 IEEE 754 est votre double). Pour cela, vous aurez besoin exactement 325 caractères. C'est: DBL_DIG + abs(DBL_MIN_10_EXP) + strlen("-0."). C'est évidemment parce qu' log10(fabs(DBL_MIN)) est de 308, qui est aussi abs(DBL_MIN_10_EXP)+1 (le +1 est parce que de le premier chiffre à gauche de la virgule), et c'est le nombre de zéros à gauche de l'chiffres significatifs.
```
int lz;                 /* aka abs(DBL_MIN_10_EXP)+1 */
int dplaces;
int sigdig;             /* aka DBL_DECIMAL_DIG - 1 */
double dbl = -DBL_MIN;

lz = abs((int) lrint(floor(log10(fabs(dbl)))));
sigdig = lrint(ceil(DBL_MANT_DIG * log10((double) FLT_RADIX)));
dplaces = sigdig + lz - 1;
printf("f = %.*f\n", dplaces, dbl);
```
- Mon résultat est "f = -0.00000000(plus de 300 zéros) 000000000000000" et printf("lz = %d, sigdig = %d, dplaces = %d, dbl = %g\n", lz, sigdig, dplaces, dbl); imprime "lz = 308, sigdig = 16, dplaces = 323, dbl = -2.22507 e-308". La sortie recevez-vous?
- lrint() appel d'offre que peu de valeur par rapport à la seule (int). Retrait, il ajoute de la clarté.
- Le sigdig formule est désactivée par 1 avec FLT_RADIX == 2. Voir la définition de DBL_DECIMAL_DIG qui est effectivement ce que sigdig devrait être de déterminer chiffres significatifs pour tous les double. Suggérer sigdig = DBL_DECIMAL_DIG; (par exemple 17)
- Remarque, DBL_MIN est le plus petit de la normale. DBL_TRUE_MIN est le plus petit non-zéro double. Bien sûr, avec l'impression de l'importance des chiffres, à l'aide DBL_MIN suffira - que cette réponse ne.
- Comme je l'ai dit dans le commentaire sigdig est DBL_DECIMAL_DIG - 1
InformationsquelleAutor Greg A. Woods
0

Ce n'est pas l'ambiguïté d'un ensemble de réponses à tous. Je suis à la recherche de quelque chose à dire à un C# spécificateur de format dans le but d'exercer un analyseur je suis en train de travailler sur. Je suis au hasard de générer des cas de test, y compris la double ou de la précision en virgule flottante constantes, et j'ai besoin de l'aller-retour pour être conservé. Oui, je sais qu'il est "aller-retour", qui en est un aspect. Mais j'ai aussi besoin de soutien Fixe ainsi que Scientifique notation. Jusqu'à présent j'aime 1079 mais cela ne semble pas excessif pour moi. Ou à tout le moins mon "assez proche" de la comparaison doit prendre que la variance en compte les pré/post-analyser la vérification.

InformationsquelleAutor mwpowellhtx
-1

"Pour que vous aurez besoin exactement 325 caractères"

Apparemment (et c'est un cas très commun) Vous ne comprenez pas la façon dont la conversion entre les différents numérique des bases travaux.

Peu importe le degré de précision de la définition de la DBL_MIN est, il est limité par le matériel de précision, ce qui est généralement jusqu'à 80 bits ou 18 chiffres décimaux (x86 et architectures similaires)

Pour cette raison, spécialisé en précision arbitraire-l'arithmétique des bibliothèques a été inventé, comme f.e. gmp ou de mpfr.

InformationsquelleAutor vtomazzi

Vous devez vous connecter pour publier un commentaire.

Recommandé Tailles De Tampon

Maximum de Décimales Comte de la Partie Intégrante

Maximum Exposant Longueurs

Plus Rapide De L'Algorithme De