龙贝格算法

龙贝格算法是以复化梯形公式，复化希普森，复化牛顿-科特斯为基础采用的是逐渐平衡误差的做法，如下：

代码

#include<stdio.h>     //龙贝格
#include<math.h>
#define maxlen 100
double a;
double b;

double f(double x)
{
    if(x==0)
    {
        return 1;
    }
    else
    {
        return (sin(x)/x);
    }
}
double t(int n)
{
    if(n<1)
    {
        return  -1;
    }
    else
    {

        if(n==1)
        {
            return (b-a)/2*(f(a)+f(b));
        }
        else 
        {
            double h;
            h=(b-a)/(n/2);
            double s=0;
            double m=a+h/2;
            while(m<b)
            {
                s=s+f(m);
                m=m+h;
            }
            while(m<b);
            return (t(n/2)/2+s*h/2);
        }
    }
}
double s(int n)
{
    if(n<1)
    {
        return -1;
    }
    else
    {
        return (4/3*t(2*n)-1/3*t(n));
    }
}
double c(int n)
{
    if(n<1)
    {
        return -1;
    }
    else
    {
        return (16/15*s(2*n)-1/15*s(n));
    }
}
double r(int n)
{
    if(n<1)
    {
        return -1;
    }
    else
    {
        return (64/63*c(2*n)-1/63*c(n));
    }
}
int main()
{
    printf("左区间：");scanf("%lf",&a);
    printf("右区间：");scanf("%lf",&b);
    printf("k\tt(2^k)\ts(2^(k-1)\tc(2^(k-2))\tr(2^(k-3))");
    for(int k=0;k<=4;k++)
    {
        int z=pow(2,k);
        double x=z/2;
        double v=x/2;
        double b=v/2;
        printf("%lf\t%lf\t%lf\t%lf\t%lf\n",k,t(z),s(x),c(v),r(b));
    }
    return 0;
}

这个龙贝格采用的是迭代公式，一步一步接近精确值，代码没有优化，所以看起来有点啰嗦，愿谅解哈