您的位置：360文档中心› c语言用六种方法求定积分

c语言用六种方法求定积分

合集下载

定积分计算方法总结

定积分计算方法总结

定积分计算方法总结定积分是微积分中的一种重要概念，用于计算曲线与x轴之间的面积、曲线的弧长、质量、质心等物理量。

本文将总结定积分的计算方法，包括基本定积分的计算、换元积分法、分部积分法等。

一、基本定积分的计算基本定积分是指形如∫f(x)dx的定积分，其中f(x)为已知函数。

基本定积分的计算方法主要包括常数法、分段法和凑微分法。

1. 常数法：当被积函数为常数函数时，可以直接利用积分性质计算。

如∫kdx=kx+C，其中k为常数，C为积分常数。

2. 分段法：当被积函数在不同区间上有不同的表达式时，可以将积分区间划分为不同的子区间，在每个子区间上分别计算积分，然后再求和得到整个区间上的积分值。

3. 凑微分法：当被积函数可以通过凑微分的方式转化为已知函数的微分形式时，可以利用凑微分法进行计算。

凑微分法的关键是找到合适的凑微分项，使得被积函数可以表示为一个函数的微分。

例如，对于∫x^2dx，可以将其转化为∫(x^2+1-1)dx，然后利用积分性质计算。

二、换元积分法换元积分法是一种常用的定积分计算方法，通过引入新的变量进行替换，将原来的积分转化为更容易计算的形式。

换元积分法的关键是选择合适的换元变量和适当的换元公式。

1. 一般换元法：当被积函数中存在形如f(g(x))g'(x)的部分时，可以选择g(x)作为新的变量进行替换。

然后利用链式法则计算新的微分形式，将原来的积分转化为新变量的积分。

2. 三角换元法：当被积函数中存在形如sin(x)或cos(x)等三角函数时，可以选择三角函数的反函数作为新的变量进行替换。

然后利用三角函数的导数和反函数的导数计算新的微分形式，将原来的积分转化为新变量的积分。

三、分部积分法分部积分法是一种常用的定积分计算方法，通过将积分中的乘积拆解为两个函数的乘积，利用分部积分公式进行计算。

分部积分法的关键是选择合适的分部函数和求导函数。

分部积分公式为∫u(x)v'(x)dx=u(x)v(x)-∫v(x)u'(x)dx。

C语言常用算法集合

C语言常用算法集合

1.定积分近似计算：/*梯形法*/double integral(double a,double b,long n) { long i;double s,h,x;h=(b-a)/n;s=h*(f(a)+f(b))/2;x=a;for(i=1;i<n;i++){x+=h;s+=h*f(x) ;}return(s);}/*矩形法*/double integral(double a,double b,long n) { long i;double t=0,h,x;h=(b-a)/n;x=a;for(i=0;i<n;i++){t+=h*f(x);x+=h;}return(t);}2. 生成斐波那契数列：/*直接计算*/int fib(int n){ int i,f1=1,f2=1,f;for(i=3;i<=n;i++){f=f1+f2;f1=f2;f2=f;}if(n==1||n==2) return 1;else return f;}/*递归调用*/void fib(int n,int*s){ int f1,f2;if(n==1||n==2) *s=1;else{ fib(n-1,&f1);fib(n-2,&f2);*s=f1+f2;}}3.素数的判断：/*方法一*/for (t=1,i=2;i<n; i++)if(n%i==0) t=0;if(t) printf("%d is prime",n);/*方法二*/for (t=1,i=2;i<n&&t; i++)if(n%i==0) t=0;if(t) printf("%d is prime",n);/*方法三*/for (i=2;i<n; i++)if(n%i==0) break;if(i==n) printf("%d is prime",n); /*方法四*/for(t=1,i=2; i<=(int)sqrt(n); i++)if(n%i==0){t=0;break;}if(t) printf("%d is prime",n);4.反序数：/*求反序数*/long fan(long n){ long k;for(k=0;n>0;n/=10)k=10*k+n%10;return k;}/*求回文数*/int f(long n){ long k,m=n;for(k=0;n>0;n/=10)k=10*k+n%10;if(m==k) return 1;return 0;}/*求整数位数*/int f(long n){ int count;for(count=0;n>0;n/=10)count++;return count;}5.求最大公约数：/*方法一*/int gcd(int x,int y){ int z;z=x<y?x:y;while(!(x%z==0&&y%z==0))/*x%z||y%z*/ z--;return z;}/*方法二*/int gcd(int x,int y){int r;while((r=x%y)!=0){x=y;y=r;}return y;}/*方法三*/int gcd(int a ,int b){ int r ;if((r=a%b)==0)return b;elsereturn gcd(b,r);}6.数组常用算法：查找：/*线性查找*/int find(int num,int x[],int key){ int i,m=-1;for(i=0;i<num;i++)if(x[i]==key){m=i;break;}return m;}/*折半查找*/int find(int x[],int num,int key){ int m=-1,low=0,high=num-1,mid;while(low<=high){mid=(low+high)/2;if(x[mid]==key){m=mid;break;}else if(x[mid]>key) high=mid-1;else low=mid+1;}return m;}/*折半查找（递归）*/int b_search(int x[ ],int low,int high,int key) {int mid;mid=(low+high)/2;if(x[mid]==key) return mid;if(low>=high) return -1;else if(key<x[mid])return b_search(x,low,mid-1,key);elsereturn b_search(x,mid+1,high,key); }/*寻找子串*/int find(char *s1,char *s2){ int i,k=0;while(s1[i]==s2[i]) i++;if(s2[i]==0) return k;s1++;k++;return -1;}分词：/*方法一*/void fen(char s[][10],char str){ int i,j,k;for(i=0,j=0,k=0;str[i]!=0;i++)if(isalpha(a[i]))s[j][k++]=str[i];else {s[j][k]=0;k=0;j++;}}}/*方法二*/#include<stdio.h>#include<string.h>void main(){ int i=0,n=0;char s[80],*p;strcpy(s,"It is a book.");for(p=s;p!='\0';p++)if(*p=='')i=0;elseif(i==0){n++;i=1;}printf("%d\n",n);getch();}排序：/*插入法排序*/void sort(int a[],int n){ int i,j,t;for(i=1;i<n;i++){t=a[i];for(j=i-1;j>=0&&t<a[j];j--)a[j+1]=a[j];a[j]=t;}}/*归并排序*/#define x 10#define y 10void com(int *a,int *b,int *c){ int i,j,k;for(i=0,j=0,k=0;i<=x&&j<=y;){if(a[i]<b[j]){c[k++]=a[i];i++;}else{c[k++]=b[j];j++;}}if(i<x) for(k=k-1;i<x;i++)c[k++]=a[i];if(j<x) for(k=k-1;j<y;j++)c[k++]=a[j]; }/*交换法排序1 冒泡排序*/void sort(int a[],int n){ int i,j,t,flag;for(i=0;i<n-1;i++){flag=1;for(j=0;j<n-1-i;j++)if(a[j]>a[j+1]){t=a[j];a[j]=a[j+1];a[j+1]=t;flag=0;}if(flag) break;}}/*交换法排序2*/void sort(int a[],int n){ int i,j,t;for(i=0;i<n-1;i++)for(j=i+1;j<n;j++)if(a[i]>a[j]){t=a[i];a[i]=a[j];a[j]=t;}}/*选择法排序*/void sort(int a[],int n){ int i,j,point,t;for(i=0;i<n-1;i++){point=i;for(j=i+1;j<n;j++)if(a[point]<a[j]) point=j;if(point!=i){t=a[point];a[point]=a[i];a[i]=t;}}}7.一元非线性方程求根：/*牛顿迭代法求函数跟*/#include <stdio.h>#include <math.h>int main(void){ double x,x1,eps=1e-6,f,f1; /*误差为eps*/x=1.0; /*x=1.0是初值*/do{x1=x;f=6-x1*(5-x1*(4-3*x1)); /*f为f(x)函数*/f1=-5+x1*(8-9*x1); /*f1为f(x)的导函数*/x=x1-f/f1;f=6-x*(5-x*(4-3*x));}while(fabs(f)>=eps &&fabs(x-x1)>=eps);printf("x=%f",x);}/*二分法求函数跟*/#include <stdio.h>#include <math.h>double f(double x){ return 6-x*(5-x*(4-3*x)); /*f(x)函数*/}int main(void){ double a,b,c,x,eps=1e-6;do{scanf("%lf%lf",&a,&b);}while(f(a)*f(b)>0);if(fabs(f(a))<1e-6)x=a;else if (fabs(f(b))<1e-6)x=b;else {c=(b+a)/2;while(fabs(f(c))>eps&&fabs(b-a)>eps){if(f(a)*f(c)<0)b=c;elsea=c;c=(b+a)/2;}x=c;}printf("x=%f",x);}/*弦截法求函数跟*/c=(a*f(b)-b*f(a))/ (f(b)-f(a));while(fabs(f(c))>eps){if(f(a)*f(c)<0)b=c;elsea=c;c=(a*f(b)-b*f(a))/ (f(b)-f(a));}#include <stdio.h>void f();int main(void){ int x, loop=0;do{for(x=1;x<5;x++) {int x=2;printf("%d",x);}printf("%d ",x);f();loop++;}while(loop<1);getch();}void f(){ printf("%d",x++); }8.汉诺塔：#include<stdio.h>void Hanoi(int n, char A, char B, char C){if(n==1)printf("\n move %d from %c to %c",n,A,C);else{Hanoi(n-1,A,C,B);printf("\nmove %d from %c to %c",n,A,C);Hanoi(n-1,B, A, C);}}int main(void){ Hanoi(3,'A','B','C');getch();}9.建立链表：NODE *creat(void) /* void表示无参函数*/{NODE *head=NULL,*p1=NULL,*p2=NULL;long num;unsigned score;int n=0;do{scanf(“%ld%u”,&num,&score);if(num==0) break;n++;p1=(NODE *)malloc(sizeof(NODE));p1->data.num=num,p1->data.score=score;p1->next=NULL;if(n==1)head=p2=p1;else{p2->next=p1;p2=p1;}}while(1);return head;}10.级数的近似计算:#include <stdio.h>#include <math.h>int main(void){ double s=1,a=1,x,eps,f;int n,m;printf("input x and eps:");scanf ("%lf%lf",&x,&eps);for(n=1;fabs(a)>eps; n++){for(f=1,m=1;m<=n;m++)f*=m;a=pow(x,n)/f;s+=a;}printf("%f",s);}。

