ฉันจะพิมพ์ค่าสองเท่าด้วยความแม่นยำเต็มที่ใช้ cout ได้อย่างไร

ดังนั้นฉันจึงได้คำตอบสำหรับคำถามสุดท้ายของฉัน(ฉันไม่รู้ว่าทำไมฉันไม่คิดอย่างนั้น) ฉันกำลังพิมพ์การdoubleใช้coutที่ปัดเศษเมื่อฉันไม่ได้คาดหวัง ฉันจะcoutพิมพ์doubleด้วยความแม่นยำได้อย่างไร

คุณสามารถตั้งค่าความแม่นยำได้โดยตรงstd::coutและใช้ตัวstd::fixedระบุรูปแบบ

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

คุณสามารถที่#include <limits>จะได้รับความแม่นยำสูงสุดของการลอยหรือสองครั้ง

#include <limits>

typedef std::numeric_limits< double > dbl;

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

การใช้std::setprecision:

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

นี่คือสิ่งที่ฉันจะใช้:

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

โดยทั่วไปแพคเกจ จำกัด มีลักษณะสำหรับการสร้างในทุกประเภท
หนึ่งในลักษณะของเลขทศนิยม (ลอย / สองครั้ง / ยาวคู่) คือคุณลักษณะ สิ่งนี้กำหนดความถูกต้อง (ฉันลืมคำศัพท์ที่แน่นอน) ของเลขทศนิยมในฐาน 10

ดู: http://www.cplusplus.com/reference/std/limits/numeric_limits.html
สำหรับรายละเอียดเกี่ยวกับคุณลักษณะอื่น ๆ

วิธี iostreams เป็นประเภทของ clunky ฉันชอบที่จะใช้boost::lexical_castเพราะมันคำนวณความแม่นยำที่เหมาะสมสำหรับฉัน และมันก็เร็วเช่นกัน

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

เอาท์พุท:

Pi: 3.14159265358979

โดยความแม่นยำเต็มที่ฉันถือว่าความแม่นยำเพียงพอที่จะแสดงการประมาณค่าที่ดีที่สุด แต่ควรชี้ให้เห็นว่าdoubleถูกเก็บไว้โดยใช้การแสดงฐาน 2 และฐาน 2 ไม่สามารถแสดงสิ่งที่เล็กน้อยได้อย่าง1.1แน่นอน วิธีเดียวที่จะได้รับความแม่นยำเต็มรูปแบบของ double double (ไม่มีข้อผิดพลาดรอบนอก) คือการพิมพ์บิตไบนารี่ (หรือ hex nybbles) วิธีหนึ่งในการทำเช่นนั้นคือการเขียนdoublea ไปยังunionจากนั้นพิมพ์ค่าจำนวนเต็มของบิต

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

สิ่งนี้จะให้ความแม่นยำที่ถูกต้อง 100% ของ double ... และไม่สามารถอ่านได้อย่างเต็มที่เนื่องจากมนุษย์ไม่สามารถอ่านรูปแบบ double IEEE ได้! Wikipediaมีการเขียนที่ดีเกี่ยวกับวิธีตีความบิตไบนารี่

ใน C ++ ที่ใหม่กว่าคุณสามารถทำได้

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

นี่คือวิธีการแสดงสองครั้งด้วยความแม่นยำเต็มรูปแบบ:

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

สิ่งนี้แสดง:

100.0000000000005

max_digits10 เป็นจำนวนหลักที่จำเป็นในการแสดงค่าสองเท่าที่แตกต่างกันโดยเฉพาะ max_digits10 หมายถึงจำนวนหลักก่อนและหลังจุดทศนิยม

อย่าใช้ set_precision (max_digits10) กับ std :: fixed
สัญกรณ์คงที่ set_precision () ตั้งค่าจำนวนหลักหลังจุดทศนิยม สิ่งนี้ไม่ถูกต้องเนื่องจาก max_digits10 แสดงถึงจำนวนหลักก่อนและหลังจุดทศนิยม

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

สิ่งนี้แสดงผลลัพธ์ที่ไม่ถูกต้อง:

100.00000000000049738

หมายเหตุ: จำเป็นต้องใช้ไฟล์ส่วนหัว

#include <iomanip>
#include <limits>

