使用循环通过级数展开来估计 PI

Question

我需要通过以下系列来估算 PI：

m(i) = 4( 1- 1/3 + 1/5 - 1/7 + 1/9 - 1/11 ...)

这就是我到目前为止所做的：

 float mOfI = 1;
    System.out.println("i \t \t \t \t  m(i)" );
    for (int i = 1; i < n; i++) {
        float sum = i + 2;
        mOfI += 4 * (1 - (1 / sum));
        mOfI -= 4 * (1 - (1 / sum));
        System.out.println(i + "\t \t \t \t" +mOfI);
    }

我知道我在这里遗漏了许多规则，但我怎样才能使它正常工作？我的意思是数学逻辑。怎样才能正确解决？

请注意系列中的-+，所有数字都是奇数，所以我不能使用i%2。

估计的 PI 会像 4.0000 , 3.1515, 3.1466 ..... 等等。

这个question 也没有得到很好的回答（没有估计实际的 PI 值）

Answer 1

让它变得简单，找到简单的模式。这是一个提示

1. 先忽略与4的乘法（或者你可以考虑 每个学期）
2. 考虑初始 denom = 1，因此 term = 1/denom = 1
3. 找到模式。请注意，在每一步 newTerm = (-1)*(1/(denom+2))。所以在每次迭代中，更新总和和 denom 相应地。
4. n 次迭代后，只需将 sum 与 4 相乘

Answer 2

mOfI 永远不会改变，因为这两行相互抵消

    mOfI += 4 * (1 - (1 / sum));
    mOfI -= 4 * (1 - (1 / sum));

试试这个。

double mOfI = 4.0;
System.out.println("i \t \t \t \t  m(i)" );
for (int i = 1, d = 3, s = -1;
         i < n; 
         i++, d += 2, s = -s) {
    mOfI += 4.0 / (s * d);
    System.out.println(i + "\t \t \t \t" +mOfI);
}

Answer 3

float m = 4;
    for (int i = 1; i < n; i++) {
        if(i%2==0){
           m +=4/(2*i+1);
        } else {
           m -=4/(2*i+1);
        }
        System.out.println(i + "\t \t \t \t" +m);
    }

注意：我使用的是移动应用程序，可能存在语法错误，但您应该明白。

Answer 4

感谢大家的宝贵时间，但我找到了正确的解决方案：

  double start = 1;         // Start series
    double end   = 901;     // End series
    System.out.println("\ni           m(i)     ");
    System.out.println("---------------------");
    for (double i = start; i <= end; i += 100) {
        System.out.printf("%-12.0f", i);
        System.out.printf("%-6.4f\n", estimatePI(i));
    }
}

/** Method estimatePI */
public static double estimatePI(double n) {
    double pi = 0;      // Set pi to 0
    for (double i = 1; i <= n; i ++) {
        pi += Math.pow(-1, i +1) / (2 * i - 1);
    }
    pi *= 4;
    return pi;
}

Answer 5

您的代码中存在多个问题。

1. 首先，您应该只将一个和除以i，将另一个除以i + 2，而不是同时除以i + 2。
2. 你将1添加到每个summand，这是错误的，它应该像1 / sum而不是1 - (1 / sum)
3. 接下来i 需要在每个步骤中进一步推进，i+2 甚至 i+4 如果您决定在一个迭代步骤中创建两个加法运算
4. 如果n 变大，您可能会很快达到int 和double 精度的极限，您可能需要BigInteger 和BigDecimal，它们在空间成本上提供无限精度 .

您目前正在制作的系列看起来像：

4 * ((1 - 1 / 1) - (1 - 1 / 1) + (1 - 1 / 2) - (1 - 1 / 2) +- ...)

应该是0，因为每个部分相互消除。

---

正确的版本如下所示：

double result = 0;

// Whether we add or subtract the summand
boolean doAdd = true;
// Start at i = 0 to produce 1 as first denominator,
// else use - instead of + in the code
for (int i = 0; i < n; i++) {
    // Advance in steps of 2 and use odd values
    // Denominator will be 1, 3, 5, 7, ... for i = 0, 1, 2, 3, ...
    double summand = 1 / (2 * i + 1);

    if (doAdd) {
        // Add it
        result += summand;
    } else {
        // Subtract it
        result -= summand;
    }
    // Toggle the flag
    doAdd = !doAdd;
}

// Multiply by 4
result *= 4;

当然，如前所述，您可能需要替换为BigDecimal。

如果您不想使用额外的标志，也可以使用if (i % 2 == 0) 代替if (doAdd)。但这样可能更容易理解。

Answer 6

这只是函数式编程中的 Java 9 练习；你可以用这条线计算 PI：

double pi = 4 * Stream.iterate(1.0, i -> i < 10000000, i -> i + 2)
            .reduce(0.0, (a, d) -> ((d - 1) / 2) % 2 == 0 ? (a + 1 / d) : (a - 1 / d));

Java 8 和 Java 9 示例：

// Java 9
double pi = 4 * Stream.iterate(1.0, i -> i < 10000000, i -> i + 2)
        .reduce(0.0, (a, d) -> ((d - 1) / 2) % 2 == 0 ? (a + 1 / d) : (a - 1 / d));
System.out.println(pi);
// Java 8
pi = 4 * Stream.iterate(1.0, i -> i + 2).limit(10000000)
        .reduce(0.0, (a, d) -> ((d - 1) / 2) % 2 == 0 ? (a + 1 / d) : (a - 1 / d));
System.out.println(pi);