C语言用六种方法求定积分

C语言用六种方法求定积分

C语言用六种方法求定积分C语言中求定积分的方法主要有以下六种：基本公式法、数值积分法、Laplace变换法、微积分概念法、数值积分法和Monte Carlo方法。

下面将详细介绍每种方法的原理和实现。

1.基本公式法：基本公式法是求解定积分的最基本方法，根据不同函数的特点和性质，利用已知的积分公式进行求解。

例如，对于一次函数和常数函数，可以使用基本公式法求解。

2.数值积分法：数值积分法是通过将定积分转化为数值计算问题来求解。

常用的数值积分方法有矩形法、梯形法和辛普森法等。

这些方法基于将求积分区间分割成若干个小区间，然后在每个小区间上近似计算出函数的积分值，再将这些积分值加总得到最终结果。

3. Laplace变换法：Laplace变换法是一种利用Laplace变换求解微分方程的方法，也可以用来求解定积分。

通过将被积函数进行Laplace变换，然后利用Laplace变换公式求解积分，最后再求出反变换得到结果。

4.微积分概念法：微积分概念法是通过将定积分定义为函数曲线下的面积来求解。

具体做法是将被积函数图像与坐标轴围成的面积分为若干个小的矩形、梯形或曲线段以及一个小的区域。

然后根据图形的几何性质进行近似计算，将这些小面积相加得到最终结果。

5.数值积分法：数值积分法也是一种基于数值计算的方法，但与前面提到的数值积分法不同，它通过构造一系列特定形式的插值函数对被积函数进行逼近，然后计算插值函数的积分值来近似求解定积分。

常用的数值积分法有牛顿-科特斯公式和高斯-勒让德公式。

6. Monte Carlo方法：Monte Carlo方法是一种基于统计随机性的数值积分方法，它通过随机抽样来进行数值求解。

具体做法是在被积函数图像下随机抽取一系列点，根据这些随机点的坐标和函数值来估计函数的积分值。

通过对多次随机抽样的结果取平均可以得到定积分的近似值。

以上六种方法都可以用C语言来实现，具体的实现方法可以根据具体问题的特点和要求选择合适的算法和数据结构，然后编写相应的代码实现。

C语言实现定积分求解方法

C语言实现定积分求解方法

C语言实现定积分求解方法C语言可以通过数值积分的方法来实现定积分的求解，主要有矩形法、梯形法和辛普森法等几种常见的求解方法。

矩形法是最简单的一种数值积分方法，它将定积分区间等分成若干个小区间，然后在每个小区间上取一个点，将积分区间分成若干个小矩形，对每个小矩形的面积进行求和，即可得到近似的定积分值。

以下是使用矩形法实现定积分求解的C语言代码：```c#include<stdio.h>#include<math.h>double f(double x)//定义需要求解的函数return sqrt(1-x*x);double integrate(double a, double b, int n)//a:积分下限,b:积分上限,n:划分的矩形个数double dx = (b-a)/n; // 求解每个小矩形的宽度double sum = 0.0; // 求和变量int i;for(i=0; i<n; i++)double x = a + i*dx + dx/2; // 计算每个小矩形的横坐标中点sum += f(x)*dx; // 计算每个小矩形的面积并求和}return sum;int maindouble a = 0.0; // 积分下限double b = 1.0; // 积分上限int n = 1000; // 划分的矩形个数double result = integrate(a, b, n); // 求解定积分printf("The definite integral is: %.6f\n", result);return 0;```梯形法是一种比矩形法更精确的数值积分方法，它将积分区间等分成若干个小区间，然后将每个小区间上的函数图像近似为一个梯形，对每个梯形的面积进行求和，即可得到近似的定积分值。

以下是使用梯形法实现定积分求解的C语言代码：```c#include<stdio.h>#include<math.h>double f(double x)//定义需要求解的函数return sqrt(1-x*x);double integrate(double a, double b, int n)//a:积分下限,b:积分上限,n:划分的梯形个数double dx = (b-a)/n; // 求解每个小梯形的底边宽度double sum = 0.0; // 求和变量int i;for(i=0; i<n; i++)double x1 = a + i*dx; // 计算每个小梯形的左边横坐标double x2 = a + (i+1)*dx; // 计算每个小梯形的右边横坐标sum += (f(x1)+f(x2))*dx/2; // 计算每个小梯形的面积并求和}return sum;int maindouble a = 0.0; // 积分下限double b = 1.0; // 积分上限int n = 1000; // 划分的梯形个数double result = integrate(a, b, n); // 求解定积分printf("The definite integral is: %.6f\n", result);return 0;```辛普森法是一种更为精确的数值积分方法，它将积分区间等分成若干个小区间，然后在每个小区间上使用二次多项式来逼近积分函数的曲线，对每个小区间的积分值进行加权求和，即可得到近似的定积分值。

矩形法求函数的定积分