ฉันจะพิมพ์doubleค่าด้วยความแม่นยำเต็มที่ใช้ cout ได้อย่างไร

ใช้hexfloatหรือ
ใช้scientificและตั้งค่าความแม่นยำ

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

มีคำตอบมากเกินไปที่จะระบุเพียงหนึ่งใน 1) ฐาน 2) รูปแบบคงที่ / วิทยาศาสตร์หรือ 3) ความแม่นยำ คำตอบที่มากเกินไปอย่างแม่นยำไม่ได้ให้ค่าที่เหมาะสม ดังนั้นคำตอบนี้เป็นคำถามเก่า

1. ฐานอะไร

doubleมีการเข้ารหัสอย่างแน่นอนโดยใช้ฐาน 2. วิธีการโดยตรงกับ C ++ 11 std::hexfloatคือการพิมพ์โดยใช้
หากยอมรับเอาต์พุตที่ไม่ใช่ทศนิยมเราจะเสร็จสิ้น

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. มิฉะนั้น: fixedหรือscientific?

doubleเป็นจุดลอยชนิดไม่จุดคงที่

อย่าได้ใช้std::fixedเป็นที่ล้มเหลวในการพิมพ์ขนาดเล็กdoubleเป็นอะไร 0.000...000แต่ สำหรับขนาดใหญ่doubleมันพิมพ์ตัวเลขจำนวนมากบางทีหลายร้อยข้อมูลที่น่าสงสัย

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 

หากต้องการพิมพ์ด้วยความแม่นยำอย่างสมบูรณ์ให้ใช้งานครั้งแรกstd::scientificซึ่งจะ "เขียนค่าทศนิยมในเครื่องหมายทางวิทยาศาสตร์" สังเกตุค่าเริ่มต้นของตัวเลข 6 หลักหลังจากจุดทศนิยมซึ่งเป็นจำนวนที่ไม่เพียงพอจะถูกจัดการในจุดถัดไป

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. ความแม่นยำเท่าไหร่ (จำนวนหลักทั้งหมด)?

การdoubleเข้ารหัสโดยใช้ฐานฐาน 2 เข้ารหัสความแม่นยำเดียวกันระหว่างอำนาจต่าง ๆ ของ 2 ซึ่งมักเป็น 53 บิต

[1.0 ... 2.0) มี 2 ⁵³ที่แตกต่างกันdouble,
[2.0 ... 4.0) มี 2 ⁵³ที่แตกต่างกันdouble,
[4.0 ... 8.0) มี 2 ⁵³ที่แตกต่างกันdouble,
[8.0 ... 10.0) มี 2 / 8 * 2 ⁵³doubleที่แตกต่างกัน

แต่ถ้าพิมพ์รหัสในทศนิยมกับNเลขนัยสำคัญจำนวนรวมกัน [1.0 ... 10.0) เป็น 9/10 * 10 N

สิ่งที่เลือกN(ความแม่นยำ) จะไม่มีการแมปแบบหนึ่งต่อหนึ่งระหว่างdoubleข้อความทศนิยม หากเลือกค่าคงที่Nบางครั้งมันจะมากหรือน้อยกว่าที่จำเป็นจริงๆสำหรับdoubleค่าบางอย่าง เราอาจผิดพลาดน้อยเกินไป ( a)ด้านล่าง) หรือมากเกินไป ( b)ด้านล่าง)

3 ผู้สมัครN:

ก) ใช้Nดังนั้นเมื่อมีการแปลงจากแอปรับส่งข้อความdouble-text doubleเรามาถึงข้อความเดียวกันทั้งหมด

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

ข) ใช้Nดังนั้นเมื่อมีการแปลงจากdouble-text- doubleเรามาถึงในเวลาเดียวกันทั้งหมดdoubledouble

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

เมื่อmax_digits10ไม่สามารถใช้งานได้โปรดทราบว่าเนื่องจากแอตทริบิวต์ 2 ฐานและ 10 ฐานdigits10 + 2 <= max_digits10 <= digits10 + 3เราสามารถใช้digits10 + 3เพื่อพิมพ์ตัวเลขทศนิยมให้เพียงพอ

c) ใช้สิ่งNที่แตกต่างกันไปตามค่า

