c语言中的莱布尼兹函数

我在寻找C中π的莱布尼兹近似值

我已经测试过这个函数，但它似乎不起作用：

float leibnizPi(float n){
    double pi=1.0;
    int i;
    int N;
    for (i=3, N=2*n+1; i<=N; i+=2)
        pi += ((i&2) ? -1.0 : 1.0) / i;
    return 4*pi;
}

float-leibnizPi（float n）{
双pi=1.0；
int i；
int N；
对于（i=3，N=2*N+1；i我已经测试了您的函数，它似乎工作正常。对于
N=1000
，我得到的结果是
3.142592

我是如何测试该功能的：

#include <stdio.h>

float leibnizPi(float n) {
    double pi=1.0;
    int i;
    int N;
    for (i=3, N=2*n+1; i<=N; i+=2)
        pi += ((i&2) ? -1.0 : 1.0) / i;
    return 4*pi;
}

int main(void)
{
    printf("Pi: %f\n", leibnizPi(1000));
    return 0;
}

#包括
浮动莱布尼兹皮（浮动n）{
双pi=1.0；
int i；
int N；
对于（i=3，N=2*N+1；i我已经测试了您的函数，它似乎工作正常。对于
N=1000
，我得到的结果是
3.142592

我是如何测试该功能的：

#include <stdio.h>

float leibnizPi(float n) {
    double pi=1.0;
    int i;
    int N;
    for (i=3, N=2*n+1; i<=N; i+=2)
        pi += ((i&2) ? -1.0 : 1.0) / i;
    return 4*pi;
}

int main(void)
{
    printf("Pi: %f\n", leibnizPi(1000));
    return 0;
}

#包括
浮动莱布尼兹皮（浮动n）{
双pi=1.0；
int i；
int N；
对于（i=3，N=2*N+1；iOP的代码有趣地使用
double
数学进行计算，然后在一个潜在的长循环后返回一个
float
。而不是截断为float。建议返回一个
double
。使用
float
，结果预计不会比223中的1部分更精确

下面显示了不必要的影响，在
n>约100000次之后变得明显，最终约600000次

float leibnizPif(float n){
    double pi=1.0;
    int i;
    int N;
    for (i=3, N=2*n+1; i<=N; i+=2)
        pi += ((i&2) ? -1.0 : 1.0) / i;
    return 4*pi;
}

double leibnizPid(float n){
    double pi=1.0;
    int i;
    int N;
    for (i=3, N=2*n+1; i<=N; i+=2)
        pi += ((i&2) ? -1.0 : 1.0) / i;
    return 4*pi;
}

int main() {

  double pi = acos(-1);
  float f1 = pi;
  float f2 = nextafterf(pi, 0);
  printf("%e\n", f1-f2);
  printf("                     pi  %.12e\n", pi);
  for (unsigned i=1; i<29; i++) {
    unsigned n = 1u << i;
    float f = leibnizPif(n);
    double d = leibnizPid(n);
    printf("%9u f % .5e %.12e   ", n, (f-pi)/pi, f);
    printf("d % .5e %.12e\n",  (d-pi)/pi, d);

  }
  printf("                     pi  %.12e\n", acos(-1));
  return 0;
}

修改代码输出

// with changes to use 64-bit integer math for the loops, 
// the result continue to get better returning double.
// It just takes longer and longer. 
1073741824 f  2.78275e-08 3.141592741013e+00   d  2.95864e-10 3.141592654519e+00
2147483648 f  2.78275e-08 3.141592741013e+00   d  1.47599e-10 3.141592654053e+00
4294967296 f  2.78275e-08 3.141592741013e+00   d  7.34476e-11 3.141592653821e+00
8589934592 f  2.78275e-08 3.141592741013e+00   d  3.63406e-11 3.141592653704e+00

OP的代码使用
double
数学进行计算，然后在一个潜在的长循环返回一个
float
。而不是截断为一个float。建议返回一个
double
。使用
float
，结果预计不会比223中的1部分更精确

下面显示了不必要的影响，在
n>约100000次之后变得明显，最终约600000次

float leibnizPif(float n){
    double pi=1.0;
    int i;
    int N;
    for (i=3, N=2*n+1; i<=N; i+=2)
        pi += ((i&2) ? -1.0 : 1.0) / i;
    return 4*pi;
}

double leibnizPid(float n){
    double pi=1.0;
    int i;
    int N;
    for (i=3, N=2*n+1; i<=N; i+=2)
        pi += ((i&2) ? -1.0 : 1.0) / i;
    return 4*pi;
}

int main() {

  double pi = acos(-1);
  float f1 = pi;
  float f2 = nextafterf(pi, 0);
  printf("%e\n", f1-f2);
  printf("                     pi  %.12e\n", pi);
  for (unsigned i=1; i<29; i++) {
    unsigned n = 1u << i;
    float f = leibnizPif(n);
    double d = leibnizPid(n);
    printf("%9u f % .5e %.12e   ", n, (f-pi)/pi, f);
    printf("d % .5e %.12e\n",  (d-pi)/pi, d);

  }
  printf("                     pi  %.12e\n", acos(-1));
  return 0;
}

修改代码输出

// with changes to use 64-bit integer math for the loops, 
// the result continue to get better returning double.
// It just takes longer and longer. 
1073741824 f  2.78275e-08 3.141592741013e+00   d  2.95864e-10 3.141592654519e+00
2147483648 f  2.78275e-08 3.141592741013e+00   d  1.47599e-10 3.141592654053e+00
4294967296 f  2.78275e-08 3.141592741013e+00   d  7.34476e-11 3.141592653821e+00
8589934592 f  2.78275e-08 3.141592741013e+00   d  3.63406e-11 3.141592653704e+00

我认为模运算的
&
应该是
%
你的输出是什么？显示a。@bhow
I
总是奇怪的，所以你的建议会产生一个常量。@是的，我的错误。看来我没有仔细阅读它。
I&2
部分是正确的。对于I=3，7，11，…，这将是正确的，但不是5，9，13…为什么
n
a
float
显然只是一个计数？否则它看起来很好。你为什么认为有错误？换句话说，你给它什么输入，你得到什么输出，你认为它们应该是什么？我认为
&
对于模运算应该是
%
，你的输出是什么？显示a.@bhow
i
总是很奇怪，所以你的建议会产生一个常数。@a是对的，我的错误。似乎我没有仔细阅读它。
i&2
部分是正确的。对于i=3,7,11……这是正确的，但不是5,9,13……为什么
n
a
float
显然只是一个计数呢？否则就错了看起来不错。你为什么认为有错误？换句话说，你给了它什么输入，你得到了什么输出，你认为它们应该是什么？我认为这是正确的。我用
n=1000000
试过了，它似乎收敛了，只需要很多术语。我认为这是正确的。我用
n=1000000
试过了，它似乎是收敛，这需要很多术语。