矩形法求函数的定积分
C 语言在计算中的应用
用矩形法求函数的定积分（C 语言实现）
在本程序中，先分别定义了 5 个 C 函数 f1、f2、f3、f4、f5，用来代表 5 个不同的函数。然后 定义了一个求定积分的函数 integral。现在介绍矩形法求函数定积分的数学思想。
设函数 在区间[a,b]上连续，在(a,b)上可导，将[a,b]之间的长度等分成 n 份（n 越大计算越精 确）。于是第 块小矩形的面积为 ，
printf("%lf\n",S[j]); } }
运行结果如图所示：
可以发现，计算值与理论值十分接近，当 N 取的足够大时，可以获得十分精确的值，但是运算 次数也会增加，本函数的时间复杂度为 O(n)。
从指针的用法上来讲，本程序使用了“指向函数的指针”。一个函数的函数名，代表了这个函 数的首地址，在主函数中，5 次调用 integral 函数，实现了对 5 个不同的函数求积分。integral 函 数包含了三个参数，前两个参数表示被积函数的上下限。
sum=sum+d*(*fun)(a+i*d);//定积分近似计算公式 }//fun 是指向函数的指针，该指针所指向的函数带有一个 double 型的形参， //同时，该函数的返回值类型为 double return sum; }
2
C 语言在计算中的应用
void main() {
double S[5]; int j; S[0]=integral(0,1,f1);//fun 指向 f1 S[1]=integral(0,1,f2);//fun 指向 f2 S[2]=integral(0,1,f3);//fun 指向 f3 S[3]=integral(0,1,f4);//fun 指向 f4 S[4]=integral(0,1,f5);//fun 指向 f5 printf("输出各个函数的积分值：\n"); for(j=0;j<5;j++) {

定积分计算方法总结

定积分计算方法总结

定积分计算方法总结定积分是微积分中的一个重要概念，用于计算曲线与坐标轴之间的面积、曲线长度、质量、动量等问题。

本文将总结几种常见的定积分计算方法。

1.基本积分法：也称为不定积分法，是定积分的基础。

通过求导的逆过程，可以将一些简单的函数反求积分。

例如，对于常数函数、幂函数、指数函数、三角函数等，都可以直接得到不定积分的表达式。

但对于复杂函数，基本积分法可能不适用。

2. 牛顿-莱布尼茨公式：也称为换元积分法。

该方法通过引入新的变量，将原积分转化为更简单的形式。

常见的换元变量有正弦函数、指数函数、幂函数等。

换元积分法的关键在于选择合适的换元变量，使得被积函数的形式变得更简单。

例如，对于∫sin(2x)dx，可以通过令u=2x进行换元，得到新的积分∫sin(u)du，再求解即可。

3. 分部积分法：也称为乘法积分法，是对乘积形式的积分进行处理的方法。

通过对乘积函数中的一个函数求导，另一个函数积分，可以将原积分转化为更简单的形式。

分部积分法的公式为∫udv=uv-∫vdu，其中u和v是可以求导或积分的函数。

该方法适用于许多复杂函数的积分计算，例如多项式函数与指数函数的积分。

4. 凑微分法：也称为凑常数法，是对积分式进行代换，使得被积函数的微分形式展开后更简单，从而进行积分的方法。

例如，对于∫x/(1+x^2)dx，可以通过令u=1+x^2进行代换，得到新的积分∫(1/u)du，再求解即可。

5. 变限积分法：该方法常用于计算曲线与坐标轴之间的面积。

当被积函数为连续函数时，可以通过使用反函数求解，将定积分转化为一系列不定积分的差值。

例如，对于求解曲线y=f(x)与x轴所围成的面积，可以将其表示为∫[a,b]f(x)dx=[F(x)]a^b，其中F(x)是f(x)的原函数。

通过求F(x)的反函数，可以将定积分简化为计算两个不定积分的差值。

6. 参数方程法：该方法适用于计算平面曲线围成的面积。

当曲线由参数方程给出时，可以通过将x或y表示为参数的函数，进而将面积转化为定积分的形式。

C语言实现定积分求解方法

C语言实现定积分求解方法

C语⾔实现定积分求解⽅法求定积分的⽅法有很多种，下⾯是我总结的⼏种⽐较常⽤的⽅法。

#include <stdio.h>#include <stdlib.h>#include <math.h>#include <time.h>#define N 3double fun(double x){double y;y = sqrt(4-(x)*(x));//y = sin(x);return y;}/*随机点法求定积分*/double Darts(int n){double x, y;time_t t;int i = 0;int count = 0;srand((unsigned)time(&t));for (i=0; i<n; i++){x = rand()%100/100.0;y = rand()%100/100.0;if (y <= 1-pow(x,2)){count++;}}return (double)count/(double)n;}/*左矩形法求定积分*/double LeftRect(double down, double up, int n){double h, s;int i;/*计算步长*/h = (up-down)/n;s = fun(down)*h;for (i=1; i<n; i++){s = s + fun(down+i*h)*h;}return s;}/*梯形公式求定积分*/double Trape(double down, double up, int n){double h, s;int i = 0;/*计算步长*/h = (up-down)/n;s = 0.5*(fun(down)+fun(down+h))*h;for (i=1; i<n; i++){s = s + 0.5 * (fun(down+i*h) + fun(down+(i+1)*h))*h;}return s;}/*复合梯形公式*/double T(double x, double y, int z){double h, Tn;int i = 0;h = (y-x)/z;Tn = (fun(x)+fun(y))/2;for (i=0; i<z; i++){Tn = Tn+fun(x+i*h);}Tn = Tn*h;return Tn;}/*⾟普⽣公式求定积分，公式为：S[n]=(4*T[2*n]-T[n])/3，其中T[2n],T[n]为梯形公式计算结果*/ double Simposn(double down, double up, int n){double s;/*⾟普⽣公式*/s = (4*T(down, up, 2*n) - T(down, up, n))/3;return s;}/*⾼斯公式求定积分*/double Gass(double (*func)(double x), double a, double b, int n){int i = 0;//⾼斯点及其求积系数列表float x1[1]={0.0};float A1[1]={2};float x2[2]={-0.5573503,0.5573503};float A2[2]={1,1};float x3[3]={-0.7745967,0.0,0.7745967};float A3[3]={0.555556,0.888889,0.555556};float x4[4]={0.3399810,-0.3399810,0.8611363,-0.8611363};float A4[4]={0.6521452,0.6521452,0.3478548,0.3478548};float x5[5]={0.0,0.5384693,-0.5384693,0.9061799,-0.9061799};float A5[5]={0.5688889,0.4786287,0.4786287,0.2369269,0.2369269};float *p, *t;switch (n){case 1:p = x1;t = A1;break;case 2:p = x2;t = A2;break;case 3:p = x3;t = A3;break;case 4:p = x4;t = A4;break;case 5:p = x5;t = A5;break;default :printf("intput wrong!");}float g = 0;for (i=0; i<n; i++){g += (*func)((b-a)*p[i]/2+(a+b)/2)*t[i];}g *= (b-a)/2;return g;}int main(int argc, char *argv[]){printf("随机点法积分值%f\n", Darts(10000)); double down, up;int n;double sum = 0;printf("积分下限:\n");scanf("%lf", &down);printf("积分上限:\n");scanf("%lf", &up);printf("分隔数⽬:\n");scanf("%d", &n);sum = LeftRect(down, up, n);printf("左矩形法积分值为:%f\n", sum);sum = Trape(down, up, n);printf("梯形公式积分值为:%f\n", sum);sum = Simposn(down, up, n);printf("⾟普⽣公式积分值为:%f\n", sum);sum = Gass(fun, down, up, N);printf("⾼斯公式积分值为:%f\n", sum);return 0;}。

C语言使用矩形法求定积分的通用函数

C语言使用矩形法求定积分的通用函数

C语⾔使⽤矩形法求定积分的通⽤函数本⽂为⼤家分享了C语⾔使⽤矩形法求定积分的通⽤函数，供⼤家参考，具体内容如下要求：写⼀个⽤矩形法求定积分的通⽤函数，分别求：sin(x),cos(x),e^x 。

分析：矩形法，学过⾼等数学就知道化曲为直的思想。

将定积分化为多个函数连续的和。

基本思想是将区间[a，b]化成n等分，当n越⼤的时候结果越准确。

图形化成⼀⼩块⼀⼩块的矩形。

底边长都为(b-a)/n.⾼为每个等分点的函数值。

然后将每个矩形的⾯积相加即为所求。

如：y=x;可以通过矩形的⽅法来⽆限逼近定积分的求解，如下：因为被分成n等分，就可以认为每⼀等分是⼀个矩形，那么每⼀矩形的⾯积为：每⼀个矩形⾯积为：***Sn=f(x)(b-a)/n 总⾯积为：****S=S1+S2+…+Sn#include <stdio.h>#include <stdlib.h>#include <math.h>//引⼊sin x,cos x,e^x的库//使⽤指向函数的指针变量来复⽤⼀个通⽤函数int main(){int i,j,k,n,m;float res;float (*fun)(float);//定义指向函数的指针变量float integral (float a,float b,float (*fun)(float),int n);//n为将积分区间（b-a)分成n等分，当n的值越⼤的时候结果越精确，数学上的定义是取⽆穷⼤float fsin(float);//sin x函数的声明float fcos(float);//cos x函数的声明float fexp(float);//e^x 函数的声明printf ("请输⼊积分的下限\n");scanf ("%d",&m);printf ("请输⼊积分的上限\n");scanf ("%d",&n);printf("请输⼊你要计算的函数的具体函数\n");printf("1.sin(x) 2.cos(x) 3.e^x\n");scanf ("%d",&i);switch(i){case 1:fun=fsin;//函数地址（⼊⼝）交给指针变量，灵活性强break;case 2:fun=fcos;break;case 3:fun=fexp;}res=(fun)(2.00);//printf("xxxx=%f\n",res);printf ("计算的结果为\n");res=integral(m,n,fun,200000);printf("res=%f",res);return 0;}float fsin(float x){// printf("fsinx=%f\n",x);return sin(x);}float fcos(float x){//printf("fcosx=%f\n",x);return cos(x);}float fexp(float x){//getchar();//printf("fexp=%f\n",x);return exp(x);}float integral(float a,float b,float (*fun)(float),int n){//矩形法计算,定积分转换为连续求和的形式int i=0;float x=a,s=0;float h=(b-a)/n;for (i=1;i<=n;i++){x=x+h;s=s+((*fun)(x)*h);}return s;}结果：以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。

编程实现数值积分的几种--方法 c语言

编程实现数值积分的几种--方法 c语言

编程实现数值积分的几种--方法c语言数值计算2010-11-05 09:52:43 阅读385 评论1 字号：大中小订阅复化梯形公式在区间不大时, 用梯形公式、辛卜生公式计算定积分是简单实用的, 但当区间较大时, 用梯形公式、辛卜生公式计算定积分达不到精确度要求 . 为了提高计算的精确度，我们将[a,b] 区间n等分，在每个小区间上应用梯形公式、辛卜生公式计算定积分，然后将其结果相加，这样就得到了复化梯形公式和复化辛卜生公式。

1. 复化梯形公式将积分区间等分, 设, 则节点为对每个小区间上应用梯形公式, 然后将其结果相加，则得(3.14)称(3.14) 式为复化梯形公式 .当在[a,b] 上有连续的二阶导数时，则复化梯形公式(3.14) 的余项推导如下：因为所以在区间[a,b] 上公式(3.14) 的误差为又因为在区间[a,b] 上连续，由连续函数的性质知，在区间[a,b] 上存在一点，于是（ 3.15 ）复化梯形公式，复化抛物线公式和Romberg求积法的算法程序：以下程序均定义误差限为1*10^-5;1)复化梯形公式：#include <stdio.h>#include <math.h>#define e 1e-5#define a 0 //积分下限a#define b 1 //积分上限b#define f(x) (4/(1+(x*x))) //被积函数f(x)int main(){int i,n;double h,t0,t,g;n=1; //赋初值h=(double)(b-a)/2;t=h*(f(a)+f(b));do{t0=t;g=0;for (i=1;i<=n;i++)g+=f((a+(2*i-1)*h));t=(t0/2)+(h*g); //复化梯形公式n*=2;h/=2;}while (fabs(t-t0)>e); //自定义误差限e printf("%.8lf",t); //输出积分的近似值return 0;}2)复化抛物线公式：#include <stdio.h>#include <math.h>#define e 1e-5#define a 0 //积分下限a#define b 1 //积分上限b#define f(x) (4/(1+(x*x))) //被积函数f(x)int main(){int i,n;double f1,f2,f3,h,s0,s;f1=f(a)+f(b); //赋初值f2=f(((double)(b+a)/2));f3=0;s=((double)(b-a)/6)*(f1+4*f2);n=2;h=(double)(b-a)/4;do //复化抛物线算法{f2+=f3;s0=s;f3=0;for (i=1;i<=n;i++)f3+=f((a+(2*i-1)*h));s=(h/3)*(f1+2*f2+4*f3);n*=2;h/=2;}while (fabs(s-s0)>e); //自定义误差限printf("%.8lf",s);return 0;}3)Romberg求积法：#include <stdio.h>#include <math.h>#define e 1e-5#define a 0 //积分下限a#define b 1 //积分上限b#define f(x) (4/(1+(x*x))) //被积函数f(x)double t[100][100];int main(){int n,k,i,m;double h,g,p;h=(double)(b-a)/2;t[0][0]=h*(f(a)+f(b));k=1;n=1;do //Romberg算法{g=0;for (i=1;i<=n;i++)g+=f((a+((2*i-1)*h)));t[k][0]=(t[k-1][0]/2)+(h*g);for (m=1;m<=k;m++){p=pow(4,(double)(m));t[k-m][m]=(p*t[k-m+1][m-1]-t[k-m][m-1])/(p-1);}m-=1;h/=2;n*=2;k+=1;}while (fabs(t[0][m]-t[0][m-1])>e); //自定义误差限eprintf("%.8lf",t[0][m]);return 0;}给定精度，定义误差限为1*10^-5，分别求出步长的先验估计值：用复化梯形公式计算，要求h<0. 007746。