สิ่งนี้มีประโยชน์เมื่อโค้ดต้องการแสดงข้อความน้อยที่สุด ( N == 1) หรือค่าที่แน่นอนของ a double( N == 1000-ishในกรณีของdenorm_min) แต่เนื่องจากนี่คือ "งาน" และไม่น่าจะเป็นเป้าหมายของ OP ก็จะถูกตั้งสำรอง

โดยปกติจะเป็น b) ที่ใช้เพื่อ "พิมพ์doubleค่าด้วยความแม่นยำเต็มที่" แอปพลิเคชันบางอย่างอาจต้องการ a) ข้อผิดพลาดในการไม่ให้ข้อมูลมากเกินไป

ด้วย.scientific, .precision()ชุดจำนวนของตัวเลขที่จะพิมพ์หลังจุดทศนิยมดังนั้น1 + .precision()ตัวเลขจะพิมพ์ รหัสความต้องการmax_digits10หลักทั้งหมดดังนั้นจะเรียกว่ามี.precision()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

คำถาม C ที่คล้ายกัน

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

% .12f หมายถึงจุดลอยตัวที่มีความแม่นยำ 12 หลัก

ส่วนใหญ่พกพา ...

#include <limits>

using std::numeric_limits;

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

ด้วย ostream :: ความแม่นยำ (int)

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

จะให้ผลผลิต

3.141592653589793, 2.718281828459045

ทำไมคุณต้องพูดว่า "+1" ฉันไม่มีเงื่อนงำ แต่ตัวเลขพิเศษที่คุณได้รับนั้นถูกต้อง

สิ่งนี้จะแสดงค่าสูงสุดทศนิยมสองตำแหน่งหลังจุด

#include <iostream>
#include <iomanip>

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

ดูที่นี่: สัญกรณ์จุดคงที่

มาตรฐาน :: คงที่

ใช้สัญกรณ์จุดลอยตัวแบบคงที่ตั้งค่าสถานะรูปแบบ floatfield สำหรับ str สตรีมเป็นคงที่

เมื่อมีการตั้งค่า floatfield เป็นค่าคงที่ค่าจุดลอยตัวจะถูกเขียนโดยใช้เครื่องหมายจุดคงที่: ค่าจะถูกแสดงด้วยตัวเลขหลายหลักในส่วนทศนิยมตามที่ระบุโดยเขตความแม่นยำ (ความแม่นยำ) และไม่มีส่วนเลขชี้กำลัง

มาตรฐาน :: setprecision

ตั้งค่าความแม่นยำทศนิยมตั้งค่าความแม่นยำทศนิยมที่จะใช้ในการจัดรูปแบบค่าทศนิยมในการดำเนินงานการส่งออก

หากคุณคุ้นเคยกับมาตรฐาน IEEE สำหรับการแสดงคะแนนแบบลอยตัวคุณจะรู้ว่าเป็นไปไม่ได้ที่จะแสดงคะแนนแบบลอยที่มีความแม่นยำเต็มรูปแบบนอกขอบเขตของมาตรฐานนั่นคือการบอกว่ามันจะส่งผลเสมอ การปัดเศษของมูลค่าที่แท้จริง

คุณต้องตรวจสอบก่อนว่าค่านั้นอยู่ในขอบเขตหรือไม่ถ้าใช่ให้ใช้:

cout << defaultfloat << d ;

มาตรฐาน :: defaultfloat

ใช้สัญกรณ์จุดลอยตัวเริ่มต้นตั้งค่าสถานะการจัดรูปแบบ floatfield สำหรับ str สตรีมเป็น defaultfloat

เมื่อ floatfield ถูกตั้งค่าเป็น defaultfloat ค่าจุดลอยตัวจะถูกเขียนโดยใช้สัญกรณ์เริ่มต้น: การแทนค่าใช้ตัวเลขที่มีความหมายมากเท่าที่ต้องการจนถึงความแม่นยำทศนิยมของสตรีม (ความแม่นยำ) นับทั้งตัวเลขก่อนและหลังจุดทศนิยม )

นั่นเป็นพฤติกรรมเริ่มต้นของcoutซึ่งหมายความว่าคุณไม่ได้ใช้อย่างชัดเจน