莱布尼兹系列Java

我试着用莱布尼兹级数来近似π，我得到的问题是：

“您可以使用以下数列来近似π：

编写一个程序，显示i=10000，20000，…，到100000”的π值

现在这个问题本身是相当模糊的，而这正是我想要帮助的，到目前为止我已经做到了

public class Q2 {

public static void main(String[] args) 
{
    for  (int i = 1; i <= 10000; i++)
    {
       double pi = 4* (1 - (1/3) + (1/5) - (1/7) + (1/9) - (1/11) +
              (Math.pow((-1),(i+1)) ) / ((2*i)-1));

       if(i%10000==0)
        {
            System.out.println();
        }
    }
}

}

我是不是在错误地扩充我？我觉得我面前的问题有一个侧面，我错过了！ 谢谢

---

戴夫。

你误解了问题中的系列。它们的意思是，序列的第i个元素由以下公式给出：

((-1)^i+1)/(2i - 1)  [i starting with 1 in this notation]

因此，元素2之前的系列为：

4 * ( -1^(1+1) / (2*1-1)   +   -1^(2+1) / (2*2-1)   ) = 4*(1 - 1/3)

所以这个问题列出了这个系列的前6个元素，但是这个系列的长度是无限的。这意味着对于给定的i（目标）值，计算结果如下所示：

double sum = 0;
for (int i=1; i<TARGET; i++) {
   double element = Math.pow(-1,i+1) / (2*i + 1); //element i
   sum += element; // add element i to the results so far
}
double result = 4*sum;

double sum=0；
对于（int i=1；i你误解了问题中的级数。它们的意思是级数的第i个元素由以下公式给出：

((-1)^i+1)/(2i - 1)  [i starting with 1 in this notation]

因此，元素2之前的系列为：

4 * ( -1^(1+1) / (2*1-1)   +   -1^(2+1) / (2*2-1)   ) = 4*(1 - 1/3)

因此，问题列出了序列中的前6个元素，但序列的长度是无限的。这意味着对于给定的i（目标）值，计算如下所示：

double sum = 0;
for (int i=1; i<TARGET; i++) {
   double element = Math.pow(-1,i+1) / (2*i + 1); //element i
   sum += element; // add element i to the results so far
}
double result = 4*sum;

double sum=0；
对于（int i=1；i你误解了问题中的级数。它们的意思是级数的第i个元素由以下公式给出：

((-1)^i+1)/(2i - 1)  [i starting with 1 in this notation]

因此，元素2之前的系列为：

4 * ( -1^(1+1) / (2*1-1)   +   -1^(2+1) / (2*2-1)   ) = 4*(1 - 1/3)

因此，问题列出了序列中的前6个元素，但序列的长度是无限的。这意味着对于给定的i（目标）值，计算如下所示：

double sum = 0;
for (int i=1; i<TARGET; i++) {
   double element = Math.pow(-1,i+1) / (2*i + 1); //element i
   sum += element; // add element i to the results so far
}
double result = 4*sum;

double sum=0；
对于（int i=1；i你误解了问题中的级数。它们的意思是级数的第i个元素由以下公式给出：

((-1)^i+1)/(2i - 1)  [i starting with 1 in this notation]

因此，元素2之前的系列为：

4 * ( -1^(1+1) / (2*1-1)   +   -1^(2+1) / (2*2-1)   ) = 4*(1 - 1/3)

因此，问题列出了序列中的前6个元素，但序列的长度是无限的。这意味着对于给定的i（目标）值，计算如下所示：

double sum = 0;
for (int i=1; i<TARGET; i++) {
   double element = Math.pow(-1,i+1) / (2*i + 1); //element i
   sum += element; // add element i to the results so far
}
double result = 4*sum;

double sum=0；
对于（inti=1；i我不确定这个问题是否仍然相关，但答案可能是这样的

public class Calculate_PI 
{ 
   public static void main(String[] args)
  {
    double pi = 0;      

    for(int i = 10_000; i <= 100_000; i += 10_000)
    {
        double variablePart = 0;
        for(int j = 1; j <= i; j++)
        {
            variablePart += (Math.pow(-1, j+1) / ((2 * j) - 1));
        }
        pi = 4 * variablePart;
        System.out.printf("For i = %d\npi = %12.9f\n", i,pi);
    }
  }
}

