龙贝格求积分Word格式文档下载.docx

龙贝格求积分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）;