Comment puis-je imprimer un double de la valeur avec une précision à l'aide de cout?

Donc j'ai obtenu la réponse à ma dernière question (je ne sais pas pourquoi je n'avais pas pensé à ça). J'ai l'impression d'un double à l'aide de cout qui s'est arrondi quand je ne l'attendais pas. Comment puis-je faire cout imprimer un double à l'aide de précision?

InformationsquelleAutor Jason Punyon | 2009-02-16
  1. 351

    Vous pouvez régler la précision directement sur std::cout et l'utilisation de la std::fixed spécificateur de format.

    double d = 3.14159265358979;
cout.precision(17);
cout << "Pi: " << fixed << d << endl;

    Vous pouvez #include <limits> pour obtenir le maximum de précision d'un float ou double.

    #include <limits>

typedef std::numeric_limits< double > dbl;

double d = 3.14159265358979;
cout.precision(dbl::max_digits10);
cout << "Pi: " << d << endl;
    • Pourquoi avez-vous explicitement conseille d'utiliser des fixed? Avec double h = 6.62606957e-34;, fixed me donne 0.000000000000000 et scientific sorties 6.626069570000000e-34.
    • Réglage de précision fonctionne également sur les stringstream objets
    • La précision doit être de 17 (ou std::numeric_limits<double>::digits10 + 2) parce que 2 chiffres supplémentaires sont nécessaires lors de la conversion de décimal de retour à la représentation binaire de s'assurer que la valeur est arrondie à la même valeur d'origine. Voici un papier avec quelques détails: docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html
    • Est vraiment la bonne réponse? Quand j'ai manuellement l'utilisation d'un grand nombre, je peux imprimer, 51 chiffres de approchée e, mais avec cout.precision(numeric_limits<double>::digits10 + 2); je ne reçois 16....
    • Pour ceux qui cherchent où il mentionne 17 chiffres dans le document @MikeFisher cité, c'est en vertu du Théorème 15.
    • Vous avez raison, C++11 introduit max_digits10 pour désigner la même. Fixe la réponse pour en tenir compte.
    • max_digits10 pourrait être utile pour le réglage du nombre de chiffres affichés en notation scientifique; fixe, elle ne fonctionne que pour des valeurs de magnitude proche de 1.
    • Mais quelle est la raison derrière? pourquoi pas de cout d'impression de la valeur?
    • Je suis d'accord avec vous. max_digits10 donne le nombre maximal de chiffres avant et après la virgule. set_precision() fixe spécificateur permet de définir le nombre de chiffres après le point décimal.
    • suis-je en droit de penser alors que le posté la solution de travail, car si max_digits10 indique le nombre total de chiffres de la période alors set_precision avec nombre de chiffres ne doit être exagéré, et pas de la précision doit être perdu?
    • En désaccord à propos de "ou std::numeric_limits<double>::digits10 + 2". Selon diverses FP attributs, en général, le +2, doit être aussi haut que +3. Note +3 s'applique généralement aux float.
    • en effet, avec flotteur nous avons 6 vs 9 chiffres. Mais aussi avec long double sur x87 (avec plus de précision, par exemple, dans CCG), nous avons 18 vs 21 chiffres, bien qu'avec float128 (IEEE754 binary128): 33 vs 36 chiffres. C'est donc le double qui est aberrant avec ses 15 vs 17 chiffres min et max.

    InformationsquelleAutor Bill the Lizard
  2. 60

    Utilisation std::setprecision:

    std::cout << std::setprecision (15) << 3.14159265358979 << std::endl;
    • Est-il une sorte de MAX_PRECISION macro ou enum ou quelque chose que je peux passer à std::setPrecision?
    • std::setprecision(15) pour une double (ok ou 16), log_10(2**de 53) ~= 15.9
    • std::setprecision(std::numeric_limits<double>::digits10)
    • coool...
    • Devrait être std::setprecision (17) pour le double, voir les commentaires sur @Bill Le Lézard de réponse.
    • std::setprecision de travail, #include <iomanip> doit être inclus.

    InformationsquelleAutor Paul Beckingham
  3. 23

    Voici ce que je voudrais utiliser:

    std::cout << std::setprecision (std::numeric_limits<double>::digits10 + 1)
          << 3.14159265358979
          << std::endl;

    Fondamentalement les limites paquet a des traits de caractère pour tous les construire dans les types de.

    L'un des traits pour les nombres à virgule flottante (float, double, long double) est le digits10 attribut. Cela définit la précision (j'ai oublié la terminologie exacte) d'un nombre à virgule en base 10.

    Voir: http://www.cplusplus.com/reference/std/limits/numeric_limits.html

    Pour plus de détails sur d'autres attributs.

    • Cet en-tête est nécessaire pour l'utilisation de std::setprecision(): #include <iomanip>
    • il devrait être std::numeric_limits<double> au lieu de numberic_limits<double>
    • Pourquoi ajoutez-vous 1 à std::numeric_limits<double>::digits10?
    • En raison des erreurs d'arrondi lors de l'impression.
    • Vous pouvez utiliser C+11 max_digits10 à la place. Voir this.
    • Devrait être std::setprecision (std::numeric_limits<double>::digits10 + 2) , voir les commentaires sur @Bill Le Lézard de réponse.
    • Il devrait plutôt être max_digits10, pas arbitraire digits10+2. Sinon, dans le cas de float, long double, boost::multiprecision::float128 ce sera un échec, car il vous faudrait +3 au lieu de +2.

    InformationsquelleAutor Martin York
  4. 13

    La iostreams façon est une sorte de maladroit. Je préfère utiliser boost::lexical_cast parce qu'il calcule le droit de précision pour moi. Et c'est rapide, trop.

    #include <string>
