数值计算方法实验报告.docx
《数值计算方法实验报告.docx》由会员分享，可在线阅读，更多相关《数值计算方法实验报告.docx（35页珍藏版）》请在冰豆网上搜索。
数值计算方法实验报告
本科实验报告
课程名称：
数值计算方法
实验地点：
计算机科学与技术学院506
专业班级：
学号：
学生姓名：
******
年月日
太原理工大学学生实验报告
学院名称
计算机科学与技术
专业班级
学号
学生姓名
实验日期
成绩
课程名称
数值计算方法
实验题目
实验一方程求解
一、实验目的和要求
熟悉使用、迭代法、牛顿法、割线法等方法对给定的方程进行根的求解。
选择上述方法中的两种方法求方程：
二分法f（x）=x3+4x2-10=0在[1,2]内的一个实根，且要求满足精度|x*-xn|<0.5×10-5
二、主要设备
PC，Windows操作系统，VC++6.0编程平台；
三、实验内容和原理
函数f（x）在区间（x，y）上连续，先在区间（x，y）确定a与b，若f（a），f（b）异号，说明在区间（a，b）内存在零点，然后求f[（a+b）/2]。
假设F（a）<0,F（b）>0,a1如果f[（a+b）/2]=0，该点即为零点；
2如果f[（a+b）/2]<0，则区间（（a+b）/2，b）内存在零点，（a+b）/2≥a；
3如果f[（a+b）/2]>0，则区间（a,（a+b）/2）内存在零点，（a+b）/2≤b；
返回①重新循环，不断接近零点。
通过每次把f（x）的零点所在区间收缩一半的方法，使区间内的两个端点逐步逼近函数零点，最终求得零点近似值。
四、操作方法与实验步骤
1.二分法：
#include
#include
#include
intmain（）
{
doublea=1.0,b=2.0;
doublex,s;
while
（1）
{
x=（a+b）/2;
s=pow（x,3）+4*x*x-10;
if（-0.000005{
break;
}
elseif（s<0）
{
a=x;
}
elseif（s>0）
{
b=x;
}
printf（"%f\t%f\n",a,b）;
}
printf（"%f\n",x）;
printf（"%f\n",s）;
return0;
}
2.割线法：
#include"stdio.h"
#include"math.h"
intmain（）
{
floatc,a=1.0,b=2.0;
while
（1）
{
c=b-（b*b*b+4*b*b-10）*（b-a）/（b*b*b+4*b*b-（a*a*a+4*a*a））;
if（fabs（b-c）<0.5*0.00001）break;
b=c;
printf（"%f\n",b）;
}
printf（"%f\n",c）;
}
五、实验结果与分析
二分法割线法
分析：
使用二分法和割线法均能计算出方程的根，但利用割线法要比二分法计算的次数少，并且能够较早的达到精度要求。
并且割线法程序代码量较少，精简明了。
六、讨论、心得
本次数值计算方法程序设计实验是在不断的习题练习中跳脱出来，直接面对实用性较强的程序代码编写。
效果很好，不仅加深对二分法、割线法的理解，还加强了实际用运能力。
将理论成功地转化成实践结果。
实验地点
北区多学科综合楼4506
指导教师
王峥
太原理工大学学生实验报告
学院名称
计算机科学与技术
专业班级
学号
学生姓名
实验日期
成绩
课程名称
数值计算方法
实验题目
实验二线性方程组的直接解法
一、实验目的和要求
合理利用Gauss消元法、LU分解法、追赶法求解下列方程组：
1
2
3
1
2
3
4
（n=5,10,100,…）
二、主要设备
PC，Windows操作系统，VC++6.0编程平台；
三、实验内容和原理
高斯消元法：
将原方程组化为三角形方阵的方程组：
lik=aik/akk
aij=aij-lik*akj
（k=1,2,…,n-1i=k+1,k+2,…,nj=k+1,k+2,…,n+1）
由回代过程求得原方程组的解：
xn=ann+1/ann
xk=（akn+1-∑akjxj）/akk
完全主元素消元法流程图：
列主元素消元法：
LU分解法：
将系数矩阵A转化为A=L*U，L为单位下三角矩阵，U为普通上三角矩阵，然后通过解方程组l*y=b，u*x=y,来求解x。
四、操作方法与实验步骤
1.完全主元素消元法：
#include
#include
#include"math.h"
floata[100][101];
floatx[10];
intN;
voidshuchu（）
{
for（inti=1;i<=N;i++）
{
for（intj=1;j<=N+1;j++）
{
cout<}
cout<}
}
voidinitdata（）
{
cout<<"请输入矩阵阶数:
"<cin>>N;
cout<<"请输入矩阵各项:
"<for（inti=1;i<=N;i++）
for（intj=1;j<=N+1;j++）
{
cin>>a[i][j];
}
cout<}
voidmain（）
{
intz[10];
intmaxi,maxj;
initdata（）;
for（inti=1;i<=N;i++）
z[i]=i;
for（intk=1;k{
maxi=k;maxj=k;floatmaxv=abs（a[k][k]）;
for（i=k;i<=N;i++）
for（intj=k;j<=N;j++）
if（abs（a[i][j]）>maxv）
{
maxv=abs（a[i][j]）;maxi=i;maxj=j;
}
if（maxi!
=k）
{
for（intj=1;j<=N+1;j++）
{
floatt=a[k][j];a[k][j]=a[maxi][j];a[maxi][j]=t;
}
}
if（maxj!
=k）
{
for（i=1;i<=N;i++）
{
floatt=a[i][k];a[i][k]=a[i][maxj];a[i][maxj]=t;
}
intt=z[k];z[k]=z[maxj];z[maxj]=t;
}
for（inti=k+1;i<=N;i++）
{
floatl=a[i][k]/a[k][k];
for（intj=k;j<=N+1;j++）
{
a[i][j]+=-l*a[k][j];
}
}
}
for（i=N;i>0;i--）
{
floats=0;
for（intj=i+1;j<=N;j++）
{
s+=a[i][j]*x[z[j]];
}
x[z[i]]=（a[i][N+1]-s）/a[i][i];
}
cout<<"完全主元素消去法之后的矩阵为：
"<shuchu（）;
for（i=1;i<=N;i++）
cout<<"x["<}
2.列主元素消元法：
#include"stdio.h"
intmain（）
{
floata[3][4]={{1,2,3,14},{0,1,2,8},{2,4,1,13}};
floatx[3];
floatsum=0;
intk,i,j;
for（k=0;k<2;k++）
for（i=k+1;i<3;i++）
for（j=k+1;j<4;j++）
a[i][j]=a[i][j]-a[i][k]/a[k][k]*a[k][j];
for（i=0;i<3;i++）
{
for（j=0;j<4;j++）
{
printf（"a[%d][%d]=%f",i,j,a[i][j]）;
}
printf（"\n"）;
}
x[2]=a[2][3]/a[2][2];
for（k=1;k>=0;k--）
{
sum=0;
for（j=k+1;j<3;j++）
{
sum+=a[k][j]*x[j];
}
x[k]=（a[k][3]-sum）/a[k][k];
}
for（i=0;i<3;i++）
{
printf（"x[%d]=%f\n",i+1,x[i]）;
}
printf（"\n"）;
}
3.LU分解法：
#include
#include
#defineL30
doublea[L][L],b[L],l[L][L],u[L][L],x[L],y[L];
intmain（）
{
intn,i,j,k,r;
printf（"请输入矩阵元次：
\n"）;
scanf（"%d",&n）;
printf（"请输入矩阵各项：
\n"）;
for（i=1;i<=n;++i）
{
for（j=1;j<=n;++j）
{
scanf（"%lf",&a[i][j]）;
}
}
printf（"请输入方程组的常数项：
\n"）;
for（i=1;i<=n;++i）
{
scanf（"%lf",&b[i]）;
}
for（i=1;i<=n;++i）
{
for（j=1;j<=n;++j）
{
l[i][j]=0;
u[i][j]=0.0;
}
}
for（k=1;k<=n;++k）
{
for（j=k;j<=n;++j）
{
u[k][j]=a[k][j];
for（r=1;r{
u[k][j]-=l[k][r]*u[r][j];
}
}
for（i=k+1;i<=n;++i）
{
l[i][k]=a[i][k];
for（r=1;r{
l[i][k]-=l[i][r]*u[r][k];
}
l[i][k]/=u[k][k];
}
l[k][k]=1.0;
}
for（i=1;i<=n;++i）
{
y[i]=b[i];
for（j=1;j{
y[i]-=l[i][j]*y[j];
}
}
for（i=n;i>0;--i）
{
x[i]=y[i];
for（j=i+1;j<=n;++j）
{
x[i]-=u[i][j]*x[j];
}
x[i]/=u[i][i];
}
for（i=1;i<=n;++i）
{
printf（"%0.2lf\n",x[i]）;
}
return0;
}
五、实验结果与分析
完全主元素消元法：
列主元素消元法：
LU分解法：
分析：
对于两种高斯解方程，完全主元素跟列主元素都是先消元、再回代，由程序段可以发现，始终消去对角线下方的元素。
即，为了节约内存及时效，可以不必计算出主元素下方数据。
列主元素消元法的算法设计上优于完全主元素消元法，它只需依次按列选主元素然后换行使之变到主元素位置，再进行消元即可。
列主元素消元法的耗时比完全主元素法少很多，常采用之。
对于LU分解法，分解矩阵为单位下三角阵L与上三角阵U的乘积，然后解方程组Ly=b，回代，解方程组Ux=y。
其中的L为n阶单位下三角阵、U为上三角阵.
六、讨论、心得
本次试验中，感觉是最难的一次，完全主元素消元法程序编写过程相对来说花了好长时间。
纠正各种语法、算法、思路错误。
最后勉强成功，但还是有几处警告，不得解决之法。
感到程序学习的不足，再加之对高斯的不甚了解。
编写过程很是痛苦。
查阅各种内外部资料，这点有利有弊。
突然觉得，应该再把数据结构之类的重新学习一下才行。
以后多花时间在编程吧，重在理解。
必须反省一下自己的C、C++学习了，还是得多加练习，平时养成好的算法思路，免得再次不知所措。
实验地点
北区多学科综合楼4506
指导教师
王峥
太原理工大学学生实验报告
学院名称
计算机科学与技术
专业班级
学号
学生姓名
实验日期
成绩
课程名称
数值计算方法
实验题目
实验三线性方程组的迭代解法
一、实验目的和要求
使用雅可比迭代法或高斯-赛德尔迭代法对下列方程组进行求解。
二、主要设备
PC，Windows操作系统，VC++6.0编程平台；
三、实验内容和原理
设线性方程组Ax=b
的系数矩阵A可逆，且主对角元素a11,a22,…,ann均不为零，令
D=diag（a11,a22,…,ann）
并将A分解成A=（A-D）+D
从而线性方程组可写成Dx=（D-A）x+b
则有迭代公式
x（k+1）=B1x（k）+f1
其中，B1=I-D-1A,f1=D-1b。
各自详细流程图如下所示：
四、操作方法与实验步骤
高斯—赛德尔迭代法
#include"iostream"
#include"iomanip"
usingnamespacestd;
intmain（）
{
inti,j,k=0,m,n;
doublet1,t2,e1,e2=0.0;
cout<<"请输入精度e：
";
cin>>e1;
cout<<"请输入系数矩阵行数：
";
cin>>m;
cout<<"请输入系数矩阵列数：
";
cin>>n;
cout<double（**a）=newdouble*[m];//生成二维动态数组
for（i=0;i<=m;i++）
{
a[i]=newdouble[n];
}
double（*b）=newdouble[m];
double（*x）=newdouble[n];
cout<<"请输入系数矩阵：
"<cout<<"-------------------------------------------------------------"<for（intnum1=0;num1{
for（intnum2=0;num2{
cin>>a[num1][num2];
}
cout<}
cout<<"输入的系数矩阵为：
"<for（intnum3=0;num3{
for（intnum4=0;num4{
cout<}
cout<}
cout<<"-------------------------------------------------------------"<cout<<"请输入矩阵b：
"<cout<<"-------------------------------------------------------------"<for（intnum5=0;num5{
cin>>b[num5];
}
cout<<"输入的矩阵b为：
"<for（intnum6=0;num6{
cout<}
cout<cout<<"------------------------------------------------------------"<for（intnum7=0;num7{
x[num7]=0.0000;
}
do
{
cout<<"第"<";
e2=0.0;
for（i=0;i{
doublesum=0.0;
for（j=0;j{
if（j!
=i）
sum+=a[i][j]*x[j];
}
t1=x[i];
t2=e2;
x[i]=（b[i]-sum）/a[i][i];
e2=（x[i]）-t1>=0?
（x[i]）-t1:
t1-（x[i]）;
e2=（e2>=t2?
e2:
t2）;
cout<}
cout<k++;
}while（e2>=e1&&k<30）;
cout<<"共迭代了"<delete[]a;
delete[]b;
delete[]x;
return0;
}
雅克比迭代法：
#include
#include
intmain（）
{
floata[3][3]={{10,-1,-2},{-1,10,-2},{-1,-1,5}},b[3]={7.2,8.3,4.2};
floatx[3]={0,0,0},sum;
inti,j,k,n=3;
for（k=0;k<10;k++）
{
for（i=0;i<3;i++）
{
sum=0;
for（j=0;j{
if（i==j）continue;
sum=sum+a[i][j]*x[j];
}
x[i]=（b[i]-sum）/a[i][i];
}
for（i=0;i{
printf（"x[%d]=%f\t",i+1,x[i]）;}
printf（"\n"）;
}
}
五、实验结果与分析
高斯赛德尔迭代法：
雅克比迭代：
分析：
使用高斯-赛德尔和雅克比迭代都可以求出方程组的解，但是利用高斯-赛德尔迭代法所需的迭代次数比雅克比迭代少，能够更早的达到精度要求。
从程序中可以看出，雅克比定义的sum只有一个，而高斯赛德尔需要两个。
时效性上后者要好些。
六、讨论、心得
这次试验算是比较成功，要归功于授课时候的认真听讲。
程序编写之前，对书本的理论知识进行了进一步的探索。
预习准备工作很彻底，自然随后的一切也都很顺利。
好好学习，好好编程，好好思考。
希望，有所成。
实验地点
北区多学科综合楼4506
指导教师
王峥
太原理工大学学生实验报告
学院名称
计算机科学与技术
专业班级
学号
学生姓名
实验日期
成绩
课程名称
数值计算方法
实验题目
实验四矩阵特征值与特征向量问题
一、实验目的和要求
使用幂法求A模为最大的特征值及其相应的特征向量。
二、主要设备
PC，Windows操作系统，VC++6.0编程平台；
三、实验内容和原理
幂法：
由已知的非零向量x0和矩阵A的乘幂构造向量序列{xn}以计算矩阵A的按模最大特征值及其特征向量的方法，称为幂法。
在计算过程，每步迭代中把向量xk进行规范化，即用xk乘以一个常数，使得其分量的模最大为1，这样，迭代公式变为：
其中，mk是yk模最大的第一个分量。
结果可取：
幂法流程图：
四、操作方法与实验步骤
#include
#include
#defineN3
#defineeps1e-6
#defineM30
floatmaxvalue（floatx[],intn）
{
floatMax=x[0];
inti;
for（i=1;iif（fabs（x[i]）>fabs（Max））
Max=x[i];
returnMax;
}
voidmatrix（float*A）
{
floatU[N],V[N],r1,r2,temp;
inti,j,k=0;
for（i=0;iU[i]=1;
while（k{
k++;
for（i=0;i{
temp=0;
for（j=0;jtemp+=*（A+i*N+j）*U[j];
V[i]=temp;
}
for（i=0;iU[i]=V[i]/maxvalue（V,N）;
if（k==1）
r1=maxvalue（V,N）;
else
r2=maxvalue（V,N）;
if（fabs（r2-r1）r1=r2;
}
printf（"迭代次数：
\t%d\n",k）;
printf（"矩阵的特征值：
\t%f\n",r2）;
printf（"（"）;
for（i=0;iprintf（"%f\t",U[i]）;
printf（"）\n"）;
}
intmain（）
{
floatA[N][N]={{2,-1,0},{-1,2,-1},{0,-1,2}};
matrix（A[0]）;
}
五、实验结果与分析
分析：
幂方法求解矩阵的最大特征值以及特征向量，最大优点是计算简单，容易在计算机上实现，对稀疏矩阵较为适合。
但有时收敛速度很慢。
六、讨论、心得
程序编写时详细分析了书上的求解过程，但最终结果还是有所出入。
课本的迭代次数只用7次，而程序运行之后显示为12次。
不明白那里原因。
推测是由于精确位数的不同导致。
最后在程序中更改了一下，验证得之。
知识转化为“所
升级会员 