使用按位运算来优化Java Math

Question

In my Java class, I have to calculate the value of Pi accurate to 15 decimal places using the Bailey–Borwein–Plouffe formula. In the formula, I need to calculate the 16 to the power of n (integer from 1 to 50 000 000);

There is the formula I am working with

And here is my code to calculate that:

double value = 0.0;

//Calculates and increments value by using the BBP formula
for(int i = 0; i < iterations; i++) {
    if(i == 0) {
        value += (1 / 1) * (
                 (4.0 / ((8 * i) + 1)) - 
                 (2.0 / ((8 * i) + 4)) - 
                 (1.0 / ((8 * i) + 5)) - 
                 (1.0 / ((8 * i) + 6)) );
    } else {
        value += (1.0 / (2L<<(i<<2L))) * (
                 (4.0 / ((8 * i) + 1)) - 
                 (2.0 / ((8 * i) + 4)) - 
                 (1.0 / ((8 * i) + 5)) - 
                 (1.0 / ((8 * i) + 6)) );
    }
}

The problem is, I am using a bitwise operation (shift left <<) to optimize the code, as we are given bonus marks if we make the program as fast as possible. And for some reason, no matter what I try, the resulting number calculated from Pi is simply too large to work with. I am able to get the numbers 1 to 1.5324955e+54. After that, the numbers overflow and I get 1 or 0. I am trying to get 3.14159 etc but I get 3.1382357295632852 because of this data overflow.

Can anyone help me with this? Or is it simply not worth using bitwise operations to calculate power?

Answer 1

The smallest value that is expressable as a greater-than-zero double is 2 ^-2048 . That formula is going to hit zero as a double for every term above (2048/4), which is 512. Going up to 50,000,000 is 49,999,488 too far.

Answer 2

You only need 15 digits? Here you go:

class Class {
  private static final int ITERATION_COUNT = 15;


  public static void main(final String... args) {
    System.out.println(generatePi());
  }

  private static double generatePi() {
    double pi = 0;
    long sixteenPowK = 1;
    for (int k = 0; k < ITERATION_COUNT; k++) {
      pi += 1.0 / sixteenPowK * kthTerm(k);
      sixteenPowK *= 16;
    }
    return pi;
  }

  private static double kthTerm(final int k) {
    return 4.0 / (8.0 * k + 1) 
      - 2.0 / (8.0 * k + 4) 
      - 1.0 / (8.0 * k + 5) 
      - 1.0 / (8.0 * k + 6);
  }
}

I'd be curious to see a micro benchmark

Answer 3

DISCLAIMER: I'm far from being an expert in numerical methods.

In general, to solve any problem, I avoid preoptimizations. Once I find the solution, I start to optimize, only if it is somehow required.

In this case, I've inlined the 8 * i multiplication to a factor8 variable, I've removed the if inside the loop and have calculated the initial value for i = 0 , and most important, I have accumulated the value of (1 / 16) ^ i in a multiplication.

With these changes, I've managed to calculate the value of PI accurate to 15 decimal places in only 11 iterations. Here's the code:

public class Pi {

    public static void main(String[] args) {

        int iterations = 11;
        int start = 1;

        double value = 4.0 - 2.0 / 4.0 - 1.0 / 5.0 - 1.0 / 6.0;

        double oneSixteenth = 1.0 / 16.0;
        double oneSixteenthToN = oneSixteenth;

        for (int i = start; i < iterations; i++) {
            double factor8 = 8.0 * i;
            value += oneSixteenthToN * (
                    (4.0 / (factor8 + 1)) -
                            (2.0 / (factor8 + 4)) -
                            (1.0 / (factor8 + 5)) -
                            (1.0 / (factor8 + 6)));
            oneSixteenthToN *= oneSixteenth;
        }

        System.out.println("value = " + value); // our calculated value

        System.out.println("   pi = " + Math.PI); // exact value
    }
}

The output is:

value = 3.141592653589793
   pi = 3.141592653589793

I must admit that I'm unaware of the cause of the cumulative error in your code, but I'm almost sure that it has to do with the calculation of the (1 / 16) ^ i term.

Answer 4

I have solved my own question. It turns out I did not need bitwise operations at all. Since the program creates 50M iterations to calculate Pi, I can increment a predefined variable by using += and *= operations. Here is my final code, it computes Pi in 50M iterations in under 0.2 seconds.

//Computes Pi by using the BBP formula
public double computePi(int iterations) //<=50 000 000
{
    final double d = 1 / 16.0;
    double a = 16.0;
    double b = -8;

    double pi = 0.0;

    for(int k = 0; k < iterations; k++)
    {
        a *= d;
        b += 8;
        pi += a * (4.0 / (b + 1)
                - 2.0 / (b + 4)
                - 1.0 / (b + 5)
                - 1.0 / (b + 6));

    }

    return pi;
}

Thank you for all of your input, it has helped me a lot and made me rethink my approach to this problem.