How to make a float in c++ without a decimal place limit

Question

I have a c++ program which calculates Pi but then its value gets cut off after a few decimal places because of the decimal place limit on the float which Pi is stored in.

I've already tried using different data types instead of float but they still have a decimal place limit which is too small.

#include <iostream>
#include <fstream>
#include <sstream>
using namespace std;

int main(){
    cout << "Calculate Pi using the Nilakantha series" << endl << endl;

    unsigned long int iterations = 0;
    unsigned long int x = 0;
    unsigned long int y = 2;
    char z = 0;
    string fileName = "";
    int64_t Pi = {3.0f};

    cout << "Input the number of loop iterations(maximum of 4,294,967,295): ";
    cin >> iterations;
    cout << "Input the name of the file you want to write to: ";
    cin >> fileName;

    for(x = 0; x < iterations; x++){
        Pi += 4.0f / (y * (y + 1.0f) * (y + 2.0f));
        y += 2;
        Pi -= 4.0f / (y * (y + 1.0f) * (y + 2.0f));
    y += 2;
    }

    ofstream file;
    file.open(fileName + ".txt");
    file << Pi;
    file.close();

    cout << endl << "Calculation complete, check the file " << fileName << ".txt";

    cin >> z;
}

How do I remove the limit or use a method which stores the value of Pi without it getting cut off after a few decimal places?

I tried that but I want to store a lot (probably over 1000) digits of Pi and that didn't seem to work. — Daemon Beast, May 12 '19 at 20:36
Possible duplicate of https://stackoverflow.com/questions/5907031/printing-the-correct-number-of-decimal-points-with-cout — JVApen, May 12 '19 at 20:40
Why are you declaring Pi as an int64_t? And why are you using floats in the middle of the calculation? If you use floats in the middle of the calculation that'll make it more inaccurate — Alecto Irene Perez, May 12 '19 at 20:41
Also, by default std::cout only prints 6 digits. You need to tell it to print more. — Alecto Irene Perez, May 12 '19 at 20:41
@LucaNeri You should add the desired number of digits to the question, as that affects which solutions are appropriate. (Note that completely removing the limit is out of the question, as no computer has an infinite amount of storage.) — JaMiT, May 12 '19 at 20:54
Note that the stream insertion operator (`<<`) by default rounds to around 5 digits after the decimal place. You can get some more precision (up to ~15 decimal digits for 64-bit floating point) using [`std::setprecision`](https://en.cppreference.com/w/cpp/io/manip/setprecision) to increase the number of digits outputted, but you'll need an arbitrary precision library such as [GMP](https://gmplib.org/) for more digits than that. — eesiraed, May 12 '19 at 22:00

score 3 · Accepted Answer · answered May 12 '19 at 21:01

There are a few big issues here. The first is that you're using std::cout to print the value, and std::cout only prints 6 digits by default. The second is that you declared Pi as an int64_t. That means you'll get at most 1 digit of precision, since Pi is an integer. You need to have it as a floating point type.

So how many digits will you get from each type?

6 digits from float
15-16 digits from double
20 digits from long double on clang and gcc, but only 15-16 in Visual Studio
Around 30 digits from GCC's __float128, although that one only works on GCC

If you want more precision than that, you're going to have to use a high-precision arithmetic library that gives you more digits by simulating it. It won't be as fast, but it'll do the job.

You can play around with the amount of precision with each type using this code. I templated calculatePi on the type, so you can just stick in float, double, long double, or __float128. It'll print 20 digits. This code should print all 20 digits correctly for __float128.

#include <cstdio>
using namespace std;

template<class Float>
Float calculatePi(size_t iterations) {
    Float y = 2;
    Float Pi = 3;
    const Float two = 2;
    const Float four = 4;
    const Float one = 1;

    for(size_t i = 0; i < iterations; i++) {
        Pi += four / (y * (y + one) * (y + two));
        y += two;
        Pi -= four / (y * (y + one) * (y + two));
        y += two;
    }
    return Pi; 
}
int main(){
    long double result = calculatePi<long double>(1000000); 

    printf("Expected: 3.14159265358979323846\n"); 
    printf("Actual:   %.20Lf", result); 
}

einpoklum · Answer 2 · 2019-05-12T21:46:37.817

_{(I'm ignoring some of the less fundamental issues which @JAntonioPerez points out in his fine answer and focusing on what I find to be the core of this question.)}

If you just need a few more decimal digits of precision, then use double or long double instead of float.

If you want much higher precision, or a precision which can be specified as a run-time or compile-time arbitrary value, then you need something else. Either:

Use an arbitrary-precision number data type; here is a list of libraries providing such types.
Instead of iterating over the entire number, use iteration to determine the value of individual digits/characters in the output; and write the digits you obtain to the output file one at a time (or a few at a time).

Of course, both options are rather involved and are probably not appropriate for a "toy program" like you seem to be writing.

as for option 2: https://cs.uwaterloo.ca/~alopez-o/math-faq/mathtext/node12.html `int a=10000,b,c=2800,d,e,f[2801],g;main(){for(;b-c;)f[b++]=a/5; for(;d=0,g=c*2;c-=14,printf("%.4d",e+d/a),e=d%a)for(b=c;d+=f[b]*a, f[b]=d%--g,d/=g--,--b;d*=b);}` — Moshe Gottlieb, May 12 '19 at 20:53
@MosheGottlieb: I would call this "rather involved" actually. :-( — einpoklum, May 12 '19 at 21:44

How to make a float in c++ without a decimal place limit

2 Answers2