#include <boost/lexical_cast.hpp>

using boost::lexical_cast;
using std::string;

double d = 3.14159265358979;
cout << "Pi: " << lexical_cast<string>(d) << endl;

    De sortie:

    Pi: 3.14159265358979

    • Le coup de pouce de la documentation dit "Pour les objets numériques qui correspondent à un degré de spécialisation des std::numeric_limits, la version actuelle choisit maintenant une précision de match". Cela semble être la façon la plus simple pour obtenir le max de précision. (boost.org/doc/libs/1_58_0/doc/html/boost_lexical_cast/...)
    InformationsquelleAutor Timothy003
  5. 10

    Voici comment afficher un double avec une précision complète:

    double d = 100.0000000000005;
int precision = std::numeric_limits<double>::max_digits10;
std::cout << std::setprecision(precision) << d << std::endl;

    Cette affiche:

    100.0000000000005


    max_digits10 est le nombre de chiffres qui sont nécessaires pour représenter de façon unique toutes différentes valeurs doubles. max_digits10 représente le nombre de chiffres avant et après la virgule.


    Ne pas utiliser set_precision(max_digits10) avec std::fixe.

    Sur fixe notation, set_precision() définit le nombre de chiffres seulement après le point décimal. C'est incorrect car max_digits10 représente le nombre de chiffres avant et après le point décimal.

    double d = 100.0000000000005;
int precision = std::numeric_limits<double>::max_digits10;
std::cout << std::fixed << std::setprecision(precision) << d << std::endl;

    Cette affiche un résultat incorrect:

    100.00000000000049738

    Remarque: les fichiers d'en-Tête requis

    #include <iomanip>