c语言表示积分

c语言表示积分

c语言表示积分积分是微积分的重要概念之一，用于求函数在某个区间上的总量或者累积变化量。

在C语言中，我们可以使用不同的方法来实现积分的计算。

一、定积分的计算方法定积分是指在某个区间上求函数与x轴之间的面积，可以用面积与区间长度的乘积来表示。

在C语言中，可以通过数值积分方法来近似计算定积分。

1.矩形法：矩形法是一种最简单的数值积分方法，它将区间划分为多个小矩形，然后用矩形面积的和来近似表示函数的总面积。

具体步骤如下：a.将区间[a, b]等分为n个小区间，每个小区间的宽度为h=(b-a)/n。

b.在每个小区间的右边选择一个点xi（i=0,1,2,...,n-1），计算出该点对应的函数值f(xi)。

c.将每个小矩形的面积f(xi)*h累加起来，得到总面积。

2.梯形法：梯形法是另一种常用的数值积分方法，它将区间划分为多个小梯形，然后用梯形面积的和来近似表示函数的总面积。

具体步骤如下：a.将区间[a, b]等分为n个小区间，每个小区间的宽度为h=(b-a)/n。

b.在每个小区间的两个端点上计算函数值，得到f(xi)和f(xi+1)。

c.将每个小梯形的面积[(f(xi)+f(xi+1))/2]*h累加起来，得到总面积。

二、代码示例下面是使用C语言实现上述两种数值积分方法的代码示例：1.矩形法代码示例：```c#include <stdio.h>double f(double x) {//定义被积函数return x*x;}double integral_rectangle(double a, double b, int n) { //计算矩形法近似积分double h = (b - a) / n;double sum = 0.0;for (int i = 0; i < n; i++) {double x = a + i * h;sum += f(x);}return sum * h;}int main() {double a = 0.0; //积分下限double b = 1.0; //积分上限int n = 100; //小区间个数double result = integral_rectangle(a, b, n); printf("矩形法求积分的结果为：%lf\n", result); return 0;}```2.梯形法代码示例：```c#include <stdio.h>double f(double x) {//定义被积函数return x*x;}double integral_trapezoid(double a, double b, int n) { //计算梯形法近似积分double h = (b - a) / n;double sum = 0.0;for (int i = 0; i < n; i++) {double x1 = a + i * h;double x2 = a + (i+1) * h;sum += (f(x1) + f(x2)) / 2;}return sum * h;}int main() {double a = 0.0; //积分下限double b = 1.0; //积分上限int n = 100; //小区间个数double result = integral_trapezoid(a, b, n);printf("梯形法求积分的结果为：%lf\n", result);return 0;}```三、总结以上是使用C语言实现数值积分的两种方法，定积分是微积分中的重要概念，可以通过数值积分方法来近似计算定积分的值。

数值分析方法计算定积分

数值分析方法计算定积分

数值分析⽅法计算定积分⽤C语⾔实现⼏种常⽤的数值分析⽅法计算定积分，代码如下：1 #include <stdio.h>2 #include <string.h>3 #include <stdlib.h>4 #include <math.h>56#define EPS 1.0E-14 //计算精度7#define DIV 1000 //分割区间，值越⼤，精确值越⾼8#define ITERATE 20 //⼆分区间迭代次数，区间分割为2^n，初始化应该⼩⼀点，否则会溢出910#define RECTANGLE 0 //矩形近似11#define TRAPEZOID 1 //梯形近似12#define TRAPEZOID_FORMULA 2 //递推梯形公式13#define SIMPSON_FORMULA 3 //⾟普森公式14#define BOOL_FORMULA 4 //布尔公式1516double function1(double);17double function2(double);18double function3(double);19void Integral(int, double f(double), double, double); //矩形, 梯形逼近求定积分公式20void Trapezoid_Formula(double f(double), double a, double b); //递推梯形公式21void Simpson_Formula(double f(double), double a, double b); //⾟普森公式22void Bool_Formula(double f(double), double a, double b); //布尔公式23void Formula(int, double f(double), double, double);2425double function1(double x)26 {27double y;28 y = cos(x);29return y;30 }3132double function2(double x)33 {34double y;35 y=1/x;36// y = 2+sin(2 * sqrt(x));37return y;38 }3940double function3(double x)41 {42double y;43 y = exp(x);44return y;45 }4647int main()48 {49 printf("y=cos(x) , x=[0, 1]\n");50 printf("Rectangle : "); Integral(RECTANGLE, function1, 0, 1);51 printf("Trapezoid : "); Integral(TRAPEZOID, function1, 0, 1);52 Formula(TRAPEZOID_FORMULA, function1, 0, 1);53 Formula(SIMPSON_FORMULA, function1, 0, 1);54 Formula(BOOL_FORMULA, function1, 0, 1);55 printf("\n");5657 printf("y=1/x , x=[1, 5]\n");58 printf("Rectangle : "); Integral(RECTANGLE, function2, 1, 5);59 printf("Trapezoid : "); Integral(TRAPEZOID, function2, 1, 5);60 Formula(TRAPEZOID_FORMULA, function2, 1, 5);61 Formula(SIMPSON_FORMULA, function2, 1, 5);62 Formula(BOOL_FORMULA, function2, 1, 5);63 printf("\n");6465 printf("y=exp(x) , x=[0, 1]\n");66 printf("Rectangle : "); Integral(RECTANGLE, function3, 0, 1);67 printf("Trapezoid : "); Integral(TRAPEZOID, function3, 0, 1);68 Formula(TRAPEZOID_FORMULA, function3, 0, 1);69 Formula(SIMPSON_FORMULA, function3, 0, 1);70 Formula(BOOL_FORMULA, function3, 0, 1);7172return0;73 }74//积分：分割-近似-求和-取极限75//利⽤黎曼和求解定积分76void Integral(int method, double f(double),double a,double b) //f(double)，f(x), double a，float b，区间两点77 {79double x;80double sum = 0; //矩形总⾯积81double h; //矩形宽度82double t = 0; //单个矩形⾯积8384 h = (b-a) / DIV;8586for(i=1; i <= DIV; i++)87 {88 x = a + h * i;89switch(method)90 {91case RECTANGLE :92 t = f(x) * h;93break;94case TRAPEZOID :95 t = (f(x) + f(x - h)) * h / 2;96break;97default:98break;99 }100 sum = sum + t; //各个矩形⾯积相加101 }102103 printf("the value of function is %.10f\n", sum);104 }105106//递推梯形公式107void Trapezoid_Formula(double f(double), double a, double b)//递推梯形公式108 {109 unsigned int i, j, M, J=1;110double h;111double F_2k_1 = 0;112double T[32];113double res = 0;114115 T[0] = (f(a) + f(b)) * (b-a)/2;116for(i=0; i<ITERATE; i++)117 {118 F_2k_1 = 0;119 J = 1;120121for(j=0; j<=i; j++) //区间划分122 J <<= 1; //2^J123 h = (b - a) /J; //步长124//M = J/2; //2M表⽰将积分区域划分的块数125for(j=1; j <= J; j += 2) //126 {127 F_2k_1 += f(a + j*h); //f(2k-1)累加和128 }129 T[i+1] = T[i]/2 + h * F_2k_1; //递推公式130 res = T[i+1];131132if(fabs(T[i+1] - T[i]) < EPS)133if(i < 3) continue;134else break;135 }136137 printf("Trapezoid_Formula : the value of function is %.10f\n", res);138//return res;139 }140//⾟普森公式141void Simpson_Formula(double f(double), double a, double b) //⾟普森公式142 {143 unsigned int i, j, M, J=1;144double h;145double F_2k_1 = 0;146double T[32], S[32];147double res_T = 0, res_S = 0;148149 T[0] = (f(a) + f(b)) * (b-a)/2;150for(i=0; i<ITERATE; i++)151 {152 F_2k_1 = 0;153 J = 1;154155for(j=0; j<=i; j++) //区间划分156 J <<= 1; //2^J157 h = (b - a) /J; //步长158//M = J/2; //2M表⽰将积分区域划分的块数159for(j=1; j <= J; j += 2) //160 {161 F_2k_1 += f(a + j*h); //f(2k-1)累加和163 T[i+1] = T[i]/2 + h * F_2k_1; //递推梯形公式164 res_T = T[i+1];165166if(fabs(T[i+1] - T[i]) < EPS)167if(i < 3) continue;168else break;169 }170171for(i=1; i<ITERATE; i++)172 {173 S[i] = (4 * T[i] - T[i-1]) / 3; //递推⾟普森公式174 res_S = S[i];175if(fabs(S[i] - S[i-1]) < EPS)176if(i < 3) continue;177else break;178 }179180 printf("Simpson_Formula : the value of function is %.10f\n", res_S);181//return res_S;182 }183184//布尔公式185void Bool_Formula(double f(double), double a, double b) //布尔公式186 {187 unsigned int i, j, M, J=1;188double h;189double F_2k_1 = 0;190double T[32], S[32], B[32];191double res_T = 0, res_S = 0, res_B;192193 T[0] = (f(a) + f(b)) * (b-a)/2;194for(i=0; i<ITERATE; i++)195 {196 F_2k_1 = 0;197 J = 1;198199for(j=0; j<=i; j++) //区间划分200 J <<= 1; //2^J201 h = (b - a) /J; //步长202//M = J/2; //2M表⽰将积分区域划分的块数203for(j=1; j <= J; j += 2) //204 {205 F_2k_1 += f(a + j*h); //f(2k-1)累加和206 }207 T[i+1] = T[i]/2 + h * F_2k_1; //递推公式208 res_T = T[i+1];209210if(fabs(T[i+1] - T[i]) < EPS)211if(i < 3) continue;212else break;213 }214215for(i=1; i<ITERATE; i++)216 {217 S[i] = (4 * T[i] - T[i-1]) / 3; //递推⾟普森公式218 res_S = S[i];219if(fabs(S[i] - S[i-1]) < EPS)220if(i < 3) continue;221else break;222 }223224for(i=1; i<ITERATE; i++)225 {226 B[i] = (16 * S[i] - S[i-1]) / 15; //递推布尔公式227 res_B = B[i];228if(fabs(B[i] - B[i-1]) < EPS)229if(i < 3) continue;230else break;231 }232233 printf("Bool_Formula : the value of function is %.10f\n", res_B);234//return res_B;235 }236237//采⽤⼆分区间的⽅法迭代，实际运⾏速度很慢238void Formula(int method, double f(double), double a, double b)//递推梯形公式239 {240 unsigned int i, j, M, J=1;241double h;242double F_2k_1 = 0;243double T[32], S[32], B[32];244double res_B = 0, res_S = 0, res_T = 0;247for(i=0; i<ITERATE; i++)248 {249 F_2k_1 = 0;250 J = 1;251252for(j=0; j<=i; j++) //区间划分253 J <<= 1; //2^J254 h = (b - a) /J; //步长255//M = J/2; //2M表⽰将积分区域划分的块数256for(j=1; j <= J; j += 2) //257 {258 F_2k_1 += f(a + j*h); //f(2k-1)累加和259 }260 T[i+1] = T[i]/2 + h * F_2k_1; //递推公式261 res_T = T[i+1];262263if(fabs(T[i+1] - T[i]) < EPS)264if(i < 3) continue;265else break;266 }267268switch(method)269 {270default :271case TRAPEZOID_FORMULA :272 printf("Trapezoid_Formula : the value of function is %.10f\n", res_T); 273//return res_T;274break;275case SIMPSON_FORMULA :276for(i=1; i<ITERATE; i++)277 {278 S[i] = (4 * T[i] - T[i-1]) / 3;279 res_S = S[i];280if(fabs(S[i] - S[i-1]) < EPS)281if(i < 3) continue;282else break;283 }284 printf("Simpson_Formula : the value of function is %.10f\n", res_S); 285//return res_S;286break;287case BOOL_FORMULA :288for(i=1; i<ITERATE; i++)289 {290 S[i] = (4 * T[i] - T[i-1]) / 3;291 res_S = S[i];292if(fabs(S[i] - S[i-1]) < EPS)293if(i < 3) continue;294else break;295 }296for(i=1; i<ITERATE; i++)297 {298 B[i] = (16 * S[i] - S[i-1]) / 15;299 res_B = B[i];300if(fabs(B[i] - B[i-1]) < EPS)301if(i < 3) continue;302else break;303 }304305 printf("Bool_Formula : the value of function is %.10f\n", res_B); 306//return res_B;307break;308 }309310 }测试结果：。

