Wie drucke ich mit cout einen doppelten Wert mit voller Präzision?

Also habe ich die Antwort auf meine letzte Frage bekommen (ich weiß nicht, warum ich nicht daran gedacht habe). Ich habe eine doubleVerwendung gedruckt cout, die gerundet wurde, als ich sie nicht erwartet hatte. Wie kann ich einen coutAusdruck doublemit voller Präzision erstellen?

Sie können die Genauigkeit direkt einstellen std::coutund den std::fixedFormatbezeichner verwenden.

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

Sie können #include <limits>die maximale Präzision eines Floats oder Double erzielen.

#include <limits>

typedef std::numeric_limits< double > dbl;

double d = 3.14159265358979;
cout.precision(dbl::max_digits10);
cout << "Pi: " << d << endl;

Verwendung std::setprecision:

std::cout << std::setprecision (15) << 3.14159265358979 << std::endl;

Folgendes würde ich verwenden:

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

Grundsätzlich enthält das Limits-Paket Merkmale für alle eingebauten Typen.
Eine der Eigenschaften für Gleitkommazahlen (float / double / long double) ist das Attribut digits10. Dies definiert die Genauigkeit (ich vergesse die genaue Terminologie) einer Gleitkommazahl in Basis 10.

Weitere Informationen zu anderen Attributen finden Sie unter: http://www.cplusplus.com/reference/std/limits/numeric_limits.html
.

Der iostreams Weg ist irgendwie klobig. Ich bevorzuge die Verwendung, boost::lexical_castweil sie die richtige Präzision für mich berechnet. Und es ist auch schnell .

#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;

Ausgabe:

Pi: 3.14159265358979

Bei voller Genauigkeit gehe ich davon aus, dass die Genauigkeit genau genug ist, um die beste Annäherung an den beabsichtigten Wert zu zeigen, aber es sollte darauf hingewiesen werden, dass doubledie Verwendung unter Verwendung der Basis 2-Darstellung gespeichert wird und die Basis 2 nicht so trivial wie 1.1genau darstellen kann. Die einzige Möglichkeit, die volle Genauigkeit des tatsächlichen Doppels (ohne Abrundungsfehler) zu erhalten, besteht darin, die Binärbits (oder Hex-Nybbles) auszudrucken. Eine Möglichkeit, dies zu tun, besteht darin, das doublein a zu schreiben unionund dann den ganzzahligen Wert der Bits auszudrucken.

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

Dies gibt Ihnen die 100% genaue Genauigkeit des Doppels ... und ist absolut unlesbar, da Menschen das IEEE-Doppelformat nicht lesen können! Wikipedia hat eine gute Beschreibung der Interpretation der Binärbits.

In neuerem C ++ können Sie dies tun

std::cout << std::hexfloat << 1.1;

So zeigen Sie ein Double mit voller Präzision an:

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

Dies zeigt an:

100.0000000000005

max_digits10 ist die Anzahl der Stellen, die erforderlich sind, um alle unterschiedlichen Doppelwerte eindeutig darzustellen. max_digits10 steht für die Anzahl der Stellen vor und nach dem Dezimalpunkt.

Verwenden Sie set_precision (max_digits10) nicht mit std :: fixed.
Bei fester Notation legt set_precision () die Anzahl der Stellen erst nach dem Dezimalpunkt fest. Dies ist falsch, da max_digits10 die Anzahl der Stellen vor und nach dem Dezimalpunkt darstellt.

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

Dies zeigt ein falsches Ergebnis an:

100.00000000000049738

Hinweis: Header-Dateien erforderlich

#include <iomanip>
#include <limits>

Wie drucke ich einen doubleWert mit cout mit voller Präzision?

Verwenden hexfloatoder
verwenden scientificund stellen Sie die Präzision ein

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

Zu viele Antworten sprechen nur eine von 1) Basis 2) festem / wissenschaftlichem Layout oder 3) Präzision an. Zu viele präzise Antworten liefern nicht den richtigen Wert. Daher diese Antwort auf eine alte Frage.

1. Welche Basis?

A doublewird sicherlich mit Basis 2 codiert. Ein direkter Ansatz mit C ++ 11 besteht darin, mit zu drucken std::hexfloat.
Wenn eine nicht dezimale Ausgabe akzeptabel ist, sind wir fertig.

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

2. Sonst: fixedoder scientific?

A doubleist ein Gleitkommatyp , kein Festkomma .

Verwenden Sie nicht , std::fixedda dies nicht so klein doublewie alles andere als drucken kann 0.000...000. Im Großen doubleund Ganzen werden viele Ziffern gedruckt, möglicherweise Hunderte fragwürdiger Informationen.

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 

Um mit voller Präzision zu drucken, verwenden Sie zuerst std::scientific"Gleitkommawerte in wissenschaftlicher Notation schreiben". Beachten Sie, dass der Standardwert von 6 Stellen, nachdem der Dezimalpunkt, ein unzureichender Betrag, im nächsten Punkt behandelt wird.

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

3. Wie genau (wie viele Ziffern insgesamt)?

Eine doubleunter Verwendung der Binärbasis 2 codierte Codierung codiert die gleiche Genauigkeit zwischen verschiedenen Potenzen von 2. Dies sind häufig 53 Bit.

