c - C 中负奇实数的黎曼 Zeta 函数

Question

我正在尝试用 C 语言编写 Riemann Zeta 函数，但我对负赔率有很大的问题。因为根据定义，偶数负数都是 0。只针对实数的函数，不复杂。所以 0..1 是未定义。我知道我犯了一些数学错误，但我今天开始阅读有关此函数的内容，并且我正在尝试学习。

https://en.wikipedia.org/wiki/Riemann_zeta_function

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

double zeta(double s, long long int n)
{
    double p=0.0;
    if(s<0 && fmod(s,2)==0)
    {
        return p;
    }
    if(s==0) { return -0.5;}
    if(s>0 && s<=1)
    {
        puts("Undefined. ");
        exit(-1);
    }
    long long int i;
    for(i=n; i>0; i--)
    {

        p+=pow(i,-s);
    }
    return p;
}

int main()
{
    double s;
    puts("Enter real number to Zeta function: ");
    scanf("%lf",&s);
    printf("\n%.15lf",zeta(s,1000000));
    return 0;

}

这只是一个草图......这里没有什么专业的!

示例:zeta(-5) = -0.003968253968253它给出 1.036927755143338...

我只对负真实问题有疑问...我使用的是 Windows 10，使用 GCC 的 Codeblocks。

代码已使用@NPE 贡献进行了更新，但仍然无法处理负的实际赔率...

Answer 1

我没有参与评论，抱歉。

按照 zeta 函数的定义，简单的编码方式是(我只是将代码中的 s 更改为 -s，并添加了“收敛级别 n”作为参数)

double zeta_simple(double s, long long int n)
{
    double p=0.0;
    long long int i;
    for(i=1; i<=n; i++)
    {

        p+=pow(i,-s);
    }
    return p;
}

但是问题是，您开始在“小”数字之前添加“大”数字，很快您就会遇到下溢操作。所以你想做的是

double zeta(double s, long long int n)
{
    double p=0.0;
    long long int i;
    for(i=n; i>0; i--)
    {

        p+=pow(i,-s);
    }
    return p;
}

您可以使用 s=2 来测试收敛性，它会收敛到 PI^2/6.0，而 s=4 会收敛到 PI^4/90.0

#define PI 3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679L
int main()
{
      long long int n;
      for (long long int n=10; n<=100000000; n*=10)
      {
        printf("%28.16f\t %28.16f\n", zeta(4.0, n), zeta2(4.0, n));
      }
      printf("%s=%20.16f\n\n","PI^4/90", PI*PI*PI*PI/90.0);

      for (long long int n=10; n<=10000000000; n*=10)
      {
        printf("%28.16f\t %28.16f\n", zeta(2.0, n), zeta2(2.0, n));
      }
      printf("%s=%20.16f\n","PI^2/6 ", PI*PI/6.0);
}

你得到了

          1.0820365834937564               1.0820365834937566
          1.0823229053444732               1.0823229053444725
          1.0823232333783044               1.0823232333783073
          1.0823232337108049               1.0823232337108359
          1.0823232337111379               1.0823232337109849
          1.0823232337111381               1.0823232337109849
          1.0823232337111381               1.0823232337109849
          1.0823232337111381               1.0823232337109849
PI^4/90=  1.0823232337111379

          1.5497677311665408               1.5497677311665408
          1.6349839001848929               1.6349839001848925
          1.6439345666815597               1.6439345666815606
          1.6448340718480596               1.6448340718480665
          1.6449240668982261               1.6449240668982523
          1.6449330668487265               1.6449330668487985
          1.6449339668482315               1.6449339668477756
          1.6449340568482265               1.6449340573291047
          1.6449340658482263               1.6449340600880324
          1.6449340667482264               1.6449340600880324
PI^2/6 =  1.6449340668482264

看看 zeta_simple 的收敛如何在一段时间后停止...为了继续收敛，您必须使用 zeta

您还可以看到，对于 10000000000 次操作(因此使用 long long int)，您只能获得 s=2 的 9 位精度。随着 s 的增加，收敛速度也会增加。

因此，为了使小 s 变得高效，人们使用加速收敛公式。

如果您想进一步挖掘，我建议您查看 https://math.stackexchange.com/questions/183680/modern-formula-for-calculating-riemann-zeta-function

另外，当你开始探索 s 复杂性时，真正有趣的是