1. c语言如何求定积分
4.龙贝格求积公式，求解定积分
C/C++ code
#include<stdio.h>
#include<math.h>
#define f(x) (sin(x)/x)
#define N 20
#define MAX 20
#define a 2
#define b 4
#define e 0.00001
float LBG(float p,float q,int n)
{ int i;
float sum=0,h=(q-p)/n;
for (i=1;i<n;i++)
sum+=f(p+i*h);
sum+=(f(p)+f(q))/2;
return(h*sum);
}
void main()
{ int i;
int n=N,m=0;
float T[MAX+1][2];
T[0][1]=LBG(a,b,n);
n*=2;
for(m=1;m<MAX;m++)
{ for(i=0;i<m;i++)
T[i][0]=T[i][1];
T[0][1]=LBG(a,b,n);
n*=2;
for(i=1;i<=m;i++)
T[i][1]=T[i-1][1]+(T[i-1][1]-T[i-1][0])/(pow(2,2*m)-1);
if((T[m-1][1]<T[m][1]+e)&&(T[m-1][1]>T[m][1]-e))
{ printf("Answer=%f\n",T[m][1]); getch();
return ;
}
}
}
6. 牛顿-科特斯求积公式，求定积分
C/C++ code
#include<stdio.h>
#include<math.h>
int NC(a,h,n,r,f)
float (*a)[];
float h;
int n,f;
float *r;
{ int nn,i;
float ds;
if(n>1000||n<2)
{ if (f)
printf("\n Faild! Check if 1<n<1000!\n",n);
return(-1);
}
if(n==2)
{ *r=0.5*((*a)[0]+(*a)[1])*(h);
return(0);
}
if (n-4==0)
{ *r=0;
*r=*r+0.375*(h)*((*a)[n-4]+3*(*a)[n-3]+3*(*a)[n-2]+(*a)[n-1]);
return(0);
}
if(n/2-(n-1)/2<=0)
nn=n;
else
nn=n-3;
ds=(*a)[0]-(*a)[nn-1];
for(i=2;i<=nn;i=i+2)
ds=ds+4*(*a)[i-1]+2*(*a)[i];
*r=ds*(h)/3;
if(n>nn)
*r=*r+0.375*(h)*((*a)[n-4]+3*(*a)[n-3]+3*(*a)[n-2]+(*a)[n-1]);
return(0);
}
main()
{
float h,r;
int n,ntf,f;
int i;
float a[16];
printf("Input the x[i](16):\n");
for(i=0;i<=15;i++)
scanf("%d",&a[i]);
h=0.2;
f=0;
ntf=NC(a,h,n,&r,f);
if(ntf==0)
printf("\nR=%f\n",r);
else
printf("\n Wrong!Return code=%d\n",ntf);
getch();
}
看看这个或许有帮助
2. c语言求定积分
#include
using
namespace
std;
#define
min
0
#define
max
1.0
inline
double
f(double
x)
{
return
x*x;
}
double
ladder(int
n)//用梯形法求积分
{
double
width=(max-min)/n;
double
sum=0;
for
(double
d=min;d
>n;
if
(cin.good()&&n>0)
break;
cout<<"输入错误，请重新输入：";
cin.clear();
cin.sync();
}
cout<<"梯形法积分为："<
评论
0
0
加载更多
3. 用C语言编写一个求定积分的程序
这是辛普森积分法。
给你写了fun_1( ），fun_2(），请自己添加另外几个被积函数。
调用方法 t=fsimp(a,b,eps,fun_i);
a,b --上下限，eps -- 迭代精度要求。
#include<stdio.h>
#include<stdlib.h>
#include <math.h>
double fun_1(double x)
{
return 1.0 + x ;
}
double fun_2(double x)
{
return 2.0 * x + 3.0 ;
}
double fsimp(double a,double b,double eps, double (*P)(double))
{
int n,k;
double h,t1,t2,s1,s2,ep,p,x;
n=1; h=b-a;
t1=h*(P(a)+P(b))/2.0;
s1=t1;
ep=eps+1.0;
while (ep>=eps)
{
p=0.0;
for (k=0;k<=n-1;k++)
{
x=a+(k+0.5)*h;
p=p+P(x);
}
t2=(t1+h*p)/2.0;
s2=(4.0*t2-t1)/3.0;
ep=fabs(s2-s1);
t1=t2; s1=s2; n=n+n; h=h/2.0;
}
return(s2);
}
void main()
{
double a,b,eps,t;
a=0.0; b=3.141592653589793238; eps=0.0000001;
// a definite integral by Simpson Method.
t=fsimp(a,b,eps,fun_1);
printf("%g\n",t);
t=fsimp(a,b,eps,fun_2);
printf("%g\n",t);
// ...
printf("\n Press any key to quit...");
getch();
}
4. C语言解决定积分
#include<stdio.h>
#include<math.h>
void main()
{
int i,n;
float x[10001],y[10001];
float x0,xn,h,JiFen;
printf("input x0,xn,n:");
scanf("%f,%f,%d",&x0,&xn,&n);
h=(xn-x0)/n;
x[0]=x0;
for(i=0;i<=n;i++)
{
x[i]=x[0]+i*h;
y[i]=pow(x[i],3);
}
JiFen=0.0;
for(i=0;i<n;i++)
{
JiFen=JiFen+y[i]+y[i+1];
}
JiFen=JiFen*h/2.0;
printf("\n");
printf("n=%d JiFen is %f",n,JiFen);
getch();
}
5. 用c语言编写求一个定积分
给一个辛普森求积分的例子。
1. 关于辛普森法（Simpson‘s Rule）[1]
辛普森法是数值方法求积分的一种方法，它与梯形法和矩形法不同，辛普森法用二次曲线去逼近实际的积分，如下图所示：
#include<stdio.h>
#include<math.h>
typedefdouble(*funcptr)(doublea);
doubleintegrate_simpson(funcptrf,floatlower,floatupper,intn)
{
inti;
floata,b;
floath;
doubleresult;
printf("%f%f%d
",lower,upper,n);
h=(upper-lower)/n;
printf("%f
",h);
result=0;
a=lower;
b=a+h;
for(i=0;i<n;i++)
{
doubletmp;
tmp=(b-a)/6*(f(a)+4*f((a+b)/2)+f(b));
printf("%f%f%f
",a,b,tmp);
result=result+tmp;
a=b;
b=a+h;
}
returnresult;
}
doublef(doublea)
{
returnexp(a);
}
voidmain(void)
{
doublere;
re=integrate_simpson(f,0,1,100);
printf("%f
",re);
}
3. 输出样式
moose@debian:~$ ./a.out
0.000000 1.000000 100
0.010000
0.000000 0.010000 0.010050
0.010000 0.020000 0.010151
0.020000 0.030000 0.010253
0.030000 0.040000 0.010356
0.040000 0.050000 0.010460
0.050000 0.060000 0.010565
0.060000 0.070000 0.010672
0.070000 0.080000 0.010779
0.080000 0.090000 0.010887
0.090000 0.100000 0.010997
0.100000 0.110000 0.011107
0.110000 0.120000 0.011219
0.120000 0.130000 0.011332
0.130000 0.140000 0.011445
0.140000 0.150000 0.011560
0.150000 0.160000 0.011677
0.160000 0.170000 0.011794
0.170000 0.180000 0.011913
0.180000 0.190000 0.012032
0.190000 0.200000 0.012153
0.200000 0.210000 0.012275
0.210000 0.220000 0.012399
0.220000 0.230000 0.012523
0.230000 0.240000 0.012649
0.240000 0.250000 0.012776
0.250000 0.260000 0.012905
0.260000 0.270000 0.013034
0.270000 0.280000 0.013165
0.280000 0.290000 0.013298
0.290000 0.300000 0.013431
0.300000 0.310000 0.013566
0.310000 0.320000 0.013703
0.320000 0.330000 0.013840
0.330000 0.340000 0.013979
0.340000 0.350000 0.014120
0.350000 0.360000 0.014262
0.360000 0.370000 0.014405
0.370000 0.380000 0.014550
0.380000 0.390000 0.014696
0.390000 0.400000 0.014844
0.400000 0.410000 0.014993
0.410000 0.420000 0.015144
0.420000 0.430000 0.015296
0.430000 0.440000 0.015450
0.440000 0.450000 0.015605
0.450000 0.460000 0.015762
0.460000 0.470000 0.015920
0.470000 0.480000 0.016080
0.480000 0.490000 0.016242
0.490000 0.500000 0.016405
0.500000 0.510000 0.016570
0.510000 0.520000 0.016736
0.520000 0.530000 0.016905
0.530000 0.540000 0.017075
0.540000 0.550000 0.017246
0.550000 0.560000 0.017419
0.560000 0.570000 0.017595
0.570000 0.580000 0.017771
0.580000 0.590000 0.017950
0.590000 0.600000 0.018130
0.600000 0.610000 0.018313
0.610000 0.620000 0.018497
0.620000 0.630000 0.018683
0.630000 0.640000 0.018870
0.640000 0.650000 0.019060
0.650000 0.660000 0.019251
0.660000 0.670000 0.019445
0.670000 0.680000 0.019640
0.680000 0.690000 0.019838
0.690000 0.700000 0.020037
0.700000 0.710000 0.020239
0.710000 0.720000 0.020442
0.720000 0.730000 0.020647
0.730000 0.740000 0.020855
0.740000 0.750000 0.021064
0.750000 0.760000 0.021276
0.760000 0.770000 0.021490
0.770000 0.780000 0.021706
0.780000 0.790000 0.021924
0.790000 0.800000 0.022144
0.800000 0.810000 0.022367
0.810000 0.820000 0.022592
0.820000 0.830000 0.022819
0.830000 0.839999 0.023048
0.839999 0.849999 0.023280
0.849999 0.859999 0.023514
0.859999 0.869999 0.023750
0.869999 0.879999 0.023989
0.879999 0.889999 0.024230
0.889999 0.899999 0.024473
0.899999 0.909999 0.024719
0.909999 0.919999 0.024968
0.919999 0.929999 0.025219
0.929999 0.939999 0.025472
0.939999 0.949999 0.025728
0.949999 0.959999 0.025987
0.959999 0.969999 0.026248
0.969999 0.979999 0.026512
0.979999 0.989999 0.026778
0.989999 0.999999 0.027047
1.718280
另：
matlab中用内置的int求积分的结果：
1.718281828459046
matlab中用前述simpson法求积分的结果：
1.718281828465257
4. 注意
本例中直接调用了标准math库里的exp()，实际上可以通过改写函数f()，将exp也做数值求解。
6. C语言求函数定积分
问题就是出在数据类型上的选用上，precision=0.0000001时已经超过了float的数据范围，所以导致数据截断后precision=0.000000，从而程序在计算积分时可能陷入死循环，应该采用double型数据类型。其实不推荐楼主用如此多的define语句，程序的可读性和风格应该重于编程员的劳动度。。。
还有楼主对自然对数e的define也已经超过了计算机的可识别范围。。您那样精确的定义e并不会在结果上获得更加精确地结果，其实反倒会起到相反的作用，要知道与其用一个这样可能导致内存出错以及必定会导致数据截断的变量来实现精度的提高远远不如采用一个更精确的积分算法，而且c语言提供了自然数e为底的指数函数~而且貌似您的积分算法是不准确的，梯形积分的定义并非如此，其再两端的函数值应该只取1/2.希望您多加细心~
如果不介意的话，就是你的precision应该改为step~这样会能更加准备的表达了这个变量的作用，在你的程序中precision变量其实是积分步长~在数值计算方法中积分精度的控制往往不是通过细化步长来表达，而是通过后一个积分值-前一个积分值<precision 这样来实现精度控制~呵呵
7. 用c语言求定积分
#include <stdio.h>
#include <math.h>
int main()
{
double a,b,n,k,i,x,y;
double EPS=1e-7;
a=0;//a为积分下限
b=1.57079632679459661;//b为积分上限
n=1e-7;//n控制精度
k=x=y=0;//k为辅助变量
i=0;//i为积分的值
while(k<=1/n)
{
k++;
x=k*n*b-k*n*a;
y=sin(x);//定义被积函数
i=i+b*y*n-a*y*n;
}
printf("%lf\n",i);
getchar();
}
8. 用C语言求定积分
实际问题描述：
求定积分近似值
程序代码如下：
#include
#include
void main()
{
int i,n=1000;
float a,b,h,t1,t2,s1,s2,x;
printf("请输入积分限a,b:");
scanf("%f,%f",&a,&b);
h=(b-a)/n;
for(s1=0,s2=0,i=1;i<=n;i++)
{
x=a+(i-1)*h;
t1=(float)exp(-x*x/2);t2(float)=exp(-(x+h)*(x+h)/2);
s1=s1+t1*h; /*矩形面积累加*/
s2=s2+(t1+t2)*h/2; /*梯形面积累加*/
}
printf("矩形法算得积分值：%f.
",s1);
printf("梯形法算得积分值：%f.
",s2);
}
程序运行结果如下：
矩形法算得积分值：0.855821
梯形法算得积分值：0.855624
由上面的比较可知，梯形法的精度要高于矩形法。
9. 用C语言求积分
好象要你自己定义函数，库函数中好象是没有直接可以用的积分函数的。
10. c语言求解定积分
这是第一种方法，第二种方法我没学过，不知道原理就无能为力啦~~
#include<stdio.h>
#include<math.h>
double f(double x)
{
return 1/(1+x*x*x);
}
double y(double a,double b,int m)
{
int i;
double h=(b-a)/m,c=0.0;
for(i=1;i<m;i++)
c=c+f(a+i*h);
return ((f(a)+f(b))/2+c)*h;
}
int main()
{
printf("%f" ,y(0,1,500));
return 0;
}