[1.0 ... 2.0) es gibt 2 ⁵³ verschiedene double,
[2.0 ... 4.0) es gibt 2 ⁵³ verschiedene double,
[4.0 ... 8.0) es gibt 2 ⁵³ verschiedene double,
[8.0 ... 10.0) es gibt 2 / 8 * 2 ⁵³ verschiedene double.

Doch wenn Code druckt in dezimal mit Nsignifikanten Stellen, die Anzahl der Kombinationen [1.0 ... 10.0) ist 9/10 * 10 ^N .

Unabhängig von der Ngewählten (Genauigkeit) erfolgt keine Eins-zu-Eins-Zuordnung zwischen doubleund Dezimaltext. Wenn ein Fix Nausgewählt wird, ist er manchmal für bestimmte doubleWerte etwas mehr oder weniger als wirklich erforderlich . Wir könnten bei zu wenigen ( a)unten) oder zu vielen ( b)unten) Fehler machen .

3 Kandidat N:

a) Verwenden Sie ein Nso, wenn Sie aus doubleText-Text konvertieren, erhalten wir für alle den gleichen Text double.

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

b) Verwenden Sie ein Nso, wenn Sie von double-text- konvertieren, doublewir kommen doublefür alle gleich double.

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

Wenn max_digits10nicht verfügbar, beachten Sie, dass digits10 + 2 <= max_digits10 <= digits10 + 3wir aufgrund der Attribute Basis 2 und Basis 10 verwenden könnendigits10 + 3 , dass genügend Dezimalstellen gedruckt werden.

c) Verwenden Sie eine N, die mit dem Wert variiert.

Dies kann nützlich sein, wenn Code minimalen Text ( N == 1) oder den genauen Wert von a double( N == 1000-ishim Fall von denorm_min) anzeigen möchte . Da dies jedoch "Arbeit" ist und wahrscheinlich nicht das Ziel von OP ist, wird es beiseite gelegt.

Es wird normalerweise b) verwendet, um "einen doubleWert mit voller Genauigkeit zu drucken ". Einige Anwendungen ziehen es möglicherweise vor, a) Fehler zu machen, wenn nicht zu viele Informationen bereitgestellt werden.

Legt mit fest .scientific, wie .precision()viele Stellen nach dem Dezimalpunkt 1 + .precision()gedruckt werden sollen , damit die Stellen gedruckt werden. Code benötigt max_digits10insgesamt Ziffern und wird daher .precision()mit a aufgerufen 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
//1234567890123456  17 total digits

Ähnliche C-Frage

printf("%.12f", M_PI);

% .12f bedeutet Gleitkomma mit einer Genauigkeit von 12 Stellen.

Am tragbarsten ...

#include <limits>

using std::numeric_limits;

    ...
    cout.precision(numeric_limits<double>::digits10 + 1);
    cout << d;

Mit ostream :: präzise (int)

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

wird nachgeben

3.141592653589793, 2.718281828459045

Warum Sie "+1" sagen müssen Ich habe keine Ahnung, aber die zusätzliche Ziffer, die Sie daraus erhalten, ist korrekt.

Dies zeigt den Wert bis zu zwei Dezimalstellen nach dem Punkt an.

#include <iostream>
#include <iomanip>

double d = 2.0;
int n = 2;
cout << fixed << setprecison(n) << d;

Siehe hier: Festkommanotation

std :: behoben

Feste Gleitkommanotation verwenden Setzt das Floatfield-Format-Flag für den str-Stream auf fest.

Wenn floatfield auf fest gesetzt ist, werden Gleitkommawerte in Festkommanotation geschrieben: Der Wert wird mit genau so vielen Stellen im Dezimalteil dargestellt, wie durch das Genauigkeitsfeld (Genauigkeit) angegeben, und ohne Exponententeil.

std :: setprecision

Festlegen der Dezimalgenauigkeit Legt die Dezimalgenauigkeit fest, die zum Formatieren von Gleitkommawerten bei Ausgabeoperationen verwendet werden soll.

Wenn Sie mit dem IEEE-Standard zur Darstellung der Gleitkommazahlen vertraut sind, wissen Sie, dass es unmöglich ist, Gleitkommazahlen außerhalb des Geltungsbereichs des Standards mit voller Genauigkeit anzuzeigen , das heißt, dies führt immer dazu eine Rundung des realen Wertes.

Sie müssen zuerst prüfen, ob der Wert innerhalb des Bereichs liegt. Wenn ja, verwenden Sie:

cout << defaultfloat << d ;

std :: defaultfloat

Standard-Gleitkommanotation verwenden Setzt das Floatfield-Format-Flag für den str-Stream auf defaultfloat.

Wenn floatfield auf defaultfloat gesetzt ist, werden Gleitkommawerte mit der Standardnotation geschrieben: Die Darstellung verwendet so viele aussagekräftige Ziffern wie erforderlich bis zur Dezimalgenauigkeit (Genauigkeit) des Streams und zählt sowohl die Ziffern vor als auch nach dem Dezimalpunkt (falls vorhanden) ).

Dies ist auch das Standardverhalten von cout, was bedeutet, dass Sie es nicht explizit verwenden.