Ⅰ c语言求定积分
问题就是出在数据类型上的选用上，precision=0.0000001时已经超过了float的数据范围，所以导致数据截断后precision=0.000000，从而程序在计算积分时可能陷入死循环，应该采用double型数据类型。其实不推荐楼主用如此多的define语句，程序的可读性和风格应该重于编程员的劳动度。。。
还有楼主对自然对数e的define也已经超过了计算机的可识别范围。。您那样精确的定义e并不会在结果上获得更加精确地结果，其实反倒会起到相反的作用，要知道与其用一个这样可能导致内存出错以及必定会导致数据截断的变量来实现精度的提高远远不如采用一个更精确的积分算法，而且c语言提供了自然数e为底的指数函数~而且貌似您的积分算法是不准确的，梯形积分的定义并非如此，其再两端的函数值应该只取1/2.希望您多加细心~
如果不介意的话，就是你的precision应该改为step~这样会能更加准备的表达了这个变量的作用，在你的程序中precision变量其实是积分步长~在数值计算方法中积分精度的控制往往不是通过细化步长来表达，而是通过后一个积分值-前一个积分值<precision
这样来实现精度控制~呵呵
Ⅱ 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();
}
看看这个或许有帮助
Ⅲ 用c语言编程计算积分
#include #include float f1(float x) { return(1.0+x); } float f2(float x) { return(2.0*x+3.0); } float f3(float x) { return(exp(x)+1); } float f4(float x) { return(pow(1+x,2)); } float f5(float x) { return(pow(x,3)); } float fsimp(float a,float b,float (*p)(float)) { float c,s; c=(a+b)/2; s=(b-a)/6*(p(a)+4*p(c)+p(b)); return s; } int main() { float a,b; printf("请输入积分下限a的值："); scanf("%f",&a); printf("请输入积分上限b的值："); scanf("%f",&b); printf("%f\n",fsimp(a,b,f1)); printf("%f\n",fsimp(a,b,f2)); printf("%f\n",fsimp(a,b,f3)); printf("%f\n",fsimp(a,b,f4)); printf("%f\n",fsimp(a,b,f5)); }
Ⅳ 用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();
}
Ⅳ C语言求积分
float I_Control(float Input)
{
static float OutData = 0;
OutData+=Input*deltaT；
deltaT+=deltaT；
return OutData;
}
Ⅵ 用C语言计算微积分
我给一楼加的注释以及修改：
#include<stdio.h>
#include<math.h>
#define ARRAYBOUND 10001
void main()
{
int i = 0; //辅助变量，最常见那种
int n = 0; //将所求定积分函数曲线在x轴方向，平均分成n等分;n越大,结果越精确;不过限于此算法限制n<ARRAYBOUND,否则溢出.
float x[ARRAYBOUND];//ARRAYBOUND维浮点数组，存放离散的x坐标值
float y[ARRAYBOUND];//ARRAYBOUND维浮点数组，存放每个x坐标对应的函数值;x[i],y[i]满足y[i]=f(x[i]),f是你要求定积分的函数
float x0 = 0.0; //定积分下限
float xn = 0.0; //定积分上限
float h = 0.0; //面积微元宽度
float J = 0.0; //辅助变量
/*f=x^3*/ //这里说明要求定积分的是函数f(x)=x*x*x;(y等于x的立方,x^3是vb的写法)
// printf("input x0,xn,n:");
printf("请分别输入下限(x0),上限(xn),精度(n):");
scanf("%f",&x0);
scanf("%f",&xn);
scanf("%d",&n);
h=(xn-x0)/n;//将函数图形在x方向平分成n份,h是每个面积微元的宽度
x[0]=x0; //将积分下限赋值给x[0]
for(i=0;i<=n && n<ARRAYBOUND;i++)
{
x[i]=x[0]+i*h; //计算n个离散的横坐标值，存入x[]数组
y[i]=(float)pow(x[i],3);//计算n个横坐标对应的函数值，存入y[]数组。在此可以改变要求积分的函数
}
// J=0.0;
for(i=0;i<n;i++)
{
//J=J+y[i]+y[i+1];
J+=y[i];//将所有纵坐标值代数相加，存入J
}
//J=J*h/2.0;
J=J*h;//所有微元面积一次求解，因为∑h*y[i]=h*∑y[i];
printf("\nn=%d \n所求定积分值是: %f\n",n,J);
}
我将//J=J+y[i]+y[i+1]改为J+=y[i];将//J=J*h/2.0;改为J=J*h只是帮助lz理解
其实，这两种表达在理论上是等价的，不过我发现修改后，在n同样大小的情况下，结果的精度有一点点下降，还真不知为什么？？？
这样的话lz应该能理解了吧，其实一楼的算法还有不少值得改进的地方，希望lz能有所突破！！
Ⅶ 用C语言求积分
好象要你自己定义函数，库函数中好象是没有直接可以用的积分函数的。
Ⅷ 用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
由上面的比较可知，梯形法的精度要高于矩形法。