Question

所以我的代码使用for和while循环以及递归方法打印出Pi的估计值。除了我的编译器说我的递归方法中的if语句存在堆栈溢出错误外，它一切正常。

public static final double REAL_PI = 3.14159;//PI is the value Mr.B gave us on the handout
public static double Pi = 0; //Pi is the value of Pi that this program calculates
public static int m = 0; 
public static int c = 0;


public static void main (String [] args)
{
    Algorithm(); //calls on method of calculating pi
    System.out.println("Calculated pi: " + Pi); //prints out pi
    countDigits(Pi); //calls on countdigits method
    System.out.println("Number of digits: " + c); //has the computer print out the count because that's how many digits are the same
    While();
    Recursive(1, 0.0); //calls on estimate digits method
}

public static double Algorithm() //should return a double (pi)
{
    for(m=1; m<=100000; m++)
    {
        Pi += 4*(Math.pow(-1, m-1)/((2*m)-1));//Math.pow uses math package to calculate a power to use the algorithm
    }
    return Pi;
}

public static int countDigits (double Pi)
{
    int a = (int) Pi; //the int cast makes Pi and REAL_PI into integers so the program can compare each digit separately 
    int b = (int) REAL_PI;
    int c = 0;
    int count = 0;
    while(a == b)//if m less then or equal to 100,000 then while loop runs
    {
        count ++;
        a = (int) (Pi*(Math.pow(10,count))); //if a=b then the computer will multiply Pi and REAL_PI by 10 
        b = (int) (REAL_PI*(Math.pow(10,count)));
        /*when you input a and b 
         * while loop compares them
         * if a = b then loop continues until a doesn't equal b and loop ends
         */
    }
    c = count; //gives c the value of the count so it can be used outside the method
    return count;
}
public static double While()
{
    int m = 1;
    Pi = 0.0;
    while (countDigits(Pi) < 6) 
    {
        Pi += 4*(Math.pow(-1, m-1)/((2*m)-1));
        m++;
    }
    Pi = (int)(Pi * 1000000);
    Pi = (double)(Pi/1000000);
    System.out.println("Pi using while loop: " + Pi);
    return Pi;
}

public static double Recursive(int m,double Pi)
{
    Pi += 4*(Math.pow(-1, m-1)/((2*m)-1));
    if (countDigits(Pi) < 6)
    {
        return Pi += Recursive(m+1,Pi);
    }
    Pi = (int)(Pi * 1000000);
    Pi = (double)(Pi/1000000);
    System.out.println("Pi using recursive: " + Pi);
    return Pi;
}

}

Answer 1

问题是用于计算π的莱布尼兹系列缓慢地收敛极其。使用你的程序，我发现经过3663次迭代（当我杀死程序时），值看起来像这样：

pi=3.141865802997432 
pi=3.1413195787723875 
pi=3.1418656538577117 
pi=3.1413197278306884

仍然只有3个小数位，即使精确到4也需要很长时间。堆栈不足以容纳如此多的递归调用，最终它会溢出。

堆栈溢出错误（Java）

1 个答案: