龙贝格求积分Word格式文档下载.docx
《龙贝格求积分Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《龙贝格求积分Word格式文档下载.docx（14页珍藏版）》请在冰豆网上搜索。
由梯形公式得
T1=1/2[f（0）+f
（1）]=3
计算f（1/2）=16/5用变步长梯形公式得
T2=1/2[T1+f（1/2）]=3.1
由加速公式得
S1=1/3（4T2-T1）=3.133333333
求出f（1/4）f（3/4）进而求得
T4=1/2{T2+1/2[f（1/4）+f（3/4）]}
=3.131176471
S2=1/3（4T4-T2）=3.141568628
C1=1/15（16S2-S1）=3.142117648
计算f（1/8）f（3/8）f（5/8）f（7/8）进而求得
T8=1/2{T4+1/4[f（1/8）+f（3/8）+f（5/8）+f（7/8）]}
=3.138988495
S4=1/3（4T3-T4）=3.141592503
C2=1/15（16S4-S2）=3.141594095
R1=1/63（64C2-C1）=3.141585784
把区间再二分，重复上述步骤算得
T16=3.140941613S8=3.141592652
C4=3.141592662R2=3.141592640
程序步骤
1.输入积分上线
2.输入积分下线
3.输入区间等分数
4.输入要求的函数
5.计算出所求函数的积分，分别是
●复化梯形求积结果
●辛普森求积结果
●科特斯求积结果
●龙贝格求积结果
流程图
源程序
//MyTask.cpp:
Definestheentrypointfortheconsoleapplication.
//
#include"
stdafx.h"
math.h"
#include<
stdlib.h>
#defineIS_INT（x）（（x）==int（（x）*10/10））
voidfuHuaTiXing（intk,inta,intb）;
//复化梯形求积里面T1跟T2
doublef（doublex）;
//原函数sinx/x
doublefuHuaTiXing（intk,doubley,inta,intb）;
doubleleiJia（inta,intb,inti）;
//复化梯形求积里面的累加
voidsimpson（intk）;
//k代表要计算的simpson的个数
voidcotes（intk）;
//k>
=3
voidromberg（intk）;
doubleTTT[512]={0.0};
doubleTT[128]={0.0};
doubleS[64]={0.0};
doubleC[32]={0.0};
doubleR[16]={0.0};
intflag;
intmain（intargc,char*argv[]）
{
inta,b,k;
//a积分下线b积分上限k等分数
//k最大支持256等分
int_k;
doubleresult;
intloop_k;
intg_quit=0;
intg_quit1=0;
//欢迎界面
printf（"
\t\t****************************************************\n"
）;
欢迎使用RomBerg方法计算积分\n"
本程序支持最小4等分最大256等分\n"
想继续运行吗，继续请按1，退出请按0\n"
scanf（"
%d"
&
g_quit）;
if（1==g_quit）
{
while
（1）
{
printf（"
pleaseinput3numberswhitchmeansthreeconstent.\n"
pleaseinputthefirstnumberwhitchmeans积分下限\n"
getchar（）;
scanf（"
a）;
pleaseinputthesecondnumberwhitchmeans积分上限\n"
b）;
pleaseinputthethirdnumberwhitchmeans等分数\n\t\t\t\t\t注意:
支持4等分到256等分\n\t\t\t\t\t注意:
一定是2的整数幂\n"
k）;
//
if（4==（int）k）
{
_k=2;
}
elseif（8==（int）k）
_k=3;
elseif（16==（int）k）
_k=4;
elseif（32==（int）k）
_k=5;
elseif（64==（int）k）
_k=6;
elseif（128==（int）k）
_k=7;
elseif（256==（int）k）
_k=8;
}
else
printf（"
您输入的等分区间不是2的整数幂,请重新输入!
\n\n"
getchar（）;
continue;
aaaaa:
pleaseselectthefunctionoff（x）.\n"
ifyouwanttochosefunction1（pow（x,2）*sin（x））pleaseinput1;
\n"
ifyouwanttochosefunction2（sin（x）*cos（x））pleaseinput2;
ifyouwanttochosefunction3（sin（x）*sin（x）*x）pleaseinput3;
ifyouwanttochosefunction4（sin（x）/x）pleaseinput4.\n"
flag）;
if（flag==1||flag==2||flag==3||flag==4）
//null
else
Youhaveinputedwrongnum!
\nPleasetryagain!
\n\n\n"
gotoaaaaa;
fuHuaTiXing（_k,a,b）;
simpson（_k）;
cotes（_k）;
romberg（_k）;
outputfuHuaTiXing（复化梯形）result.\n"
for（loop_k=0;
loop_k<
=_k;
loop_k++）
TT%d=%.14f\n"
（int）pow（2,loop_k）,TT[loop_k]）;
outputsimpsonresult.\n"
=_k-1;
S%d=%.14f\n"
（int）pow（2,loop_k）,S[loop_k]）;
outputcotesresult.\n"
=_k-2;
C%d=%.14f\n"
outputrombergresult.\n"
=_k-3;
R%d=%.14f\n"
（int）pow（2,loop_k）,R[loop_k]）;
继续计算请按1，退出请按0\n"
g_quit1）;
if（0==g_quit1）
exit（0）;
}
}
else
exit（0）;
return0;
}
doublef（doublex）//原函数sinx/x
doubleresult_f;
switch（flag）
case1:
result_f=pow（x,2）*sin（x）;
return（result_f）;
break;
case2:
result_f=sin（x）*cos（x）;
case3:
result_f=sin（x）*sin（x）*x;
case4:
result_f=sin（x）;
if（x!
=0）
result_f=result_f/x;
return（result_f）;
elsereturn1.0;
default:
break;
voidfuHuaTiXing（intk,inta,intb）//复化梯形求积里面T1跟T2
intloop_i;
doubleresult_b_a;
result_b_a=double（b-a）/2;
for（loop_i=0;
loop_i<
=k;
loop_i++）//k>
inttemp;
if（loop_i==0）//kmeanszhishu
TT[0]=result_b_a*（f（a）+f（b））;
//代表T1
else
temp=pow（2,loop_i）;
TT[loop_i]=TT[loop_i-1]/2+（（double）（b-a）/（temp））*leiJia（a,b,loop_i）;
for（loop_i=0;
loop_i<
10;
loop_i++）
TTT[loop_i]=TT[loop_i];
//把局部数组转存到全局数组中方便下面的访问
doubleleiJia（inta,intb,inti）//复化梯形求积里面的累加
intloop_m;
doubleresult_leijia=0.0;
inttemp;
doubletemp1,temp2;
switch（i）
loop_m=（int）pow（2,（i-1））;
case5:
case6:
default:
for（loop_i=1;
=loop_m;
loop_i++）
temp=pow（2,i）;
temp1=（double）（a+（2*loop_i-1）*（（double）（b-a）/temp））;
//temp2=f（temp1）;
result_leijia=result_leijia+f（temp1）;
//第一次temp1=0.5
return（result_leijia）;
//求simpson
voidsimpson（intk）//k代表要计算的ximpson的个数
intloop_i=0,loop_j=0;
for（loop_i=0;
=k-1;
S[loop_i]=（4*TT[loop_i+1]-TT[loop_i]）/3;
voidcotes（intk）
=k-2;
C[loop_i]=（16*S[loop_i+1]-S[loop_i]）/15;
voidromberg（intk）
=k-3;
R[loop_i]=（pow（4,3）*C[loop_i+1]-C[loop_i]）/（pow（4,3）-1）;
升级会员 