C语言常用算法

C语言常用算法

累加算法的要领是形如“s=s+A”的累加式，此式必须出现在循环中才能被反复执行，从而实现累加功能。

“A”通常是有规律变化的表达式，s在进入循环前必须获得合适的初值，通常为0。

例1、求1+2+3+……+100的和。

main(){int i,s;s=0; i=1;while(i<=100){s=s+i; /*累加式*/i=i+1; /*特殊的累加式*/}printf("1+2+3+...+100=%d\n",s);}【解析】程序中加粗部分为累加式的典型形式，赋值号左右都出现的变量称为累加器，其中“i = i + 1”为特殊的累加式，每次累加的值为1，这样的累加器又称为计数器。

3．累乘累乘算法的要领是形如“s=s*A”的累乘式，此式必须出现在循环中才能被反复执行，从而实现累乘功能。

“A”通常是有规律变化的表达式，s在进入循环前必须获得合适的初值，通常为1。

例1、求10！[分析]10！=1×2×3×……×10main(){int i; long c;c=1; i=1;while(i<=10){c=c*i; /*累乘式*/i=i+1;}printf("1*2*3*...*10=%ld\n",c);}二、非数值计算常用经典算法1．穷举也称为“枚举法”，即将可能出现的每一种情况一一测试，判断是否满足条件，一般采用循环来实现。

例1、用穷举法输出所有的水仙花数（即这样的三位正整数：其每位数位上的数字的立方和与该数相等，比如：13+53+33=153）。

[法一]main(){int x,g,s,b;for(x=100;x<=999;x++){g=x%10; s=x/10%10; b=x/100;if(b*b*b+s*s*s+g*g*g==x)printf("%d\n",x);}}【解析】此方法是将100到999所有的三位正整数一一考察，即将每一个三位正整数的个位数、十位数、百位数一一求出（各数位上的数字的提取算法见下面的“数字处理”），算出三者的立方和，一旦与原数相等就输出。

C语言程序设计循环结构之科学计算

C语言程序设计循环结构之科学计算