#include <limits>
    • Cela se produit parce que 100.0000000000005 n'est pas exactement comme dans un double. (Il peut sembler comme il se doit, mais il ne le fait pas, car il est normalisé, c'est à dire sa représentation binaire). Pour voir cela, essayez: 100.0000000000005 - 100. Nous obtenons 4.973799150320701e-13.
    InformationsquelleAutor Daniel Laügt
  6. 9

    Par plus de précision, je suppose que signifie suffisamment de précision pour montrer la meilleure approximation de la valeur de référence, mais il convient de rappeler que double est stocké à l'aide de représentation en base 2 et en base 2 ne peut pas représenter quelque chose d'aussi trivial que 1.1 exactement. La seule façon d'obtenir la plein plein précision de la double réel (SANS arrondi ERREUR) est à imprimer les bits binaires (ou hex nybbles). Une façon de le faire est d'écrire le double à un union et l'impression de la valeur de l'entier de bits.

    union {
    double d;
    uint64_t u64;
} x;
x.d = 1.1;
std::cout << std::hex << x.u64;

    Cela vous donnera 100% de précision de précision de la double... et être totalement illisible parce que les humains ne peuvent pas lire IEEE double format ! Wikipédia a une bonne écriture sur la façon d'interpréter les bits binaires.

    Dans les nouvelles versions de C++, vous pouvez le faire

    std::cout << std::hexfloat << 1.1;
    InformationsquelleAutor Mark Lakata
  7. 4

    Comment puis-je imprimer un double valeur avec une précision à l'aide de cout?

    Utilisation hexfloat ou

    utilisation scientific et de définir la précision

    std::cout.precision(std::numeric_limits<double>::max_digits10 - 1);
std::cout << std::scientific <<  1.0/7.0 << '\n';

//C++11 Typical output
1.4285714285714285e-01

    Trop de réponses traiter un seul de 1) base 2) fixe/disposition scientifique ou 3) de précision. Trop de réponses avec précision ne pas fournir la bonne valeur. D'où cette réponse à une vieille question.

    1. Quelle base?

    Un double est certainement codée en utilisant la base 2. Une approche directe avec le C++11 est à imprimer à l'aide de std::hexfloat.

    Si une non-sortie décimale est acceptable, nous sommes fait.

    std::cout << "hexfloat: " << std::hexfloat << exp (-100) << '\n';
std::cout << "hexfloat: " << std::hexfloat << exp (+100) << '\n';
//output
hexfloat: 0x1.a8c1f14e2af5dp-145
hexfloat: 0x1.3494a9b171bf5p+144
    1. Autrement: fixed ou scientific?

    Un double est un virgule flottante type, pas point fixe.

    Ne pas utilisation std::fixed que qui ne parvient pas à imprimer de petits double que quelque chose, mais 0.000...000. Pour les grandes double, il imprime de nombreux chiffres, peut-être des centaines interroge sur le caractère informatif.

    std::cout << "std::fixed: " << std::fixed << exp (-100) << '\n';
std::cout << "std::fixed: " << std::fixed << exp (+100) << '\n';
//output
std::fixed: 0.000000
std::fixed: 26881171418161356094253400435962903554686976.000000

    Pour l'impression avec plus de précision, utilisez d'abord std::scientific qui va "écrire des valeurs à virgule flottante en notation scientifique". Avis de la valeur par défaut de 6 chiffres après la virgule, un montant insuffisant, est traitée dans le point suivant.

    std::cout << "std::scientific: " << std::scientific << exp (-100) << '\n';  
std::cout << "std::scientific: " << std::scientific << exp (+100) << '\n';
//output
std::scientific: 3.720076e-44
std::scientific: 2.688117e+43
    1. Combien de précision (le nombre total de chiffres?

    Un double codé binaire de la base de 2 code pour la même précision entre les diverses puissances de 2. C'est souvent 53 bits.

    [1.0 2.0...) il y a 253 différentes double,

    [2.0 4.0...) il y a 253 différentes double,

    [8.0 4.0...) il y a 253 différentes double,

    [8.0...10.0) il y a 2/8 * 253 différentes double.

    Encore si le code imprime en décimal avec N chiffres significatifs, le nombre de combinaisons [1.0...10.0) est de 9/10 * 10N.

    Quelle que soit N (de précision) est choisi, il ne sera pas un one-to-one mapping entre double de décimales et de texte. Si un fixe N est choisi, il sera parfois un peu plus ou moins de vraiment nécessaire que pour certaines double valeurs. Nous pourrions d'erreur sur trop peu (a) ci-dessous) ou trop (b) ci-dessous).

    3 candidats N:

    a) Utiliser une N donc, lors de la conversion de texte-doubletexte, nous arrivons dans le même texte pour tous les double.

    std::cout << dbl::digits10 << '\n';
