Martyr2项目实现——Number部分的问题求解 (1) Find Pi to Nth Digit

Find Pi to Nth Digit

问题描述：

Find PI to the Nth Digit – Enter a number and have the program generate PI up to that many decimal places. Keep a limit to how far the program will go.

翻译：

给定一个整数N，让程序生成精确到小数点后N为的圆周率$\pi$

要保证程序运行的时间在一定限度下

计算原理:

常用的圆周率的数值计算方法有级数法，迭代法，随机算法

级数法：使用圆周率$\pi$的级数表示来计算

高斯提出的用于平方倒数和公式

\[\frac{\pi^2}{6}=\frac{1}{1^2}+\frac{1}{2^2}+\frac{1}{3^2}...+\frac{1}{(n-1)^2}+\frac{1}{n^2}+...
\]
莱布尼兹公式

\[\frac{\pi}{4}=\frac{1}{1}-\frac{1}{3}+\frac{1}{5}-\frac{1}{7}+...+(-1)^{n-1}\frac{1}{2n-1}+...
\]

不过莱布尼兹公式的收敛速度很慢
拉马努金提出的公式

\[\frac{1}{\pi}=\frac{2\sqrt{2}}{9801}\sum_{k=0}^{+\infty}\frac{(4k)!(1103+26390k)}{k!^4(396^{4k})}
\]

使用级数法计算圆周率的收敛速度还是太慢

迭代算法：适合计算机程序实现的计算圆周率的方法

迭代算法的收敛速度要比无穷级数快很多

比较出名的算法是高斯-勒让德算法

高斯-勒让德算法：

引入四个数列 $\{a_n\},\{b_n\},\{t_n\},\{p_n\}$

他们的初值为：

\[a_0=1\qquad b_0=\frac{1}{\sqrt{2}}\qquad t_0=\frac{1}{4}\qquad p_0=1
\]

递推公式为：

\[a_{n+1}=\frac{a_n+b_n}{2}\;,b_{n+1}=\sqrt{a_nb_n}\;,t_{n+1}=t_n-p_n(a_n-a_{n+1})^2\;,p_{n+1}=2p_n.
\]

计算圆周率$\pi$近似值的方法：

\[\pi \approx\frac{(a_{n+1}+b_{n+1})^2}{4t_{n+1}}
\]

该算法每执行一次迭代，计算出的圆周率的正确位数就会增加一倍多。

具体的实现：

我们准备将圆周率计算到小数点后1000位（N<=1000)

开方运算

考虑到java的浮点数最高只支持64位double双精度浮点数，为了能够计算的更精确，考虑使用java的大数类·java.Math.BigDecimal来进行计算。

注意到在使用高斯勒让德算法计算圆周率时，需要用到开平方运算，BigDecimal并没有实现对大数对象的开方运算，我们需要自己实现。这里使用牛顿迭代法来计算大数的开平方。

具体的计算方法参考博客：java BigDecimal开平方

大数除法的精度问题

在进行大数运算时，对于大数除法BigDeciaml.divide()，需要设定响应的计算精度和舍入方法(如何截断数值)

这里我们需要使用到java.Math.MathContext类，这个类描述了数字运算符的某些规则

我们可以使用默认的规则（比如MathContext.DECIMAL128)

也可以指定精度和舍入模式，定义自己的MathContext对象，构造方法为

MathContext(int setPrecision, RoundingMode setRoundingMode)

具体用法参考博客：java_math_MathContext

为了能够实现我们的计算要求（1000位的圆周率），我们设定大数除法的计算精度为1002位（有效数字，自定义舍入方法）

MathContext mc = new MathContext(1002, RoundingMode.HALF_EVEN);

对于开平方运算，我们设置它的计算精度为500位（精确到小数点后100位）

下表是我们计算的每次迭代可以到达的计算精度

对于给定的参数N（要求计算小数位数）,我们通过查表来确定迭代次数，然后对得到的数值进行截断。

迭代次数	精度（小数点后精确到的位数）
0	0
1	2
2	7
3	18
4	40
5	83
6	170
7	344
8	693
9	1000

程序实现：

主程序

import java.math.BigDecimal;

import java.math.MathContext;

public class CalculatePi {

    private static int[] map_array = {0,2,7,18,40,83,170,344,693,1000};

    public static String getPiValue(int N){ //获取精确到小数点后N位的圆周率近似值

        if(N<0||N>1000) return "error:给定参数超出范围！(默认参数范围为[1,1000])";

        int index = 0;

        for(int i=map_array.length-1;i>=1;i--){

            if(N>map_array[i]) {

                index = i+1;

                break; //给定的参数N位于map_array[i,i+1]之间

            }

        }

        String value = calculate(N,index);

        return value;

    }

    private static String calculate(int N,int index) {

        //利用高斯-勒让德迭代算法来计算圆周率的近似值，index为迭代的次数

        if (index == 0) return "3";

        //设置初值

        BigDecimal a0 = new BigDecimal(1);

        BigDecimal a1 = new BigDecimal(1);

        BigDecimal b = CalculateSqrt.sqrt(new BigDecimal("0.5"));

        BigDecimal t = new BigDecimal("0.25");

        BigDecimal p = new BigDecimal(1);

        BigDecimal pi = new BigDecimal(3);

        MathContext mc = CalculateSqrt.mc;

        //进行迭代

        for (int i = 0; i < index; i++) {

            a1 = a0.add(b);

            a1 = a1.divide(new BigDecimal(2), mc);

            b = b.multiply(a0);

            b = CalculateSqrt.sqrt(b);

            BigDecimal temp = new BigDecimal(1);

            temp = a0.subtract(a1);

            temp = temp.multiply(temp);

            temp = temp.multiply(p);

            t = t.subtract(temp);

            p = p.multiply(new BigDecimal(2));

            temp = a1.add(b);

            temp = temp.multiply(temp);

            temp = temp.divide(new BigDecimal(4), mc);

            pi = temp.divide(t, mc);

            a0 = a1;

        }

        return pi.toString().substring(0, N + 2);

    }

    public static void main(String[] args) {

        int N = 10;

        String pi = getPiValue(1001);

        System.out.println(pi);

    }

}

计算平方根程序：

import java.math.BigDecimal;

import java.math.MathContext;

import java.math.RoundingMode;

public class CalculateSqrt {

    private static int N = 1002;

    public static MathContext mc = new MathContext(N, RoundingMode.HALF_EVEN);

    private static String eps = "0."+repeatString("0",N/2)+"1";

    public static void main(String[] args) {

        BigDecimal n = new BigDecimal("2");

        BigDecimal r = sqrt(n);

        System.out.println(r.toString());

    }

    public static BigDecimal sqrt(BigDecimal num) {

        if(num.compareTo(BigDecimal.ZERO) < 0) {

            return BigDecimal.ZERO;

        }

        BigDecimal x = num.divide(new BigDecimal("2"), mc);

        while(x.subtract(x = sqrtIteration(x, num)).abs().compareTo(new BigDecimal(eps)) > 0);

        return x;

    }

    private static BigDecimal sqrtIteration(BigDecimal x, BigDecimal n) {

        return x.add(n.divide(x, mc)).divide(new BigDecimal("2"), mc);

    }

    private static String repeatString(String str,int n){

        StringBuffer sb = new StringBuffer();

        for(int i=0;i<n;i++){

            sb.append(str);

        }

        return sb.substring(0,sb.length());

    }

}