Question

用C语言计算微积分？

可以的话举一些例子！！！

Answer 1

我给一楼加的注释以及修改：
#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能有所突破！！

Answer 2

#include <stdio.h>

#include <math.h>

#include <time.h>

int main()
{
    int n = 0;
    
    double x, y = 0.0, result = 0.0, a, b;
    
    printf("请输入积分区间 a,b:");
    
    scanf("[%lf,%lf]",&a,&b);
    
	clock();
	
    for(x = a ; x <= b ; x += 1E-7)    //这里可调控结果精度
    {
        y += (x*x*asin(x)+1)/sqrt(1-x*x) ;//这里可任意修改为自己需要的积分方程
        n++;
    }
    
    result = ( (b-a)/n ) * y;
    
    printf("y = (x*x*asin(x)+1)/sqrt(1-x*x) 在积分区间[%.2lf,%.2lf]上的结果为:%.7lf\n运行时间:%.4f s\n",a,b,result,(double)clock()/CLOCKS_PER_SEC);
    
    return 0;
}

基本上普通的积分都能求，就是算法并不好（就是最基本的矩形法求和，也称黎曼求和），循环次数太多耗时

Answer 3

通过黎曼和解定积分既是把y曲线下方面积划分成无数矩形，矩形数量越多，得出的面积越精确

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

int main()
{
float function1(float);
float function2(float);

float function3(float);
void integration(float f(float),float,float); //求定积分公式
integration(function1,1,0);
integration(function2,1,-1);
integration(function3,2,0);

}

void integration(float f(float),float a,float b) //f(float)，f(x)。float a，float b，区间两点
{
float x,t2=0; //t2,矩形总面积
float n=1000; //n值越大，精确值越高
float h; //矩形宽度
float t1=0; //单个矩形面积
h=(a-b)/n;
//矩形宽度为面积总长度除以矩形个数
for(float i=1;i<=1000;i++) //计算每个矩形的面积
{
x=b+h*i; //通过i的变化，得出每个矩形底部x的值
t1=f(x)*h; //用x做实参调用函数进一步求出y值，既矩形的高度，底乘高得出面积
t2=t2+t1; //各个矩形面积相加
}
printf("the value of function is %f",t2);

}

float function1(float x)
{
float y;
y=sin(x);
return y;
}

float function2(float x)
{
float y;
y=cos(x);
return y;
}

float function3(float x)
{
float y;
y=exp(x);
return y;
}

Answer 4

#include(stdio.h)
#include(math.h)
void main()
{
int i,n;
float x(10001),y(10001);
float x0,xn,h,J;
/*f=x^3*/
printf("input x0,xn,n:");
scanf("%f",&x0);
scanf("%f",&xn);
scanf("%d",&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);
}
J=0.0;
for(i=0;i<n;i++)
{
J=J+y(i)+y(i+1);
}
J=J*h/2.0;
printf("n");
printf("n=%d JiFen is %f",n,J);
}

Answer 5

我给一楼加的注释以及修改：
#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能有所突破！！