//Typical output
15

    b) Utiliser un N donc, lors de la conversion de double-texte-double nous arrivons à la même double pour tous double.

    //C++11
std::cout << dbl::max_digits10 << '\n';
//Typical output
17

    Quand max_digits10 n'est pas disponible, il faut noter qu'en raison de la base 2 et en base 10 attributs, digits10 + 2 <= max_digits10 <= digits10 + 3, nous pouvons utiliser digits10 + 3 pour assurer assez de chiffres décimaux sont imprimés.

    c) Utiliser un N qui varie en fonction de la valeur.

    Cela peut être utile lorsque le code veut afficher un texte minimal (N == 1) ou le exacte valeur d'un double (N == 1000-ish dans le cas de denorm_min). Pourtant, depuis c'est le "travail" et n'est pas susceptible OP objectif, il sera mis de côté.

    Il est généralement b) qui est utilisé pour l'impression d'un double valeur avec plus de précision". Certaines applications peuvent préférer un) à l'erreur de ne pas fournir trop d'informations.

    Avec .scientific, .precision() définit le nombre de chiffres à imprimer après la virgule, ce qui 1 + .precision() chiffres sont imprimés. Le Code doit max_digits10 total des chiffres de telle sorte .precision() est appelée avec un max_digits10 - 1.

    typedef std::numeric_limits< double > dbl;
std::cout.precision(dbl::max_digits10 - 1);
std::cout << std::scientific <<  exp (-100) << '\n';
std::cout << std::scientific <<  exp (+100) << '\n';
//Typical output
3.7200759760208361e-44
2.6881171418161356e+43

    Similaire C question

    InformationsquelleAutor chux
  8. 3
    printf("%.12f", M_PI);

    %.12f moyens à virgule flottante, avec une précision de 12 chiffres.

    • Ce n'est pas "à l'aide de cout".
    • Mais résolu mon paresseux aller à google question @Johnsyweb jajaja
    • 12 chiffres n'est pas "de précision"
    InformationsquelleAutor Maister
  9. 1

    cout est un objet qui a un tas de méthodes que vous pouvez appeler pour modifier la précision et de la mise en forme de l'imprimé choses.

    Il y a un setprecision(...) de l'opération, mais vous pouvez également définir d'autres choses comme la largeur d'impression, etc.

    Rechercher cout dans votre IDE de référence.

    InformationsquelleAutor Uri
  10. 0

    La plupart de façon portable...

    #include <limits>

using std::numeric_limits;

    ...
    cout.precision(numeric_limits<double>::digits10 + 1);
    cout << d;
    • Je suis curieux: pourquoi le "+1"?
    InformationsquelleAutor
  11. 0

    Avec ostream::précision(int)

    cout.precision( numeric_limits<double>::digits10 + 1);
cout << M_PI << ", " << M_E << endl;

    donnera

    3.141592653589793, 2.718281828459045

    Pourquoi vous devez dire "+1", je n'ai aucune idée, mais le chiffre supplémentaire pour vous est correct.

    • Peut-être parce qu'il n'est pas toujours correcte? (juste deviner)
    • numeric_limits<unsigned char>::digits10 est égal à 2. Parce qu'il peut contenir n'importe quel nombre décimal de deux chiffres (0..99. Il peut également contenir 255.. mais pas 256, 257 300 etc.... c'est pourquoi digits10 n'est pas 3! Je pense que les "+1" est ajouté à surmonter quelque chose comme ça.
    InformationsquelleAutor Jann