无法让BBP公式在nodejs中工作

Question

I've been trying to make a little program that can compute the n-th digit of pi.

After a few searches I've found that the most common formula is the BBP formula, wich is n-th digit = 16^-n[4/(8n + 1)-2/(8n + 4)-1/(8n + 5)-1/(8n + 6)].

The output is in base 16.

My code is the following:

function run(n) {
    return Math.pow(16, -n) * (4 / (8 * n + 1) - 2 / (8 * n + 4) - 1 / (8 * n + 5) - 1 / (8 * n + 6));
}

function convertFromBaseToBase(str, fromBase, toBase) {
    var num = parseInt(str, fromBase);
    return num.toString(toBase);
}


for (var i = 0; i < 10; i++) {
    var a = run(i);
    console.log(convertFromBaseToBase(a, 16, 10));
}

So far, my output is the following:

1:3
2:0
3:0
4:0
5:1
6:7
7:3
8:1
9:7
10:3

Obviously, these are not the 10 first digits of PI. My understanding is that values get rounded too often and that causes huge innacuracy in the final result.

However, I could be wrong, that's why I'm here to ask if I did anything wrong or if it's nodejs's fault. So I would loove if one of you guys have the answer to my problem!
Thanks!!

Answer 1

Unfortunately, 4/(8n + 1) - 2/(8n + 4) - 1/(8n + 5) - 1/(8n + 6) does not directly return the Nth hexadecimal digit of pi. I don't blame you, I made the same assumption at first. Although all the terms do indeed sum to pi, each individual term does not represent an individual hexadecimal digit. As seen here , the algorithm must be rewritten slightly in order to function correctly as a "digit spigot". Here is what your new run implementation ought to look like:

/**
   Bailey-Borwein-Plouffe digit-extraction algorithm for pi 
    <https://en.wikipedia.org/wiki/Bailey%E2%80%93Borwein%E2%80%93Plouffe_formula#BBP_digit-extraction_algorithm_for_.CF.80>
*/
function run(n) {
    var partial = function(d, c) {
        var sum = 0;

        // Left sum
        var k;
        for (k = 0; k <= d - 1; k++) {
            sum += (Math.pow(16, d - 1 - k) % (8 * k + c)) / (8 * k + c);
        }

        // Right sum. This converges fast...
        var prev = undefined;
        for(k = d; sum !== prev; k++) {
            prev = sum;
            sum += Math.pow(16, d - 1 - k) / (8 * k + c);
        }

        return sum;
    };

    /**
        JavaScript's modulus operator gives the wrong
        result for negative numbers. E.g. `-2.9 % 1`
        returns -0.9, the correct result is 0.1.
    */
    var mod1 = function(x) {
        return x < 0 ? 1 - (-x % 1) : x % 1;
    };

    var s = 0;
    s +=  4 * partial(n, 1);
    s += -2 * partial(n, 4);
    s += -1 * partial(n, 5);
    s += -1 * partial(n, 6);

    s = mod1(s);
    return Math.floor(s * 16);
}

// Pi in hex is 3.243f6a8885a308d313198a2e037073...
console.log(run(0) === 3); // 0th hexadecimal digit of pi is the leading 3
console.log(run(1) === 2);
console.log(run(2) === 4);
console.log(run(3) === 3);
console.log(run(4) === 15); // i.e. "F"

Additionally, your convertFromBaseToBase function is more complicated than it needs to be. You have written it to accept a string in a specific base, but it is already being passed a number (which has no specific base). All you should really need is:

for (var i = 0; i < 10; i++) {
    var a = run(i);
    console.log(a.toString(16));
}

Output:

3
2
4
3
f
6
a
8
8
8

I have tested this code for the first 30 hexadecimal digits of pi, but it might start to return inaccurate results once Math.pow(16, d - 1 - k) grows beyond Number.MAX_SAFE_INTEGER , or maybe earlier for other reasons. At that point you may need to implement the modular exponentiation technique suggested in the Wikipedia article.