公共类计算\u PI
{ 
公共静态void main（字符串[]args）
{
双pi=0；
对于（inti=10_000；我不确定这个问题是否仍然相关，但答案可能是这样的

public class Calculate_PI 
{ 
   public static void main(String[] args)
  {
    double pi = 0;      

    for(int i = 10_000; i <= 100_000; i += 10_000)
    {
        double variablePart = 0;
        for(int j = 1; j <= i; j++)
        {
            variablePart += (Math.pow(-1, j+1) / ((2 * j) - 1));
        }
        pi = 4 * variablePart;
        System.out.printf("For i = %d\npi = %12.9f\n", i,pi);
    }
  }
}

公共类计算\u PI
{ 
公共静态void main（字符串[]args）
{
双pi=0；
对于（inti=10_000；我不确定这个问题是否仍然相关，但答案可能是这样的

public class Calculate_PI 
{ 
   public static void main(String[] args)
  {
    double pi = 0;      

    for(int i = 10_000; i <= 100_000; i += 10_000)
    {
        double variablePart = 0;
        for(int j = 1; j <= i; j++)
        {
            variablePart += (Math.pow(-1, j+1) / ((2 * j) - 1));
        }
        pi = 4 * variablePart;
        System.out.printf("For i = %d\npi = %12.9f\n", i,pi);
    }
  }
}

公共类计算\u PI
{ 
公共静态void main（字符串[]args）
{
双pi=0；
对于（inti=10_000；我不确定这个问题是否仍然相关，但答案可能是这样的

public class Calculate_PI 
{ 
   public static void main(String[] args)
  {
    double pi = 0;      

    for(int i = 10_000; i <= 100_000; i += 10_000)
    {
        double variablePart = 0;
        for(int j = 1; j <= i; j++)
        {
            variablePart += (Math.pow(-1, j+1) / ((2 * j) - 1));
        }
        pi = 4 * variablePart;
        System.out.printf("For i = %d\npi = %12.9f\n", i,pi);
    }
  }
}

公共类计算\u PI
{ 
公共静态void main（字符串[]args）
{
双pi=0；
对于（int i=10_000；i），这个问题似乎每周都会被问一次。如果你想除掉两个数字，而不舍入为整数，那么其中一个必须是非整数类型。例如，1.0/3，而不是1/3。请看一下。也不必严格地进行数学运算。pow（）调用——这是一个方便的数学符号来捕捉交替符号，但如果需要，只检查i是偶数还是奇数，并翻转该项的符号，效率要高得多。这个问题似乎每周都会被问一次。如果你想除掉两个数字，而不舍入为整数，其中一个必须是非integer类型。例如，1.0/3，而不是1/3。请看一看。严格来说，也不需要进行数学运算。pow（）调用——这是一个方便的数学符号来捕捉交替符号，但如果需要，只检查i是偶数还是奇数，并翻转该项的符号，效率要高得多。这个问题似乎每周都会被问一次。如果你想除掉两个数字，而不舍入为整数，其中一个必须是非integer类型。例如，1.0/3，而不是1/3。请看一看。严格来说，也不需要进行数学运算。pow（）调用——这是一个方便的数学符号来捕捉交替符号，但如果需要，只检查i是偶数还是奇数，并翻转该项的符号，效率要高得多。这个问题似乎每周都会被问一次。如果你想除掉两个数字，而不舍入为整数，其中一个必须是非integer类型。例如，1.0/3，而不是1/3。请看一看。严格来说，也不需要进行数学运算。pow（）呼叫——这是一个方便的数学符号来捕捉交替符号，但如果需要的话，只检查我是偶数还是奇数，并翻转该术语的符号，效率要高得多。我也在想，非常感谢你的帮助。我没有资格投票支持你的答案，但一旦我投票，我一定会回来投票支持你我也在想，谢谢你的帮助。我没有资格投票支持你的答案，但一旦我投票了，我一定会回来投票支持你。我也在想，谢谢你的帮助。我没有资格投票支持你的答案，但一旦我投票了，我一定会回来投票支持你。我也在想，谢谢你的帮助非常感谢你的帮助。我没有资格投票支持你的答案，但一旦我投票了，我一定会回来投票支持你。