hi, I already know how to use setprecision but the function wont let the round go up past 16.

#include<iostream>
#include<stdio.h>
#include<math.h>
#include<iomanip>
using namespace std;
int main ()
{
    double pi = 3.14159265358979323846264338327950288419716939937510;
    cout << setprecision(50) << pi << endl;
    system("pause");
}

the output is just 3.1415926535897931 the code to force it to go past 16 would be something like this:

#include<iostream>
#include<stdio.h>
#include<math.h>
#include<iomanip>
using namespace std;
int main ()
{
    double pi = 3.14159265358979323846264338327950288419716939937510;
    cout << force_max_digits_setprecision(50) << pi << endl; //I just added "force_max_digits_"
    system("pause");
}

any solutions? Thanks.

Run the following code to see how many digits your double is actually holding.

#include <iostream>
#include <ostream>
#include <limits>

int main()
{
    typedef std::numeric_limits< double > dl;

    using namespace std;

    cout << "double:\n";
    cout << "\tdigits (bits):\t\t" << dl::digits << endl;
    cout << "\tdigits (decimal):\t" << dl::digits10 << endl;
    cin.get()
    return 0;
}

Edited 5 Years Ago by NathanOliver: n/a

how is that program supposed to help me? when i run the program, the output is just "double:
digits (bits): 53
digits (decimal): 15"

That means that you can only hold 15 digits after the decimal place. If you need more precision than that you will need to look into using a math library.

The definition of the IEEE double-precision format is eight bytes (MSB to LSB):

seee eeee   eeee emmm   mmmm mmmm   ...   mmmm mmmm

where s is a sign bit (1 is negative, 0 is positive), e is a 12-bit signed integer exponent (ranging from -2048 to 2047), and m is the remaining 51 bits, the fractional mantissa following an implicit "1.", so that the final value is

(1 - 2*s) * 1.m * (2^(e-2048))

Some values are necessarily reserved to indicate overflow, underflow, +/- infinity, and the always hilarious magical NaN constant (which has a tendency to flourish in unchecked linear algebra code :) ).

But the bottom line is, including the leading 1, you can store only 52 significant binary digits, and at ~10 bits to represent a trio of decimal digits, that comes to a little over 15 decimal digits that can be meaningfully represented in the decimal +- N.NNNNN * 10^e notation.

If you need more precision than a double provides, then you will need to use (or create, if you're bored) a higher-precision math library. I believe there are options for arbitrary precision (at the cost of storage and computation). Wikipedia provides a large list of options, maybe something will fit your needs (if other than idle curiosity).

Enjoy!

This article has been dead for over six months. Start a new discussion instead.