5.9 循环应用举例
X0代表前一次的近似根， x代表后一次的近似根。
#include <stdio.h> 求出一个x后，把它的
例3：编写程序，用
#include <math.h> 值赋给x0，然后用x0求
main() Newton迭代法求方程 {
下一个x。
f(x)=2x+cosx-2.6=0
float x,x0,f,f1; x=2; /*迭代初值自选*/
n个数，相对来说，梯形法的精度比矩形法的要高一些。
5.9 循环应用举例
4.用矩形法求一元函数在某区间上的积分近似值s
初始算法：初始化积分区间（a，b），如果把积分区间划分为 100个格，则每个区间的宽度h=fabs(a-b)/100；
5.9 循环应用举例
【例5_34】 ：编写程 序，用矩形法求一元函 数f(x)=x*x在区间[0，1] 上的积分近似值S。 （课本P103）
在某区间上的近似实根r
4.用矩形法求一元函数在某区间上的积分近似值S
5.用梯形法求一元函数在某区间上的积分近似值S
6.加密、解密算法
所谓非线性方程，就是因变量与自变量 之间的关系不是线性的关系，这类方程 很多，例如平方关系、对数关系、指数 关系、三角函数关系等等。
5.9 循环应用举例
1.用普通迭代法求方程的近似实根r
main()
{
double x,y=0,h,a=0,b=3.1416/6,s;
int i,n=15;
h=fabs(a-b)/n;
for(i=1;i<=n;i++)
{
x=a+(i-1)*h;
y=y+sqrt(4-sin(x)*sin(x));

C语言__用六种方法求定积分

C语言__用六种方法求定积分

C语言__用六种方法求定积分C语言是一种广泛应用于科学计算、算法设计和系统编程的程序设计语言。

虽然C语言本身并没有提供内置的定积分计算函数，但可以通过使用不同的方法来近似计算定积分。

以下将介绍六种常见的数值积分方法：矩形法、梯形法、辛普森法、龙贝格法、高斯-勒让德法和自适应辛普森法。

1. 矩形法（Reimann Sum）：将积分区间等分成若干小区间，然后在每个小区间取一个函数值，最后将所有函数值相加，并乘以区间大小。

这相当于将每个小区间上的曲线近似为一个矩形。

2. 梯形法（Trapezoidal Rule）：将积分区间分割成若干小区间，并在每个小区间使用梯形面积公式进行近似计算。

梯形的上底和下底分别为相邻两个小区间的函数值，高为小区间的宽度。

3. 辛普森法（Simpson's Rule）：将积分区间分割成若干小区间，并在每个小区间使用三点拉格朗日插值多项式近似计算。

辛普森法使用二次多项式来逼近曲线，能够更好地近似曲线的曲率。

4. 龙贝格法（Romberg Method）：龙贝格法是一种逐步逼近的方法，将积分区间多次分割，并使用多种精度的梯形法进行计算。

通过不断提高梯形法的精度，最终逼近定积分的值。

5. 高斯-勒让德法（Gauss-Legendre Method）：高斯-勒让德法使用一组预先确定的节点和权重，将积分区间变换到[-1,1]上，然后使用插值多项式计算定积分的近似值。

该方法的优点是能够以很高的精度计算积分值。

6. 自适应辛普森法（Adaptive Simpson's Rule）：自适应辛普森法根据曲线的变化程度自动调整子区间的大小。

在每个小区间上计算出辛普森值，并与高斯-勒让德法值进行比较，以决定是否需要进一步细分区间。

以上这些方法都可以使用C语言中的循环、条件语句和函数来实现。

具体实现的步骤包括：将积分区间分割成若干小区间，计算每个小区间上的函数值，然后将这些函数值进行加权求和，最后乘以相应的权重或宽度，得到定积分的近似值。

C语言用六种方法求定积分

C语言用六种方法求定积分

1. 描述问题利用①左矩形公式‎，②中矩形公式‎，③右矩形公式‎ ，④梯形公式，⑤simps ‎on 公式，⑥Gauss ‎积分公式求‎解定积分。

2. 分析问题2.1定积分21.1定积分的‎定义定积分就是‎求函数在区‎()f x 间中图线下‎[],a b 包围的面积‎。

即所包围的‎()0,,,y x a x b y f x ====面积。

这个图形称‎为曲边梯形‎，特例是曲边‎梯形。

如下图：（图1）设一元函数‎()y f x =,在区间内有‎[],a b 定义。

将区间分成‎[],a b n 个小区间[][][][]00112,,,,,......,i a x x x x x x b 。

设1i i i x x x -∆=-，取区间中曲‎i x ∆线上任意一‎点记做()i f ξ，作和式：()1lim n n i f i xi ξ→+∞=⎛⎫∆ ⎪⎝⎭∑ 若记λ为这‎些小区间中‎的最长者。

当0λ→时，若此和式的‎极限存在，则称这个和‎式是函数()f x 在区间上的‎[],a b 定积分。

记作：()ba f x dx ⎰其中称为积‎a 分下限，b 为积分上限‎，()f x 为被积函数‎，()f x dx 为被积式，∫ 为积分号。

之所以称其‎为定积分，是因为它积‎分后得出的‎值是确定的‎，是一个数，而不是一个‎函数。

21.2定积分的‎几何意义[1]它是介于x ‎轴、函数f(x)的图形及两‎条直线x=a ，x=b 之间的各 个部分面积‎的代数和。

在x 轴上方‎的面积取正‎号；在x 轴下方‎的面积取负‎号。

如图2.2言实现定‎积分计算的‎算法 22.1利用复合‎梯形公式实‎现定积分的‎计算假设被积函‎数为()f x ，积分区间为‎[],a b ，把区间等分‎[],a b 成个小区间‎n ，各个区间的‎长度为h ，即()/h b a n =-，称之为“步长”。

根据定积分‎的定义及几‎何意义，定积分就是‎求函数在区‎()f x 间中图线下‎[],a b 包围的面积‎。

几种定积分的数值计算方法

几种定积分的数值计算方法

几种定积分的数值计算方法数值计算定积分是计算定积分的一种近似方法，适用于无法通过代数方法求得精确解的定积分。

本文将介绍几种常见的数值计算定积分的方法。

1.矩形法（矩形逼近法）：矩形法是最简单的数值计算定积分方法之一、它将定积分区间划分为若干个小区间，然后在每个小区间上取一个样本点，将每个小区间上的函数值乘以小区间的宽度，得到小矩形的面积，最后将这些小矩形的面积相加即可得到定积分的近似值。

矩形法有两种主要的实现方式：左矩形法和右矩形法。

左矩形法使用每个小区间的左端点作为样本点，右矩形法则使用右端点。

2.梯形法（梯形逼近法）：梯形法是另一种常见的数值计算定积分方法。

它将定积分区间划分为若干个小区间，然后在每个小区间上取两个样本点，分别作为小区间的端点。

接下来，计算每个小区间上的函数值，然后将每个小区间上的函数值与两个端点连线所构成的梯形的面积相加，得到所有梯形的面积之和，最后得到近似的定积分值。

3.辛普森法：辛普森法是一种更为精确的数值计算定积分方法。

它将定积分区间分为若干个小区间，然后用二次多项式逼近每个小区间上的函数曲线。

在每个小区间上，辛普森法使用三个样本点，将函数曲线近似为一个二次多项式。

然后，对于每个小区间，计算该二次多项式所对应的曲线下梯形区域的面积，并将所有小区间的面积相加，得到近似的定积分值。

4. 龙贝格法（Romberg integration）：龙贝格法是一种迭代的数值计算定积分方法，通过进行多次计算，逐步提高近似的精确度。

龙贝格法首先使用梯形法或者辛普森法计算一个初始近似值，然后通过迭代的方式进行优化。

在每次迭代中，龙贝格法先将区间划分成更多的子区间，并在每个子区间上进行梯形法或者辛普森法的计算。

然后，利用这些计算结果进行Richardson外推，从而得到更精确的定积分近似值。

通过多次迭代，龙贝格法可以逐步提高逼近的精确度。

上述介绍的四种数值计算定积分的方法都有各自的优势和适用范围。

定积分计算的方法与技巧

定积分计算的方法与技巧

定积分计算的方法与技巧定积分是微积分的重要内容之一，用于计算曲线下方的面积、求平均值、求定积分等。

本文将介绍一些定积分计算的方法与技巧，包括基本积分公式、换元法、分部积分法、定积分的性质以及数值积分等。

一、基本积分公式在进行定积分计算时，掌握一些基本积分公式是非常重要的。

以下是一些常见的基本积分公式：- ∫kdx = kx + C （k为常数，C为常数）- ∫x^n dx = 1/(n+1) * x^(n+1) + C （n为非负整数，C为常数）- ∫e^x dx = e^x + C- ∫a^x dx = a^x/ln(a) + C （a>0且a≠1）- ∫sin(x) dx = -cos(x) + C- ∫cos(x) dx = sin(x) + C- ∫1/(1+x^2) dx = arctan(x) + C- ∫1/sqrt(1-x^2) dx = arcsin(x) + C二、换元法换元法是解决复杂定积分的有效方法之一、在进行换元法时，我们可以选择一个合适的变量替换，使得被积函数简化。

设有∫f(g(x))g'(x)dx，令u=g(x)，则dx=du/g'(x)，所以∫f(u)du 即可。

换元法的关键是选择合适的变量替换。

三、分部积分法分部积分法用于对乘积进行积分。

设有∫u(dv)，其中u为一个可微函数，dv为一个可积函数，根据分部积分法的公式：∫u(dv) = uv - ∫v(du)通过选择合适的u和dv，将原问题转化为求解形式更简单的积分。

如果最后的∫v(du)也可以通过分部积分法进一步解决，则可以多次应用该方法。

四、定积分的性质定积分具有一些重要的性质，可以帮助我们简化计算：- ∫[a,b] f(x) dx = -∫[b,a] f(x) dx （积分区间调换，结果取负值）- ∫[a,b] (f(x) + g(x)) dx = ∫[a,b] f(x) dx + ∫[a,b] g(x) dx （可加性）- ∫[a,b] k*f(x) dx = k*∫[a,b] f(x) dx （常数倍性）- 若f(x)在[a,b]上连续，则∫[a,b] f(x) dx = F(b) - F(a)，其中F(x)是f(x)的一个原函数五、数值积分当无法通过手算得到解析解时，可以使用数值积分的方法来求解定积分。

10个重要的算法C语言实现源代码：拉格朗日,牛顿插值,高斯,龙贝格

10个重要的算法C语言实现源代码：拉格朗日,牛顿插值,高斯,龙贝格

10个重要的算法C语言实现源代码：拉格朗日，牛顿插值，高斯，龙贝格~~关键字: 拉格朗日，牛顿插值，高斯，龙贝格1.拉格朗日插值多项式，用于离散数据的拟合C/C++ code#include <stdio.h>#include <conio.h>#include <alloc.h>float lagrange(float *x,float *y,float xx,int n) /*拉格朗日插值算法*/{ int i,j;float *a,yy=0.0; /*a作为临时变量，记录拉格朗日插值多项式*/ a=(float *)malloc(n*sizeof(float));for(i=0;i<=n-1;i++){ a[i]=y[i];for(j=0;j<=n-1;j++)if(j!=i) a[i]*=(xx-x[j])/(x[i]-x[j]);yy+=a[i];}free(a);return yy;}main(){ int i,n;float x[20],y[20],xx,yy;printf("Input n:");scanf("%d",&n);if(n>=20) {printf("Error!The value of n must in (0,20)."); getch();return 1;}if(n<=0) {printf("Error! The value of n must in (0,20)."); getch(); return 1;}for(i=0;i<=n-1;i++){ printf("x[%d]:",i);scanf("%f",&x[i]);}printf("\n");for(i=0;i<=n-1;i++){ printf("y[%d]:",i);scanf("%f",&y[i]);}printf("\n");printf("Input xx:");scanf("%f",&xx);yy=lagrange(x,y,xx,n);printf("x=%f,y=%f\n",xx,yy);getch();}2.牛顿插值多项式，用于离散数据的拟合C/C++ code#include <stdio.h>#include <conio.h>#include <alloc.h>void difference(float *x,float *y,int n){ float *f;int k,i;f=(float *)malloc(n*sizeof(float));for(k=1;k<=n;k++){ f[0]=y[k];for(i=0;i<k;i++)f[i+1]=(f[i]-y[i])/(x[k]-x[i]);y[k]=f[k];}return;}main(){ int i,n;float x[20],y[20],xx,yy;printf("Input n:");scanf("%d",&n);if(n>=20) {printf("Error! The value of n must in (0,20)."); getch(); return 1;}if(n<=0) {printf("Error! The value of n must in (0,20).");getch(); return 1;}for(i=0;i<=n-1;i++){ printf("x[%d]:",i);scanf("%f",&x[i]);}printf("\n");for(i=0;i<=n-1;i++){ printf("y[%d]:",i);scanf("%f",&y[i]);}printf("\n");difference(x,(float *)y,n);printf("Input xx:");scanf("%f",&xx);yy=y[20];for(i=n-1;i>=0;i--) yy=yy*(xx-x[i])+y[i]; printf("NewtonInter(%f)=%f",xx,yy);getch();}3.高斯列主元消去法,求解奇次线性方程组C/C++ code#include<stdio.h>#include <math.h>#define N 20int main(){ int n,i,j,k;int mi,tmp,mx;float a[N][N],b[N],x[N];printf("\nInput n:");scanf("%d",&n);if(n>N){ printf("The input n should in(0,N)!\n");getch();return 1;}if(n<=0){ printf("The input n should in(0,N)!\n");getch();return 1;}printf("Now input a(i,j),i,j=0...%d:\n",n-1); for(i=0;i<n;i++){ for(j=0;j<n;j++)scanf("%f",&a[i][j]);}printf("Now input b(i),i,j=0...%d:\n",n-1); for(i=0;i<n;i++)scanf("%f",&b[i]);for(i=0;i<n-2;i++){ for(j=i+1,mi=i,mx=fabs(a[i][j]);j<n-1;j++) if(fabs(a[j][i])>mx){ mi=j;mx=fabs(a[j][i]);}if(i<mi){ tmp=b[i];b[i]=b[mi];b[mi]=tmp;for(j=i;j<n;j++){ tmp=a[i][j];a[i][j]=a[mi][j];a[mi][j]=tmp;}}for(j=i+1;j<n;j++){ tmp=-a[j][i]/a[i][i];b[j]+=b[i]*tmp;for(k=i;k<n;k++)a[j][k]+=a[i][k]*tmp;}}x[n-1]=b[n-1]/a[n-1][n-1];for(i=n-2;i>=0;i--){ x[i]=b[i];for(j=i+1;j<n;j++)x[i]-=a[i][j]*x[j];x[i]/=a[i][i];}for(i=0;i<n;i++)printf("Answer:\n x[%d]=%f\n",i,x[i]); getch();return 0;}#include<math.h>#include<stdio.h>#define NUMBER 20#define Esc 0x1b#define Enter 0x0dfloat A[NUMBER][NUMBER+1] ,ark;int flag,n;exchange(int r,int k);float max(int k);message();main(){float x[NUMBER];int r,k,i,j;char celect;clrscr();printf("\n\nUse Gauss.");printf("\n\n1.Jie please press Enter.");printf("\n\n2.Exit press Esc.");celect=getch();if(celect==Esc)exit(0);printf("\n\n input n=");scanf("%d",&n);printf(" \n\nInput matrix A and B:");for(i=1;i<=n;i++){printf("\n\nInput a%d1--a%d%d and b%d:",i,i,n,i);for(j=1;j<=n+1;j++) scanf("%f",&A[i][j]); }for(k=1;k<=n-1;k++){ark=max(k);if(ark==0){printf("\n\nIt's wrong!");message();}else if(flag!=k)exchange(flag,k);for(i=k+1;i<=n;i++)for(j=k+1;j<=n+1;j++)A[i][j]=A[i][j]-A[k][j]*A[i][k]/A[k][k];}x[n]=A[n][n+1]/A[n][n];for( k=n-1;k>=1;k--){float me=0;for(j=k+1;j<=n;j++){me=me+A[k][j]*x[j];}x[k]=(A[k][n+1]-me)/A[k][k];}for(i=1;i<=n;i++){printf(" \n\nx%d=%f",i,x[i]);}message();}exchange(int r,int k){int i;for(i=1;i<=n+1;i++)A[0][i]=A[r][i];for(i=1;i<=n+1;i++)A[r][i]=A[k][i];for(i=1;i<=n+1;i++)A[k][i]=A[0][i];}float max(int k){int i;float temp=0;for(i=k;i<=n;i++)if(fabs(A[i][k])>temp){temp=fabs(A[i][k]);flag=i;}return temp;}message(){printf("\n\n Go on Enter ,Exit press Esc!");switch(getch()){case Enter: main();case Esc: exit(0);default:{printf("\n\nInput error!");message();} }}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.00001float 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 ;}}}C/C++ code5.牛顿迭代公式，求方程的近似解C/C++ code#include<stdio.h>#include<math.h>#include<conio.h>#define N 100#define PS 1e-5#define TA 1e-5float Newton(float (*f)(float),float(*f1)(float),float x0 ) { float x1,d=0;int k=0;do{ x1= x0-f(x0)/f1(x0);if((k++>N)||(fabs(f1(x1))<PS)){ printf("\nFailed!");getch();exit();}d=(fabs(x1)<1?x1-x0:(x1-x0)/x1);x0=x1;printf("x(%d)=%f\n",k,x0);}while((fabs(d))>PS&&fabs(f(x1))>TA) ;return x1;}float f(float x){ return x*x*x+x*x-3*x-3; }float f1(float x){ return 3.0*x*x+2*x-3; }void main(){ float f(float);float f1(float);float x0,y0;printf("Input x0: ");scanf("%f",&x0);printf("x(0)=%f\n",x0);y0=Newton(f,f1,x0);printf("\nThe root is x=%f\n",y0);getch();}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;elsenn=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);elseprintf("\n Wrong!Return code=%d\n",ntf);getch();}7.雅克比迭代，求解方程近似解C/C++ code#include <stdio.h>#include <math.h>#define N 20#define MAX 100#define e 0.00001int main(){ int n;int i,j,k;float t;float a[N][N],b[N][N],c[N],g[N],x[N],h[N];printf("\nInput dim of n:"); scanf("%d",&n);if(n>N){ printf("Faild! Check if 0<n<N!\n"); getch(); return 1; } if(n<=0){printf("Faild! Check if 0<n<N!\n"); getch(); return 1;} printf("Input a[i,j],i,j=0…%d:\n",n-1);for(i=0;i<n;i++)for(j=0;j<n;j++)scanf("%f",&a[i][j]);printf("Input c[i],i=0…%d:\n",n-1);for(i=0;i<n;i++)scanf("%f",&c[i]);for(i=0;i<n;i++)for(j=0;j<n;j++){ b[i][j]=-a[i][j]/a[i][i]; g[i]=c[i]/a[i][i]; } for(i=0;i<MAX;i++){ for(j=0;j<n;j++)h[j]=g[j];{ for(k=0;k<n;k++){ if(j==k) continue; h[j]+=b[j][k]*x[k]; } }t=0;for(j=0;j<n;j++)if(t<fabs(h[j]-x[j])) t=fabs(h[j]-x[j]);for(j=0;j<n;j++)x[j]=h[j];if(t<e){ printf("x_i=\n");for(i=0;i<n;i++)printf("x[%d]=%f\n",i,x[i]);getch();return 0;}printf("after %d repeat , return\n",MAX);getch();return 1;}getch();}8.秦九昭算法C/C++ code#include <math.h>float qin(float a[],int n,float x){ float r=0;int i;for(i=n;i>=0;i--)r=r*x+a[i];return r;}main(){ float a[50],x,r=0;int n,i;do{ printf("Input frequency:");scanf("%d",&n);}while(n<1);printf("Input value:");for(i=0;i<=n;i++)scanf("%f",&a[i]);printf("Input frequency:");scanf("%f",&x);r=qin(a,n,x);printf("Answer:%f",r);getch();}9.幂法C/C++ code#include<stdio.h>#include<math.h>#define N 100#define e 0.00001#define n 3float x[n]={0,0,1};float a[n][n]={{2,3,2},{10,3,4},{3,6,1}};float y[n];main(){ int i,j,k;float xm,oxm;oxm=0;for(k=0;k<N;k++){ for(j=0;j<n;j++){ y[j]=0;for(i=0;i<n;i++)y[j]+=a[j][i]*x[i];}xm=0;for(j=0;j<n;j++)if(fabs(y[j])>xm) xm=fabs(y[j]);for(j=0;j<n;j++)y[j]/=xm;for(j=0;j<n;j++)x[j]=y[j];if(fabs(xm-oxm)<e){ printf("max:%f\n\n",xm);printf("v[i]:\n");for(k=0;k<n;k++) printf("%f\n",y[k]);break;}oxm=xm;}getch();}10.高斯塞德尔C/C++ code#include<math.h>#include<stdio.h>#define N 20#define M 99float a[N][N];float b[N];int main(){ int i,j,k,n;float sum,no,d,s,x[N];printf("\nInput dim of n:");scanf("%d",&n);if(n>N){ printf("Faild! Check if 0<n<N!\n "); getch();return 1;}if(n<=0){ printf("Faild! Check if 0<n<N!\n ");getch();return 1;} printf("Input a[i,j],i,j=0…%d:\n",n-1);for(i=0;i<n;i++)for(j=0;j<n;j++)scanf("%f",&a[i][j]);printf("Input b[i],i=0…%d:\n",n-1);for(i=0;i<n;i++) scanf("%f",&b[i]);for(i=0;i<n;i++) x[i]=0;k=0;printf("\nk=%dx=",k);for(i=0;i<n;i++) printf("%12.8f",x[i]);do{ k++;if(k>M){printf("\nError!\n”);getch();}break;}no=0.0;for(i=0;i<n;i++){ s=x[i];sum=0.0;for(j=0;j<n;j++)if (j!=i) sum=sum+a[i][j]*x[j];x[i]=(b[i]-sum)/a[i][i];d=fabs(x[i]-s);if (no<d) no=d;}printf("\nk=%2dx=",k);for(i=0;i<n;i++) printf("%f",x[i]); }while (no>=0.1e-6);if(no<0.1e-6){ printf("\n\n answer=\n");printf("\nk=%d",k);for (i=0;i<n;i++)printf("\n x[%d]=%12.8f",i,x[i]);}getch();}。

  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

C语言实验报告求定积分班级10信息与计算科学一班姓名戴良伟学号 211.描述问题 利用①左矩形公式，②中矩形公式，③右矩形公式 ，④梯形公式，⑤simpson 公式，⑥Gauss 积分公式求解定积分。

2. 分析问题定积分定积分的定义定积分就是求函数()f x 在区间[],a b 中图线下包围的面积。

即()0,,,y x a x b y f x ====所包围的面积。

这个图形称为曲边梯形，特例是曲边梯形。

如下图：（图1）设一元函数()y f x =,在区间[],a b 内有定义。

将区间[],a b 分成n 个小区间[][][][]00112,,,,,......,i a x x x x x x b 。

设1i i i x x x -∆=-，取区间i x ∆中曲线上任意一点记做()i f ξ，作和式：()1lim n n i f i xi ξ→+∞=⎛⎫∆ ⎪⎝⎭∑ 若记λ为这些小区间中的最长者。

当0λ→时，若此和式的极限存在，则称这个和式是函数()f x 在区间[],a b 上的定积分。

记作：()ba f x dx ⎰ 其中称a 为积分下限，b 为积分上限，()f x 为被积函数，()f x dx 为被积式，∫ 为积分号。

之所以称其为定积分，是因为它积分后得出的值是确定的，是一个数，而不是一个函数。

定积分的几何意义[1]它是介于x 轴、函数f(x)的图形及两条直线x=a ，x=b 之间的各个部分面积的代数和。

在x 轴上方的面积取正号；在x 轴下方的面积取负号。

如图言实现定积分计算的算法利用复合梯形公式实现定积分的计算假设被积函数为()f x ，积分区间为[],a b ，把区间[],a b 等分成n 个小区间，各个区间的长度为h ，即()/h b a n =-，称之为“步长”。

根据定积分的定义及几何意义，定积分就是求函数()f x 在区间[],a b 中图线下包围的面积。

将积分区间n 等分，各子区间的面积近似等于梯形的面积，面积的计算运用梯形公式求解，再累加各区间的面积，所得的和近似等于被积函数的积分值，n 越大，所得结果越精确。

以上就是利用复合梯形公式实现定积分的计算的算法思想。

复合梯形公式：()()()1122n n i i h T f a f x f b -=⎛⎫=++ ⎪⎝⎭∑[2] 具体算法如下：算法一1：输入积分区间的端点值a 和b ；2：输入区间的等分个数n （要求n 尽可能大，以保证程序运行结果有较高的精确度）；3：计算步长()/h b a n =-；4：对累加和赋初值()/2a b T f f =-；5：计算累加和()11n i i T f x -==∑6：算出积分值n T T h =⨯；7：输出积分近似值n T ，完毕。

1.2.2利用Smpson 公式实现定积分的计算假设被积函数为()f x ，积分区间为[],a b ，把区间[],a b 等分成n 个小区间，各个区间的长度为h 。

在复合梯形公式的基础上，构造出一种加速计算积分的方法。

作为一种外推算法， 它在不增加计算量的前提下提高了误差的精度。

具体算法如下：算法二1：输入积分上限b 和下限a ；2：输入区间的等分个数n （要求n 尽可能大，以保证程序运行结果有较高的精确度）；3：利用辛甫生公式：[][][]()42/3S n T n T n =⨯-[2]，实现对定积分的求解（其中[]2T n ，[]T n 均为梯形公式计算所得的结果，由此可见辛甫生公式是以梯形公式为基础的）；4：算出积分值S n ；5：输出积分近似值S，完毕。

n利用Guass公式实现定积分计算Guass型求积公式是构造高精度差值积分的最好方法之一。

他是通过让节点和积分系数待定让函数f(x)以此取i=0,1,2....n次多项式使其尽可能多的能够精确成立来求出积分节点和积分系数。

高斯积分的代数精度是2n-1，而且是最高的。

通常运用的是-1---+1的积分节点和积分系数，其他积分域是通过变换x=(b-a)t/2 +(a+b)/2 变换到-1到1之间积分。

算法三1：输入积分上限b和下限a；2：利用Guass公式，求定积分；4：算出积分值Sn5：输出积分近似值S，完毕。

n3.程序的编写程序一（左矩形公式）源程序#include<>#include<>void main(){double f(double x);/*f(x)为函数举例，即被积函数*/int i,n;/*n为区间等分的个数，应尽可能大*/double a,b,h,s;/*a为积分下限，b为积分上限，h为步长*/printf("积分下限 a:\n");scanf("%lf",&a);printf("积分上限 b:\n");scanf("%lf",&b);printf("区间等分个数 n :\n");scanf("%d",&n);h=(b-a)/n; /*步长的计算*/s=f(a)*h;for(i=1;i<n;i++){s=s+f(a+i*h)*h;}printf("函数 f(x) 的积分值为 s=%\n",s);}/*以下为被积函数的定义，即函数举例*/ double f(double x){double y;y=sqrt(4-x*x);return (y);}程序一的编译运行被积函数为f(x)=sqrt4-(x*x)的情况先编译，再运行，屏幕显示及操作如下：输入0+回车输入2+回车输入1000+回车程序二（中矩形公式）源程序#include<>#include<>void main(){double f(double x);/*f(x)为函数举例，即被积函数*/int i,n;/*n为区间等分的个数，应尽可能大*/ double a,b,h,s;/*a为积分下限，b为积分上限，h为步长*/ printf("积分下限 a:\n");scanf("%lf",&a);printf("积分上限 b:\n");scanf("%lf",&b);printf("区间等分个数 n :\n");scanf("%d",&n);h=(b-a)/n; /*步长的计算*/s=*(f(a)+f(a+h))*h;for(i=1;i<n;i++){s=s+*(f(a+i*h)+f(a+(i+1)*h))*h;}printf("函数 f(x) 的积分值为 s=%\n",s); }/*以下为被积函数的定义，即函数举例*/ double f(double x){double y;y=sqrt(4-x*x);return (y);}程序二的编译运行被积函数为f(x)=sqrt4-(x*x)的情况先编译，再运行，屏幕显示及操作如下：输入0+回车输入2+回车输入1000+回车程序三（右矩形公式）源程序#include<>#include<>void main(){double f(double x);/*f(x)为函数举例，即被积函数*/int i,n;/*n为区间等分的个数，应尽可能大*/ double a,b,h,s;/*a为积分下限，b为积分上限，h为步长*/ printf("积分下限 a:\n");scanf("%lf",&a);printf("积分上限 b:\n");scanf("%lf",&b);printf("区间等分个数 n :\n");scanf("%d",&n);h=(b-a)/n; /*步长的计算*/s=f(a+h)*h;for(i=1;i<n-1;i++){s=s+f(a+(i+1*h))*h;}printf("函数 f(x) 的积分值为 s=%\n",s); }/*以下为被积函数的定义，即函数举例*/ double f(double x){double y;y=sqrt(4-x*x);return (y);}程序三的编译运行被积函数为f(x)=sqrt4-(x*x)的情况先编译，再运行，屏幕显示及操作如下：输入0+回车输入2+回车输入1000+回车程序四（梯形公式）源程序#include<>#include<>void main(){double f(double x);/*f(x)为函数举例，即被积函数*/int i,n;/*n为区间等分的个数，应尽可能大*/ double a,b,h,s;/*a为积分下限，b为积分上限，h为步长*/ printf("积分下限 a:\n");scanf("%lf",&a);printf("积分上限 b:\n");scanf("%lf",&b);printf("区间等分个数 n :\n");scanf("%d",&n);h=(b-a)/n; /*步长的计算*/s=*(f(a)+f(a+h))*h;for(i=1;i<n;i++){s=s+*(f(a+i*h)+f(a+(i+1)*h))*h;}printf("函数 f(x) 的积分值为 s=%\n",s); }/*以下为被积函数的定义，即函数举例*/ double f(double x){double y;y=sqrt(4-x*x);return (y);}程序四的编译运行被积函数为f(x)=sqrt4-(x*x)的情况先编译，再运行，屏幕显示及操作如下：输入0+回车输入2+回车输入1000+回车程序五（Simpson公式）源程序#include<>#include<>void main(){double T(double x,double y,int z); double a,b,s;int n;printf("积分下限 a:\n");scanf("%lf",&a);printf("积分上限 b:\n");scanf("%lf",&b);printf("区间等分个数 n :\n");scanf("%d",&n);s=(4*T(a,b,2*n)-T(a,b,n))/3;/*利用辛甫生公式求解定积分*/printf("函数 f(x) 的积分值为 s=%f\n",s);/*以下为复合梯形公式的定义*/double T(double x,double y,int z) {double h,Tn;int i;double f(double t);h=(y-x)/z;Tn=(f(x)+f(y))/2;for(i=1;i<z;i++)Tn=Tn+f(x+i*h);Tn=Tn*h;return (Tn);}/*以下为被积函数的定义，即函数举例*/ double f(double t){double s;s=sqrt(4-t*t);return (s);}程序四的编译运行被积函数为f(x)=sqrt4-(x*x)的情况先编译，再运行，屏幕显示及操作如下：输入0+回车输入2+回车输入1000+回车程序六（Guass公式）源程序#include <>#include <>#define N 3float gass_integral(float (*)(float),float,float,int); void main(){float function_name(float);float a,b;printf("请输入积分上限b\n");scanf("%f",&b);printf("请输入积分下限a\n");scanf("%f",&a);float ans;ans=gass_integral(function_name,a,b,N);printf("ans=%f",ans);}-1---+1 之间float gass_integral(float (*func)(float x), float a,float b ,int n ){左矩形公式误差：%，中矩形公式误差：%，右矩形公式误差：%，梯形公式误差：%，辛普森公式和高斯公式误差几乎等于0，六个程序运行结果对比，在计算相同的函数f(x)=sqrt(4-x*x)的定积分，Simpson公式和Guass公式比矩形和梯形公式更可行，更有效。

相关文档
最新文档