Cout을 사용하여 완전 정밀도로 이중 값을 어떻게 인쇄합니까?

https://stackoverflow.com/questions/554063

23-08-2019
|

문제

그래서 나는 내 답변을 얻었습니다 마지막 질문 (내가 왜 그것을 생각하지 않았는지 모르겠다). 나는 인쇄하고 있었다 double 사용 cout 내가 그것을 기대하지 않았을 때 그것은 둥글게되었습니다. 어떻게 만들 수 있습니까? cout 인쇄 a 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;

기본적으로 한계 패키지에는 모든 유형의 빌드에 대한 특성이 있습니다.
부동 소수점 번호 (플로트/이중/긴 이중)의 특성 중 하나는 Digits10 속성입니다. 이것은베이스 10에서 부동 소수점 번호의 정확도 (정확한 용어를 잊어 버리기)를 정의합니다.

보다: http://www.cplusplus.com/reference/std/limits/numeric_limits.html
다른 속성에 대한 자세한 내용.

iostreams 방식은 일종의 어리석은 일입니다. 나는 사용하는 것을 선호한다 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 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은 소수점 전후에 숫자 수를 나타냅니다.

std :: 고정 된 Set_precision (max_digits10)을 사용하지 마십시오.
고정 표기법에서 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 Base 2 표현을 사용하여 저장되며 Base 2는 사소한 것을 나타낼 수 없습니다. 1.1 바로 그거죠. 얻는 유일한 방법 완전한 실제 이중의 정밀도 (라운드 오프 오류 없음)는 이진 비트 (또는 육각형 nybbles)를 인쇄하는 것입니다. 그렇게하는 한 가지 방법은 글을 쓰는 것입니다 double a union 그런 다음 비트의 정수 값을 인쇄합니다.

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

이것은 당신에게 이중의 100% 정확한 정밀도를 줄 것입니다 ... 인간은 IEEE 이중 형식을 읽을 수 없기 때문에 완전히 읽을 수 없습니다! 위키 백과 이진 비트를 해석하는 방법에 대한 글이 있습니다.

최신 C ++에서는 할 수 있습니다

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

어떻게 인쇄합니까? 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) 정밀도를 다룹니다. 너무 많은 답변 정도 필요한 적절한 가치를 제공하지 마십시오. 따라서 오래된 질문에 대한이 답변.

어떤 기지?

ㅏ 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

그렇지 않으면: fixed 또는 scientific?

ㅏ double a 부동 소수점 유형이 아닙니다 고정점.

하다 ~ 아니다 사용 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

얼마나 많은 정밀도 (총 숫자)?

ㅏ 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:

a) 사용 N 그래서 텍스트에서 변환 할 때double-텍스트 우리는 모두 같은 텍스트에 도착합니다 double.

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

b) 사용 N 그래서 변환 할 때 double-텍스트-double 우리는 똑같이 도착합니다 double 모든 double.

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

언제 max_digits10 사용할 수 없습니다. Base 2 및 Base 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() a로 호출됩니다 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

비슷한 C 질문

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

%.12f는 정밀도가 12 자리 인 플로팅 포인트를 의미합니다.

Cout은 인쇄 된 물건의 정밀도와 형식을 변경하기 위해 호출 할 수있는 많은 방법을 가진 객체입니다.

SetPrecision (...) 작업이 있지만 인쇄 너비 등과 같은 다른 것들을 설정할 수도 있습니다.

IDE의 참조에서 Cout을 찾으십시오.

가장 안심하게 ...

#include <limits>

using std::numeric_limits;

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

타조 :: 정밀 (int)

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

산출 할 것입니다

3.141592653589793, 2.718281828459045

왜 "+1"이라고 말해야하는 이유는 단서가 없지만, 당신이 그것을 벗어나는 여분의 숫자는 정확합니다.

라이센스 : CC-BY-SA ~와 함께 속성

제휴하지 않습니다 StackOverflow