雅克比迭代法文档格式.docx
《雅克比迭代法文档格式.docx》由会员分享，可在线阅读，更多相关《雅克比迭代法文档格式.docx（17页珍藏版）》请在冰豆网上搜索。
un+1=un+hf（tn,un）
欧拉隐式方法：
改进的Euler公式
n+1=yn+hf（xn,yn）
yn+1=yn+
[f（xn,yn）+f（xn+1,
n+1）]
三、主要仪器设备及耗材
WindowsXpVC++6.0
第二部分：
实验调试与结果分析
一、调试过程
Jacobi迭代法
#include<
stdio.h>
#defineN10
floatABS（float,float）;
int
main（void）
{
inti,j,n;
floata[N][N],b[N];
floatx[N],y[N];
floate,total;
printf（"
Pleaseinputthedimension:
"
）;
scanf（"
%d"
&
n）;
PleaseinputtheCoefficientMatrix:
"
for（i=0;
i<
n;
i++）
for（j=0;
j<
j++）
%f"
a[i][j]）;
PleaseinputtheVector:
b[i]）;
Pleaseinputtheinitialvector:
x[i]）;
do
{
total=0.0f;
if（i!
=j）
total+=a[i][j]*x[j];
}
y[i]=（b[i]-total）/a[i][i];
e=0.0f;
e=e+ABS（x[j],y[j]）;
printf（"
%f\n"
e）;
x[i]=y[i];
while（e>
0.0001）;
x%d=%f\t"
i,x[i]）;
\n"
return0;
}
floatABS（floatx,floaty）
inttotal;
if（x<
y）total=y-x;
elsetotal=x-y;
returntotal;
}
结果：
流程图：
Gauss-Seidel迭代法
#include<
intmain（）
doublex[3]={0,0,0};
doublea[3][3]={6,2,-1,1,4,-2,-3,1,4};
doubley[3]={-3,2,4};
doubled[3][3],g[3];
intround=5,i,j;
for（i=0;
i<
3;
++i）
g[i]=y[i]/a[i][i];
for（j=0;
j<
++j）
d[i][j]=i==j?
0:
-a[i][j]/a[i][i];
while（round--）{
x[i]=g[i];
x[i]+=d[i][j]*x[j];
%lf"
x[i]）;
结果：
超松弛因子迭代法
iostream>
cmath>
usingnamespacestd;
float*one_array_malloc（intn）;
float**two_array_malloc（intm,intn）;
floatmatrix_category（float*x,intn）;
intmain（）{constintMAX=100;
intn,i,j,k;
float**a;
float*x_0;
float*x_k;
floatprecision;
floatw;
cout<
<
输入精度e:
;
cin>
>
precision;
cout<
endl<
输入系数矩阵的阶数，N：
cin>
n;
a=two_array_malloc（n,n+1）;
输入增广矩阵的各值：
for（i=0;
i<
i++）
{
for（j=0;
j<
n+1;
j++）
{cin>
a[i][j];
}
x_0=one_array_malloc（n）;
输入初始向量:
for（i=0;
i++）
x_0[i];
x_k=one_array_malloc（n）;
输入松弛因子w（1<
w<
2）：
w;
floattemp;
for（k=0;
k<
MAX;
k++）
{for（i=0;
{temp=0;
i;
{temp=temp+a[i][j]*x_k[j];
x_k[i]=a[i][n]-temp;
temp=0;
for（j=i+1;
{temp=temp+a[i][j]*x_0[j];
x_k[i]=（x_k[i]-temp）/a[i][i];
x_k[i]=（1-w）*x_0[i]+w*x_k[i];
{x_0[i]=x_k[i]-x_0[i];
if（matrix_category（x_0,n）<
precision）
{break;
else{for（i=0;
{x_0[i]=x_k[i];
if（MAX==k）
{cout<
迭代不收敛\n"
迭代次数为：
endl;
解向量为：
x"
:
x_k[i]<
float*one_array_malloc（intn）
{float*a;
a=（float*）malloc（sizeof（float）*n）;
returna;
float**two_array_malloc（intm,intn）
{float**a;
inti;
a=（float**）malloc（m*sizeof（float*））;
m;
{a[i]=（float*）malloc（n*sizeof（float））;
floatmatrix_category（float*x,intn）
{inti;
floattemp=0;
{temp=temp+fabs（x[i]）;
returntemp;
三角分解法
constintN=100;
staticdoublea[N][N],b[N];
inti,j,k,num,p;
doublem,t,q;
请输入矩阵阶数：
num;
//输入a[i][j],b[i]
nowinputthematrixa[i][j],i,j=1..."
num<
:
for（i=1;
=num;
for（j=1;
j++）
cout<
a["
]["
]="
nowinputthematrixb[i],i=1..."
b["
b[i];
t=0;
for（i=1;
m=0;
for（j=i;
=num+1;
for（k=1;
=i-1;
k++）
m=m+a[i][k]*a[k][j];
a[i][j]=a[i][j]-m;
t=t+a[j][k]*a[k][i];
a[j][i]=（a[j][i]-t）/a[i][i];
a[num][num+1]=a[num][num+1]/a[num][num];
q=0;
for（k=num-1;
k>
=1;
k--）
for（j=k+1;
q=q+a[k][j]*a[j][num+1];
a[k][num+1]=（a[k][num+1]-q）/a[k][k];
方程组的解为：
x["
a[i][num+1]<
欧拉显式方法
conio.h>
math.h>
doublef（doublex,doubley）
{
returnx*pow（y,1.0/3）;
intmain（）
inti;
doublex,y,y0=1,dx=0.1;
doublexx[11];
doubleeuler[11],euler_2[11];
doubletemp;
doublef（doublex,doubley）;
for（i=0;
11;
xx[i]=i*dx;
euler[0]=y0;
for（i=1,x=0;
i++,x+=dx）
euler[i]=euler[i-1]+dx*f（x,euler[i-1]）;
euler_2[0]=y0;
temp=euler_2[i-1]+dx*f（x,euler_2[i-1]）;
euler_2[i]=euler_2[i-1]+dx*（f（x,euler_2[i-1]）+f（x+dx,temp））/2;
for（i=0,x=0;
printf（"
x=%lf\teluer=%lf\teuler_2=%lf\taccu=%lf\n"
x,euler[i],euler_2[i],pow（1+x*x,1.0/3））;
getch（）;
欧拉隐式方法
#definef（x,y）（x+y）
{intm;
doublea,b,y0;
doublexn,yn,xn1,yn1,yn1b;
doubleh;
\nInputthebeginandendofx:
scanf（"
%lf%lf"
&
a,&
b）;
Inputtheyvalueat%f:
a）;
y0）;
Inputmvalue[divide（%f,%f）]:
a,b）;
m）;
if（m<
=0）
{printf（"
Pleaseinputanumberlargerthan1.\n"
return
（1）;
h=（b-a）/m;
xn=a;
yn=y0;
=m;
{xn1=xn+h;
yn1b=yn+h*f（xn,yn）;
yn1=yn+h/2*（f（xn,yn）+f（xn1,yn1b））;
x%d=%f,y%d=%f\n"
i,xn1,i,yn1）;
xn=xn1;
yn=yn1;
}return（0）;
二、实验结果及分析
雅克比迭代法的全部分量都是间接利用，由于新值比旧值好，Gauss-Seidel迭代法直接对算出的分量加以使用，这样使得迭代的收敛情况有所改善，而超松弛法是在Gauss-Seidel迭代法的基础上，应用加速收敛思想而构造的一种方法；
欧拉公式和梯形公式在计算上有明显的区别，欧拉公式的特点是可以有UN直接计算Un+1，也就是显式的，而梯形公式右端也有Un+1,必须通过解方程才能求得，这类是隐式的。
从算法的角度看显式远比隐式方便，隐式通常用迭代法求解。
三、实验小节、建议及体会
任何一种方法都有它的优点和局限性，只有找到一种方法能够解决我们的问题，又尽量减少出错，减少计算量就是符合这个问题的好方法。
良好的编程习惯有助于检查错误，也可以增强程序的可阅读性。
（范文素材和资料部分来自网络，供参考。
可复制、编制，期待你的好评与关注）
升级会员 