东北大学数值分析实验报告
数值分析实验报告
数值分析实验报告【引言】数值分析是一门研究利用计算机和数学方法解决实际问题的学科，它在工程、科学和经济领域中有着广泛的应用。
在这个实验报告中，我将分享我在数值分析实验中的一些发现和结果。
【实验目的】本次实验的目的是通过数值方法对给定的问题进行求解，并分析数值方法的精确性和稳定性。
我们选择了经典的插值和数值积分问题来进行实验。
【实验过程】在插值问题中，我使用了拉格朗日插值和样条插值两种方法。
通过使用已知的数据点，这些方法能够通过构造多项式函数来逼近原始函数，从而能够在未知点上进行预测。
通过比较两种插值方法的结果，我发现拉格朗日插值在低维数据上表现更好，而样条插值在高维数据上更能保持插值曲线的平滑性。
在数值积分问题中，我使用了复合梯形公式和复合辛普森公式来进行数值积分。
这两种方法可以将复杂的区间上的积分问题转化为对若干个小区间进行数值积分的问题。
实验结果表明，复合辛普森公式在使用相同的步长时，其数值积分结果更为精确。
【实验结果】我以一个实际问题作为例子来展示实验结果。
问题是计算半径为1的圆的面积。
通过离散化的方法，我将圆划分为多个小的扇形区域，并使用数值积分方法计算每个扇形的面积。
最后将每个扇形的面积相加，即可得到圆的近似面积。
通过调整离散化的精度，我发现随着扇形数量的增加，计算得到的圆的面积越接近真实的圆的面积。
在插值问题中，我选择了一段经典的函数进行插值研究。
通过选择不同的插值节点和插值方法，我发现当插值节点越密集时，插值结果越接近原函数。
同时，样条插值方法在高阶导数连续的情况下能够更好地逼近原始函数。
【实验总结】通过这次实验，我对数值分析中的插值和数值积分方法有了更深入的理解。
我了解到不同的数值方法在不同的问题中有着不同的适用性和精确度。
在实际应用中，我们需要根据具体问题选择合适的数值方法，并进行必要的数值计算和分析，以获得准确可靠的结果。
总的来说，数值分析作为一种重要的工具和方法，在科学研究和工程实践中具有广泛的应用，并且不断发展和创新。
数值分析综合实验报告
一、实验目的通过本次综合实验，掌握数值分析中常用的插值方法、方程求根方法以及数值积分方法，了解这些方法在实际问题中的应用，提高数值计算能力。
二、实验内容1. 插值方法（1）拉格朗日插值法：利用已知数据点构造多项式，以逼近未知函数。
（2）牛顿插值法：在拉格朗日插值法的基础上，通过增加基函数，提高逼近精度。
2. 方程求根方法（1）二分法：适用于函数在区间内有正负值的情况，通过不断缩小区间来逼近根。
（2）Newton法：利用函数的导数信息，通过迭代逼近根。
（3）不动点迭代法：将方程转化为不动点问题，通过迭代逼近根。
3. 数值积分方法（1）矩形法：将积分区间等分，近似计算函数值的和。
（2）梯形法：将积分区间分成若干等分，用梯形面积近似计算积分。
（3）辛普森法：在梯形法的基础上，将每个小区间再等分，提高逼近精度。
三、实验步骤1. 拉格朗日插值法（1）输入已知数据点，构造拉格朗日插值多项式。
（2）计算插值多项式在未知点的函数值。
2. 牛顿插值法（1）输入已知数据点，构造牛顿插值多项式。
（2）计算插值多项式在未知点的函数值。
3. 方程求根方法（1）输入方程和初始值。
（2）选择求解方法（二分法、Newton法、不动点迭代法）。
（3）迭代计算，直到满足精度要求。
4. 数值积分方法（1）输入被积函数和积分区间。
（2）选择积分方法（矩形法、梯形法、辛普森法）。
（3）计算积分值。
四、实验结果与分析1. 插值方法（1）拉格朗日插值法：通过构造多项式，可以较好地逼近已知数据点。
（2）牛顿插值法：在拉格朗日插值法的基础上，增加了基函数，提高了逼近精度。
2. 方程求根方法（1）二分法：适用于函数在区间内有正负值的情况，计算简单，但收敛速度较慢。
（2）Newton法：利用函数的导数信息，收敛速度较快，但可能存在数值不稳定问题。
（3）不动点迭代法：将方程转化为不动点问题，收敛速度较快，但可能存在初始值选择不当的问题。
3. 数值积分方法（1）矩形法：计算简单，但精度较低。
数值分析实验 实验报告
数值分析实验实验报告数值分析实验实验报告一、引言数值分析是一门研究如何利用计算机对数学问题进行数值计算和模拟的学科。
在实际应用中，数值分析广泛应用于工程、物理、金融等领域。
本实验旨在通过实际操作，探索数值分析方法在实际问题中的应用，并通过实验结果对比和分析，验证数值分析方法的有效性和可靠性。
二、实验目的本实验的主要目的是通过数值分析方法，解决一个实际问题，并对比不同方法的结果，评估其准确性和效率。
具体来说，我们将使用牛顿插值法和拉格朗日插值法对一组给定的数据进行插值，并对比两种方法的结果。
三、实验步骤1. 收集实验数据：我们首先需要收集一组实验数据，这些数据可以来自实验测量、调查问卷等方式。
在本实验中，我们假设已经获得了一组数据，包括自变量x和因变量y。
2. 牛顿插值法：牛顿插值法是一种基于差商的插值方法。
我们可以通过给定的数据点，构造一个插值多项式，并利用该多项式对其他点进行插值计算。
具体的计算步骤可以参考数值分析教材。
3. 拉格朗日插值法：拉格朗日插值法是另一种常用的插值方法。
它通过构造一个满足给定数据点的多项式，利用该多项式对其他点进行插值计算。
具体的计算步骤也可以参考数值分析教材。
4. 结果比较与分析：在完成牛顿插值法和拉格朗日插值法的计算后，我们将比较两种方法的结果，并进行分析。
主要考虑的因素包括插值误差、计算效率等。
四、实验结果在本实验中，我们选取了一组数据进行插值计算，并得到了牛顿插值法和拉格朗日插值法的结果。
经过比较和分析，我们得出以下结论：1. 插值误差：通过计算插值点与实际数据点之间的差值，我们可以评估插值方法的准确性。
在本实验中，我们发现牛顿插值法和拉格朗日插值法的插值误差都较小，但是拉格朗日插值法的误差稍大一些。
2. 计算效率：计算效率是衡量数值分析方法的重要指标之一。
在本实验中，我们发现牛顿插值法的计算速度较快，而拉格朗日插值法的计算速度稍慢。
五、实验结论通过本实验，我们对数值分析方法在实际问题中的应用有了更深入的了解。
数值分析积分实验报告(3篇)
第1篇一、实验目的本次实验旨在通过数值分析的方法，研究几种常见的数值积分方法，包括梯形法、辛普森法、复化梯形法和龙贝格法，并比较它们在计算精度和效率上的差异。
通过实验，加深对数值积分理论和方法的理解，提高编程能力和实际问题解决能力。
二、实验内容1. 梯形法梯形法是一种基本的数值积分方法，通过将积分区间分割成若干个梯形，计算梯形面积之和来近似积分值。
实验中，我们选取了几个不同的函数，对积分区间进行划分，计算积分近似值，并与实际积分值进行比较。
2. 辛普森法辛普森法是另一种常见的数值积分方法，它通过将积分区间分割成若干个等距的区间，在每个区间上使用二次多项式进行插值，然后计算多项式与x轴围成的面积之和来近似积分值。
实验中，我们对比了辛普森法和梯形法的计算结果，分析了它们的精度差异。
3. 复化梯形法复化梯形法是对梯形法的一种改进，通过将积分区间分割成多个小区间，在每个小区间上使用梯形法进行积分，然后计算所有小区间积分值的和来近似积分值。
实验中，我们对比了复化梯形法和辛普森法的计算结果，分析了它们的精度和效率。
4. 龙贝格法龙贝格法是一种通过外推加速提高计算精度的数值积分方法。
它通过比较使用不同点数（n和2n）的积分结果，得到更高精度的积分结果。
实验中，我们使用龙贝格法对几个函数进行积分，并与其他方法进行了比较。
三、实验步骤1. 编写程序实现梯形法、辛普森法、复化梯形法和龙贝格法。
2. 选取几个不同的函数，对积分区间进行划分。
3. 使用不同方法计算积分近似值，并与实际积分值进行比较。
4. 分析不同方法的精度和效率。
四、实验结果与分析1. 梯形法梯形法在计算精度上相对较低，但当积分区间划分足够细时，其计算结果可以接近实际积分值。
2. 辛普森法辛普森法在计算精度上优于梯形法，但当积分区间划分较细时，计算量较大。
3. 复化梯形法复化梯形法在计算精度上与辛普森法相当，但计算量较小。
4. 龙贝格法龙贝格法在计算精度上优于复化梯形法，且计算量相对较小。
东北大学数值分析实验报告
数值分析实验报告课题一 迭代格式的比较一、问题提出设方程f(x3- 3x –1=0 有三个实根 x *1=1.8793 , x *2=-0.34727 ,x *3=-1.53209现采用下面三种不同计算格式，求 f(x)=0的根 x *1 或x *21、 x =213x x + 2、 x = 313-x3、 x = 313+x二、要求1、编制一个程序进行运算，最后打印出每种迭代格式的敛散情况；2、用事后误差估计k k x x -+1〈ε来3、初始值的选取对迭代收敛有何影响；4、分析迭代收敛和发散的原因。
三、目的和意义1、通过实验进一步了解方程求根的算法；2、认识选择计算格式的重要性；3、掌握迭代算法和精度控制；4、明确迭代收敛性与初值选取的关系。
程序代码：#include<iostream> #include<math.h>int k=1,k1=1,k2=1,k3=1; float x1,x2,x3;float one(float x0) {x1=(3*x0+1)/(x0*x0); return(x1); }float two(float x0) {x2=(pow(x0,3)-1)/3; return(x2); }float three(float x0) {x3=pow(3*x0+1,0.33333); return(x3); }main() {float x,x0;printf("输入x0=");scanf("%f",&x);x0=x;x1=one(x0);printf("第一个公式迭代结果: \n");while(fabs(x0-x1)>1e-5){printf("x1=%6.5f\n",x1);x0=x1;x1=one(x0);k1++;}printf("x1=%6.5f \n",x1);printf("k1=%i\n",k1);x0=x;x2=two(x0);printf("第二个公式迭代结果: \n"); while(fabs(x0-x2)>1e-5){printf("x2=%6.5f\n",x2);x0=x2;x2=two(x0);k2++;}printf("k2=%i\n",k2);x0=x;x3=three(x0);printf("第三个公式迭代结果: \n");while(fabs(x0-x3)>1e-5){printf("x3=%6.5f\n",x3);x0=x3;x3=three(x0);k3++;}printf("x3=%6.5f\n",x3);printf("k3=%i\n",k3);scanf("%");}实验结果：四、程序运行结果讨论和分析：对于第一种迭代格式，收敛区间[-8.2 -0.4]，在该收敛区间内迭代收敛于-1.53209，只能求得方程的一个根；对于第二种迭代格式，收敛区间[-1.5 1.8]，在该收敛区间内迭代收敛于-0.34730，同样只能求得方程的一个根；对于第三种迭代格式，收敛区间[-0.3 +∞)，在该收敛区间内迭代收敛于 1.87937，只能求得方程的一个根；由以上结果很容易发现，初值的选取对迭代敛散性有很大影响。
数值分析实验报告5篇
1.69376699767424 0.92310666706964 0.08471614569741 0.40804026409411
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
讨论：
利用这种方法进行这类实验，可以很精确的扰动敏感性的一般规律。即 当对扰动项的系数越来越小时，对其多项式扰动的结果也就越来越小， 即扰动敏感性与扰动项的系数成正比，扰动项的系数越大，对其根的扰 动敏感性就越明显，当扰动的系数一定时，扰动敏感性与扰动的项的幂 数成正比，扰动的项的幂数越高，对其根的扰动敏感性就越明显。
解线性方程组的直接方法
实验 （主元的选取与算法的稳定性） 问题提出：Gauss消去法是我们在线性代数中已经熟悉的。但由于计算 机的数值运算是在一个有限的浮点数集合上进行的，如何才能确保 Gauss消去法作为数值算法的稳定性呢？Gauss消去法从理论算法到数值 算法，其关键是主元的选择。主元的选择从数学理论上看起来平凡，它 却是数值分析中十分典型的问题。 实验内容：考虑线性方程组 编制一个能自动选取主元，又能手动选取主元的求解线性方程组的 Gauss消去过程。 实验要求： （1）取矩阵，则方程有解。取n=10计算矩阵的条件数。让程序自动选 取主元，结果如何？ （2）现选择程序中手动选取主元的功能。每步消去过程总选取按模最 小或按模尽可能小的元素作为主元，观察并记录计算结果。若每步消去 过程总选取按模最大的元素作为主元，结果又如何？分析实验的结果。 （3）取矩阵阶数n=20或者更大，重复上述实验过程，观察记录并分析 不同的问题及消去过程中选择不同的主元时计算结果的差异，说明主元
数值分析实验报告
数值分析实验报告实验目的：通过对数值分析实验的进行，掌握牛顿法解方程的根的求解过程和方法，通过编程实现牛顿法。
实验原理：牛顿法是一种迭代法，通过不断迭代逼近根的过程来求解方程的根。
假设f(x)在[x_0,x]中连续且有一阶连续导数，则根据泰勒展开公式，有下面的公式成立：f(x)=f(x_0)+f'(x_0)(x-x_0)+R(x)其中f(x)是方程的函数，f'(x_0)是f(x)在x_0处的导数，R(x)是无穷小量。
当x接近于x_0时，可以忽略R(x)的影响，即认为R(x)足够小可以忽略。
假设x_0是方程的一个近似根，可以得到如下的迭代公式：x_1=x_0-f(x_0)/f'(x_0)x_2=x_1-f(x_1)/f'(x_1)...在迭代的过程中，如果迭代的结果与上一次迭代的结果的误差小于设定的阈值，则可以认为找到了方程的根。
实验步骤：1.确定方程和初始近似根x_0。
2.计算f(x_0)和f'(x_0)。
3.使用迭代公式计算x的近似值x_i，直到满足终止条件（比如误差小于设定的阈值）。
4.输出计算得到的方程的根。
实验结果和分析：在实验中，我们选择了方程f(x)=x^2-2作为实验对象，初始近似根选择为x_0=1根据上述的迭代公式，可以依次计算得到x_1=1.5,x_2=1.4167,x_3=1.4142，直到满足终止条件。
通过实验计算，可以得到方程f(x)=x^2-2的两个根为x=-1.4142和x=1.4142，与理论解x=±√2比较接近，说明牛顿法可以有效地求解方程的根。
总结：通过本次实验，掌握了牛顿法解方程根的原理和实现方法，实验结果与理论解相近，验证了牛顿法的有效性。
在实际应用中，牛顿法常用于求解非线性方程和优化问题，具有较高的精度和收敛速度，但在选择初始近似根时需要谨慎，否则可能会导致迭代结果发散。
《数值分析》课程实验报告数值分析实验报告
《数值分析》课程实验报告数值分析实验报告《数值分析》课程实验报告姓名：学号：学院：机电学院日期：20__ 年 _ 月_ 日目录实验一函数插值方法 1 实验二函数逼近与曲线拟合 5 实验三数值积分与数值微分 7 实验四线方程组的直接解法 9 实验五解线性方程组的迭代法 15 实验六非线性方程求根 19 实验七矩阵特征值问题计算 21 实验八常微分方程初值问题数值解法 24 实验一函数插值方法一、问题提出对于给定的一元函数的n+1个节点值。
试用Lagrange公式求其插值多项式或分段二次Lagrange插值多项式。
数据如下：（1） 0.4 0.55 0.65 0.80 0.95 1.05 0.41075 0.57815 0.69675 0.90 1.00 1.25382 求五次Lagrange多项式，和分段三次插值多项式，计算, 的值。
（提示：结果为, ）（2） 1 2 3 4 5 6 7 0.368 0.135 0.050 0.018 0.007 0.002 0.001 试构造Lagrange多项式，计算的,值。
（提示：结果为, ）二、要求 1、利用Lagrange插值公式编写出插值多项式程序；2、给出插值多项式或分段三次插值多项式的表达式；3、根据节点选取原则，对问题（2）用三点插值或二点插值，其结果如何；4、对此插值问题用Newton插值多项式其结果如何。
Newton 插值多项式如下：其中：三、目的和意义 1、学会常用的插值方法，求函数的近似表达式，以解决其它实际问题；2、明确插值多项式和分段插值多项式各自的优缺点；3、熟悉插值方法的程序编制；4、如果绘出插值函数的曲线，观察其光滑性。
四、实验步骤（1） 0.4 0.55 0.65 0.80 0.951.05 0.41075 0.57815 0.69675 0.90 1.00 1.25382 求五次Lagrange多项式，和分段三次插值多项式，计算, 的值。
数值分析实验报告1
p
得到m=(00)T
即M0=0 ;M1=;M2=;M3=;M4=0
则根据三次样条函数定义，可得：
S(x)=
接着，在Command Window里输入画图的程序代码，
下面是画牛顿插值以及三次样条插值图形的程序：
x=[ ];
y=[ ];
plot(x,y)
hold on
for i=1:1:5
y(i)= *(x(i)*(x(i)*(x(i)*(x(i)*(x(i)*(x(i)*(x(i)
Pn=f(x0)+f[x0,x1](x-x0)+ f[x0,x1,x2](x-x0) (x-x1)+···+ f[x0,x1，···xn](x-x0) ···(x-xn-1)
我们要知道牛顿插值多项式的系数，即均差表中得部分均差。
在MATLAB的Editor中输入程序代码，计算牛顿插值中多项式系数的程序如下：
【实验原理】
《数值分析》第二章“插值法”的相关内容，包括：牛顿多项式插值，三次样条插值，拉格朗日插值的相应算法和相关性质。
【实验环境】（使用的软硬件）
软件：
MATLAB 2012a
硬件：
电脑型号：联想 Lenovo 昭阳E46A笔记本电脑
操作系统：Windows 8 专业版
处理器：Intel（R）Core（TM）i3 CPU M 350 @
实验内容：
【实验方案设计】
第一步，将书上关于三种插值方法的内容转化成程序语言，用MATLAB实现；第二步，分别用牛顿多项式插值，三次样条插值，拉格朗日插值求解不同的问题。
【实验过程】（实验步骤、记录、数据、分析）
实验的主要步骤是：首先分析问题，根据分析设计MATLAB程序，利用程序算出问题答案，分析所得答案结果，再得出最后结论。
东北大学数值分析实验报告
数值分析实验班级 姓名 学号实验环境: MATLAB实验一 解线性方程组的迭代法（1）一、实验题目 对以下方程组分别采用Jacobi 迭代法, Gaaus-Seidel 迭代法求解和SOR 迭代法求解。
（2）线性方程组⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡--------------------------13682438141202913726422123417911101610352431205362177586832337616244911315120130123122400105635680000121324⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡10987654321x x x x x x x x x x =⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡-2119381346323125 （2）对称正定线性方程组⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡----------------------1924336021411035204111443343104221812334161206538114140231212200420424⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡87654321x x x x x x x x =⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡---4515221123660（3）三对角线性方程组⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡------------------4100000000141000000001410000000014100000000141000000001410000000014100000000141000000001410000000014⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡10987654321x x x x x x x x x x =⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡----5541412621357 二、实验要求（1）应用迭代法求线性方程组, 并与直接法作比较。
东北大学数值分析实验报告
实验一：解线性方程组的直接方法1、设线性方程组⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡--------------------------13682438141202913726422123417911101610352431205362177586832337616244911315120130123122400105635680000121324⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡10987654321x x x x x x x x x x =⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡-2119381346323125x *= (-1, 0, 1, 2, 0, 3, 1, -1, 2 )T2、设对称正定阵系数阵线方程组⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡----------------------192433621411035204111443343104221812334161206538114140231212200420424⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡87654321x x x x x x x x = ⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡---4515229232060 x * = ( 1, -1, 0, 2, 1, -1, 0, 2 )T3、三对角形线性方程组⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡------------------41141000000001410000000014100000000141000000001410000000014100000000141000000001410000000014⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡10987654321x x x x x x x x x x = ⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡----5541412621357 x *= ( 2, 1, -3, 0, 1, -2, 3, 0, 1, -1 )T分别用Gauss 顺序消去法与Gauss 列主元消去法：平方根法与改进平方根法：追赶法求解，编出算法通用程序用列主元消去法求解方程组一： 流程图如下：源程序：#include < iostream >#include < vector >#include < cmath >using namespace std;class CGAUSSSOLVEEQU{private :vector < vector < double >> m_equset; vector < double > m_answer;int m_n;public :void inputEquSet(double in[],int n); void solveEquSet();void outputAnswer();void change(int m,int m2);} ;void CGAUSSSOLVEEQU::inputEquSet(double in[],int n){vector < double > vtemp;m_n=n;for (int i= 0;i < m_n; i++){m_equset.push_back(vtemp);for (int j= 0;j <= m_n; j++){m_equset[i].push_back(in[i*(m_n+1)+j]);}}}void CGAUSSSOLVEEQU::change(int m,int m2){vector < vector < double >> ::iterator iter;iter = m_equset.begin();vector < vector < double >> ::iterator iter2;iter2 = m_equset.begin();//double}void CGAUSSSOLVEEQU::solveEquSet(){vector < vector < double >> ::iterator iter;iter = m_equset.begin();for (int m= 0;m < m_n - 1 ; ++ m){// 将绝对值最大的主元素移上去for (int i=m;i<m_equset.size();i++){if (fabsl(m_equset[m][m]) < fabsl(m_equset[i][m])) {swap( m_equset[m], m_equset[i]);}}// 进行消元for (int i = m + 1 ;i < m_n; ++ i){double dm;dm = m_equset[i][m] / m_equset[m][m];for (int j = m;j < m_n + 1 ; ++ j){m_equset[i][j] -= dm * m_equset[m][j];}}++ iter;}// 初始化m_answer向量for (int i=0 ;i < m_n; ++ i) m_answer.push_back( 0 );// 求解答案m_answer[m_n - 1 ] = m_equset[m_n - 1 ][m_n] / m_equset[m_n - 1 ][m_n - 1 ];for ( int i = m_n - 2 ;i >= 0 ; -- i){m_answer[i] = m_equset[i][m_n];for ( int j = m_n - 1 ;j > i; -- j)m_answer[i] -= m_answer[j] * m_equset[i][j];m_answer[i] /= m_equset[i][i];}}void CGAUSSSOLVEEQU::outputAnswer(){for (int i= 1;i <= m_n; ++ i){cout << " x( " << i << " )= " << m_answer[i - 1 ] << endl;}}int main(){CGAUSSSOLVEEQU myEqu1;double in1[10*11]={4,2,-3,-1,2,1,0,0,0,0,5,8,6,-5,-3,6,5,0,1,0,0,12,4,2,-2,-1,3,2,-1,0,3,1,3,0,-2,1,5,-1,3,-1,1,9,4,2,-4,2,6,-1,6,7,-3,3,2,3,3,8,6,-8,5,7,17,2,6,-3,5,46,0,2,-1,3,-4,2,5,3,0,1,13,16,10,-11,-9,17,34,2,-1,2,2,38,4,6,2,-7,13,9,2,0,12,4,19,0,0,-1,8,-3,-24,-8,6,3,-1,-21};myEqu1.inputEquSet(in1,10);myEqu1.solveEquSet(); myEqu1.outputAnswer(); cout<<endl; cout<<endl; return 1 ;}实验运行结果：实验心得：通过本次实验，我不仅掌握了模块化程序设计的方法，还了解了求解线性方程组的方法，明确了高斯消去法选主元的必要性。
数值分析实验报告
数值实验题1实验1.1 病态问题实验目的：算法有“优”与“劣”之分，问题也有“好”与“坏”之别。
对数值方法的研究而言，所谓坏问题是指问题本身对扰动敏感，反之属于好问题。
本实验通过对一个高次多项式方程的求解，初步认识病态问题。
实验内容：考虑一个高次的代数多项式201()(1)(2)(20)()k p x x x x x k ==---=-∏ (E.1.1)显然该多项式的全部根为1，2，…，20，共计20个，且每个根都是单重的(也称为简单的)。
现考虑该多项式的一个扰动 19()0p x x ε+=， (E.1.2)其中，ε是一个非常小的数。
这相当于是对方程(E.1.1)中x 19的系数作一个小的扰动。
比较方程(E.1.1)和方程(E.1.2)根的差别，从而分析方程(E.1.1)的解对扰动的敏感性。
实验步骤与结果分析：(一) 实验源程序function t_charpt1_1% 数值实验1.1病态问题% 输入：[0 20]之间的扰动项及小的扰动常数 % 输出：加扰动后得到的全部根 clcresult=inputdlg({'请输入扰动项:在[0 20]之间的整数:'},'charpt 1_1',1,{'19'}); Numb=str2num(char(result));if((Numb>20)|(Numb<0))errordlg('请输入正确的扰动项:[0 20]之间的整数!');return;endresult=inputdlg({'请输入(0 1)之间的扰动常数:'},'charpt 1_1',1,{'0.00001'}); ess=str2num(char(result)); ve=zeros(1,21); ve(21-Numb)=ess;root=roots(poly(1:20)+ve);x0=real(root); y0=imag(root); plot(x0',y0', '*');disp(['对扰动项 ',num2str(Numb),'加扰动',num2str(ess),'得到的全部根为:']); disp(num2str(root));(二)实验结果分析(1)对于x19项的扰动ess，不同的取值对应的结果如下所示。
数值分析实习报告
数值分析实习报告一、实习背景与目的随着现代科学技术的飞速发展，数值分析作为一种重要的数学方法，在工程计算、科学研究等领域发挥着越来越重要的作用。
为了更好地将理论知识与实际应用相结合，提高自己在数值分析方面的实际操作能力，我参加了本次数值分析实习。
本次实习的主要目的是学习并掌握数值分析的基本方法及其编程实现，培养解决实际问题的能力。
二、实习内容与过程1. 实习前的准备工作：在实习开始前，我首先对数值分析的基本概念和方法进行了复习，包括误差分析、插值法、数值微积分、线性代数方程组的求解、非线性方程求解等。
同时，我还学习了相关编程语言，如Python、MATLAB等，为实习打下了坚实的基础。
2. 实习过程中的学习与实践：在实习过程中，我按照指导书的要求，完成了以下几个方面的学习与实践：（1）误差分析：通过实习，我深入理解了误差的来源、性质和影响因素，掌握了误差分析的基本方法，如绝对误差、相对误差、无穷小量级比较等。
（2）插值法：我学习了线性插值、二次插值、三次插值等基本插值方法，并掌握了利用Python和MATLAB编程实现插值法的技巧。
（3）数值微积分：我掌握了数值积分和数值微分的原理和方法，如梯形法、辛普森法等，并能够运用编程实现相应的算法。
（4）线性代数方程组的求解：我学习了高斯消元法、LU分解法等线性代数方程组的求解方法，并通过编程实践了这些方法的应用。
（5）非线性方程求解：我掌握了牛顿法、弦截法等非线性方程求解方法，并能够运用编程实现相应的算法。
3. 实习成果的展示与总结：在实习的最后阶段，我根据自己的学习与实践，编写了一个简单的数值分析程序，涵盖了插值、数值积分、线性代数方程组求解等多个方面的内容。
通过这个程序，我对实习过程中所学到的知识进行了巩固和总结。
三、实习收获与体会通过本次数值分析实习，我收获颇丰。
首先，我掌握了数值分析的基本方法及其编程实现，提高了自己在实际问题中的解决能力。
其次，我学会了如何将理论知识与实际应用相结合，培养了自己的动手实践能力。
东北大学数值分析课题2实验报告
数值分析实验报告东北大学一、实验要求1)建立矩阵求逆的算法公式2)编制下三角部分消元，上三角部分消元和对角元单位化等子程序3)应用结构程序设计编程出求n阶矩阵的逆矩阵的通用程序二、实验目的与意义1)通过该课题的实验，掌握求逆矩阵的程序设计方法2)学会利用矩阵求逆运算求解线性方程组的方法，提高数值方法的运用和编程的能力三、实验环境编译环境：Visual C++6.0。
编译语言：C++四、实验过程与分析:(1)求已知矩阵的逆：（以四阶为例）#include<stdio.h>#include <string.h>#define N 4int main(){ float a[N][N];float L[N][N],U[N][N],out[N][N], out1[N][N];float r[N][N],u[N][N];memset( a , 0 , sizeof(a));memset( L , 0 , sizeof(L));memset( U , 0 , sizeof(U));memset( r , 0 , sizeof(r));memset( u , 0 , sizeof(u));int n=N;int k,i,j;int flag=1;float s,t;////////////////////input a matrix////printf("\ninput A=");for(i=0;i<n;i++)for(j=0;j<n;j++)scanf("%f",&a[i][j]);//////////////////figure the input matrix//////////////////////////printf("输入矩阵:\n");for(i=0;i<n;i++){for (j = 0; j < n; j++){printf("%lf ", a[i][j]);}printf("\n");}for(j=0;j<n;j++)a[0][j]=a[0][j]; //计算U矩阵的第一行for(i=1;i<n;i++)a[i][0]=a[i][0]/a[0][0]; //计算L矩阵的第1列for(k=1;k<n;k++) {for(j=k;j<n;j++) {s=0;for (i=0;i<k;i++)s=s+a[k][i]*a[i][j]; //累加a[k][j]=a[k][j]-s; //计算U矩阵的其他元素}for(i=k+1;i<n;i++){t=0;for(j=0;j<k;j++)t=t+a[i][j]*a[j][k]; //累加a[i][k]=(a[i][k]-t)/a[k][k]; //计算L矩阵的其他元素} }for(i=0;i<n;i++)for(j=0;j<n;j++) {if(i>j){ L[i][j]=a[i][j]; U[i][j]=0;}//如果i>j，说明行大于列，计算矩阵的下三角部分，得出L的值，U的//为0else {U[i][j]=a[i][j];if(i==j) L[i][j]=1; //否则如果i<j，说明行小于列，计算矩阵的上三角部分，得出U的//值，L的为0else L[i][j]=0; }} if(U[1][1]*U[2][2]*U[3][3]*U[4][4]==0){flag=0;printf("\n逆矩阵不存在");}if(flag==1){/////////////////////求L和U矩阵的逆for (i=0;i<n;i++) /*求矩阵U的逆*/{u[i][i]=1/U[i][i];//对角元素的值，直接取倒数for (k=i-1;k>=0;k--){s=0;for (j=k+1;j<=i;j++)s=s+U[k][j]*u[j][i];u[k][i]=-s/U[k][k];//迭代计算，按列倒序依次得到每一个值，}}for (i=0;i<n;i++) //求矩阵L的逆{r[i][i]=1; //对角元素的值，直接取倒数，这里为1for (k=i+1;k<n;k++){for (j=i;j<=k-1;j++)r[k][i]=r[k][i]-L[k][j]*r[j][i]; //迭代计算，按列顺序依次得到每一个值}} /////////////////绘制矩阵LU分解后的L和U矩阵///////////////////////printf("\nLU分解后L矩阵:");for(i=0;i<n;i++){ printf("\n");for(j=0;j<n;j++)printf(" %lf",L[i][j]); }printf("\nLU分解后U矩阵:");for(i=0;i<n;i++){ printf("\n");for(j=0;j<n;j++)printf(" %lf",U[i][j]); }printf("\n");////////绘制L和U矩阵的逆矩阵printf("\nL矩阵的逆矩阵:");for(i=0;i<n;i++){ printf("\n");for(j=0;j<n;j++)printf(" %lf",r[i][j]); }printf("\nU矩阵的逆矩阵:");for(i=0;i<n;i++){ printf("\n");for(j=0;j<n;j++)printf(" %lf",u[i][j]); }printf("\n");//验证将L和U相乘，得到原矩阵printf("\nL矩阵和U矩阵乘积\n");for(i=0;i<n;i++){for(j=0;j<n;j++){out[i][j]=0;} }for(i=0;i<n;i++) {for(j=0;j<n;j++){for(k=0;k<n;k++){out[i][j]+=L[i][k]*U[k][j];} } } for(i=0;i<n;i++){for(j=0;j<n;j++){printf("%lf\t",out[i][j]); }printf("\r\n") }//////////将r和u相乘，得到逆矩阵printf("\n原矩阵的逆矩阵:\n");for(i=0;i<n;i++){for(j=0;j<n;j++){out1[i][j]=0;}}for(i=0;i<n;i++){for(j=0;j<n;j++) {for(k=0;k<n;k++){out1[i][j]+=u[i][k]*r[k][j];}} }for(i=0;i<n;i++){for(j=0;j<n;j++){printf("%lf\t",out1[i][j]);}printf("\r\n");}}return 0; }（2）求N阶矩阵的逆：#include<iostream>#include<math.h>using namespace std;class JuZhen{private:double data[10][20];int size;public:void qiuNi();void setSize();void show();void chuShi();};void JuZhen::setSize(){int n;cout<<"请?输?入?矩?阵ó的?阶×:";cin>>n;size=n;}void JuZhen::show(){int i,j;for(i=0;i<size;i++){for(j=size;j<2*size;j++){cout.width(10);cout.flags (ios::right);cout<<data[i][j]<<" ";}cout<<endl;}cout<<"***********************************************"<<endl;cout<<endl;}void JuZhen::chuShi(){int i,j;for(i=0;i<size;i++){cout<<"请?输?入?"<<i+1<<"行D的?元a素?:";for(j=0;j<2*size;j++){if(j<size)cin>>data[i][j];else if(j==i+size)data[i][j]=1.0;elsedata[i][j]=0.0;}}}void JuZhen::qiuNi()int i,j,k;int maxI=0;for(i=1;i<size;i++){if(fabs(data[maxI][0])<fabs(data[i][0])) maxI=i;}if(maxI!=0){double temp;for(j=0;j<2*size;j++){temp=data[0][j];data[0][j]=data[maxI][j];data[maxI][j]=temp;}}double temp2;for(i=0;i<size;i++){if(data[i][i]!=0)temp2=1.0/data[i][i];else{cout<<"此?矩?阵ó无T逆?!"<<endl;return ;}for(j=0;j<2*size;j++)data[i][j]*=temp2;for(j=0;j<size;j++){if(j!=i){double temp3=data[j][i];for(k=0;k<2*size;k++)data[j][k]-=temp3*data[i][k];}}}cout<<"逆?矩?阵ó为a：阰"<<endl;show();}void main()while(1){JuZhen a;a.setSize();a.chuShi();a.qiuNi();}}五、实验结果与分析（1）(2)(3)(4)如图，输入矩阵的阶，然后依次输入矩阵中元素，即可得到逆矩阵，若该矩阵无逆，则输出“此矩阵无逆”。
《数值分析》实验报告书
N4（0.895） function [y,R]= newcz(X,Y,x,M) x=0.895; M=4; X=[0.4,0.55,0.65,0.8,0.9]; Y=[0.41075,0.57815,0.69675,0.88811,1.02652];
n=length(X); m=length(x); for t=1:m z=x(t); A=zeros(n,n);A(:,1)=Y'; s=0.0; p=1.0; q1=1.0; c1=1.0; for j=2:n for i=j:n A(i,j)=(A(i,j-1)-A(i-1,j-1))/(X(i)-X(i-j+1)); end q1=abs(q1*(z-X(j-1)));c1=c1*j; end C=A(n,n);q1=abs(q1*(z-X(n))); for k=(n-1):-1:1 C=conv(C,poly(X(k)));d=length(C); C(d)=C(d)+A(k,k); end y(k)= polyval(C, z); end R=M*q1/c1; 运行结果： ans = 1.0194
实验三、解线性方程组的直接法
解线性方程组的直接法是指经过有限步运算后能求得方程组精确解
的方法。但由于实际计算中舍入误差是客观存在的，因而使用这类方法 也只能得到近似解。目前较实用的直接法是古老的高斯消去法的变形， 即主元素消去法及矩阵的三角分解法。引进选主元的技巧是为了控制计 算过程中舍入误差的增长，减少舍入误差的影响。一般说来，列主元消 去法及列主元三角分解法是数值稳定的算法，它具有精确度较高、计算 量不大和算法组织容易等优点，是目前计算机上解中、小型稠密矩阵方 程组可靠而有效的常用方法。
Y=[0.82741,0.82659,0.82577,0.82495]; n=length(X); m=length(x); for i=1:m z=x(i);s=0.0; for k=1:n p=1.0; q1=1.0; c1=1.0; for j=1:n if j~=k p=p*(z-X(j))/(X(k)-X(j)); end q1=abs(q1*(z-X(j))); c1=c1*j; end s=p*Y(k)+s; end y(i)=s; end R=M.*q1./c1; 运行结果： ans = 0.8261 2. N3(0.596) function [y,R]= newcz(X,Y,x,M) x=0.596; M=3;
东北大学数值分析上机实验报告
《数值分析》上机实验报告课题三解线性方程组的迭代法学生姓名：学生系别：学生班级：日期：上机实践报告【运行环境】软件：Windows、Microsoft Visual C++ 6.0PC一台【问题提出】对课题二所列目的和意义的线性方程组，试分别选用Jacobi 迭代法，Gauss-Seidol迭代法和SOR方法计算其解。
【实践要求】1、体会迭代法求解线性方程组，并能与消去法做比较；2、分别对不同精度要求，如ε=10-3，10-4，10-5 由迭代次数体会该迭代法的收敛快慢；3、对方程组2，3使用SOR方法时，选取松弛因子 =0.8，0.9，1，1.1，1.2等，试看对算法收敛性的影响，并能找出你所选用的松弛因子的最佳者；4、给出各种算法的设计程序和计算结果。
【目的意义】1、通过上机计算体会迭代法求解线性方程组的特点，并能和消去法比较；2、运用所学的迭代法算法，解决各类线性方程组，编出算法程序；3、体会上机计算时，终止步骤 < 或k >（予给的迭代次数），对迭代法敛散性的意义；4、体会初始解 x ，松弛因子的选取，对计算结果的影响。
【程序代码】//Jacobi.cpp#include<iostream>#include<cmath>using namespace std;#define N 15//最大迭代次数#define P 10//矩阵的阶数//#define P 8static double a[10][10]={4,2,-3,-1,2,1,0,0,0,0,8,6,-5,-3,6,5,0,1,0,0,4,2,-2,-1,3,2,-1,0,3,1,0,-2,1,5,-1,3,-1,1,9,4,-4,2,6,-1,6,7,-3,3,2,3,8,6,-8,5,7,17,2,6,-3,5,0,2,-1,3,-4,2,5,3,0,1,16,10,-11,-9,17,34,2,-1,2,2,4,6,2,-7,13,9,2,0,12,4,0,0,-1,8,-3,-24,-8,6,3,-1};static double b[10]={5,12,3,2,3,46,13,38,19,-21};static double x_jing[10]={1,-1,0,1,2,0,3,1,-1,2};//精确解static double x0[10]={0,0,0,0,0,0,0,0,0,0};static double x1[10];static int k,i,j;//static double a[8][8]={4,2,-4,0,2,4,0,0,// 2,2,-1,-2,1,3,2,0,// -4,-1,14,1,-8,-3,5,6,// 矩阵B 0,-2,1,6,-1,-4,-3,3,// 2,1,-8,-1,22,4,-10,-3,// 4,3,-3,-4,4,11,1,-4,// 0,2,5,-3,-10,1,14,2,// 0,0,6,3,-3,-4,2,19};//static double b[8]={0,-6,6,23,11,-22,-15,45};//static double x_jing[8]={1,-1,0,2,1,-1,0,2};//static double x0[8]={0,0,0,0,0,0,0,0};//static double x1[8];//static double a[10][10]={4,-1,0,0,0,0,0,0,0,0,// -1,4,-1,0,0,0,0,0,0,0,// 0,-1,4,-1,0,0,0,0,0,0,// 0,0,-1,4,-1,0,0,0,0,0,// 矩阵C 0,0,0,-1,4,-1,0,0,0,0,// 0,0,0,0,-1,4,-1,0,0,0,// 0,0,0,0,0,-1,4,-1,0,0,// 0,0,0,0,0,0,-1,4,-1,0,// 0,0,0,0,0,0,0,-1,4,-1,// 0,0,0,0,0,0,0,0,-1,4};//static double b[10]={7,5,-13,2,6,-12,14,-4,5,-5}; //static double x_jing[10]={2,1,-3,0,1,-2,3,0,1,-1}; //static double x0[10]={0,0,0,0,0,0,0,0,0,0};double Max(int y)//求算该次迭代的误差{double sum,max;for (i=0;i<P;i++){sum=0;for (j=0;j<P;j++)sum+=a[i][j]*x0[j];x1[i]=x0[i]+(b[i]-sum)/a[i][i];}max=fabs(x_jing[0]-x1[0]);for (i=1;i<P;i++){if (fabs(x_jing[i]-x1[i])>max)max=fabs(x_jing[i]-x1[i]);}cout<<"第"<<y<<"次迭代的误差为"<<max<<endl;return max;}void main(){double e[3]={10e-3,10e-4,10e-5};double max;int t;cout<<"请选择精确度：0、10e-3 1、10e-4 2、103-5 ";cin>>t;for (k=0;k<N;k++){max=Max(k);if (max<e[t])//判断精度是否符合要求，若符合则跳出程序，否则继续迭代{ k=k;break;}else{for (i=0;i<P;i++)x0[i]=x1[i];}}if (k<N)//输出结果{cout<<"迭代次数为"<<k<<endl;cout<<"方程组的解为"<<endl;for (i=0;i<P;i++)cout<<" "<<x1[i]<<endl;}else{cout<<"迭代次数超过"<<N<<"迭代终止!"<<endl;cout<<"方程组的解为"<<endl;for (i=0;i<P;i++)cout<<" "<<x1[i]<<endl;}}//Gauss-Seidol.cpp#include<iostream>#include<cmath>using namespace std;#define N 15//最大迭代次数//#define P 10//矩阵的阶数#define P 8//static double a[10][10]={4,2,-3,-1,2,1,0,0,0,0,// 8,6,-5,-3,6,5,0,1,0,0,// 4,2,-2,-1,3,2,-1,0,3,1,// 0,-2,1,5,-1,3,-1,1,9,4,// -4,2,6,-1,6,7,-3,3,2,3,// 8,6,-8,5,7,17,2,6,-3,5,// 0,2,-1,3,-4,2,5,3,0,1,// 16,10,-11,-9,17,34,2,-1,2,2,// 4,6,2,-7,13,9,2,0,12,4,// 0,0,-1,8,-3,-24,-8,6,3,-1};//static double b[10]={5,12,3,2,3,46,13,38,19,-21};//static double x_jing[10]={1,-1,0,1,2,0,3,1,-1,2};//精确解//static double x0[10]={0,0,0,0,0,0,0,0,0,0};//static double x1[10];static int k,i,j;static double a[8][8]={4,2,-4,0,2,4,0,0,2,2,-1,-2,1,3,2,0,-4,-1,14,1,-8,-3,5,6,0,-2,1,6,-1,-4,-3,3,2,1,-8,-1,22,4,-10,-3,4,3,-3,-4,4,11,1,-4,0,2,5,-3,-10,1,14,2,0,0,6,3,-3,-4,2,19};static double b[8]={0,-6,6,23,11,-22,-15,45};static double x_jing[8]={1,-1,0,2,1,-1,0,2};static double x0[8]={0,0,0,0,0,0,0,0};static double x1[8];//static double a[10][10]={4,-1,0,0,0,0,0,0,0,0,// -1,4,-1,0,0,0,0,0,0,0,// 0,-1,4,-1,0,0,0,0,0,0,// 0,0,-1,4,-1,0,0,0,0,0,// 矩阵C 0,0,0,-1,4,-1,0,0,0,0,// 0,0,0,0,-1,4,-1,0,0,0,// 0,0,0,0,0,-1,4,-1,0,0,// 0,0,0,0,0,0,-1,4,-1,0,// 0,0,0,0,0,0,0,-1,4,-1// 0,0,0,0,0,0,0,0,-1,4};//static double b[10]={7,5,-13,2,6,-12,14,-4,5,-5};//static double x_jing[10]={2,1,-3,0,1,-2,3,0,1,-1};//精确解//static double x0[10]={0,0,0,0,0,0,0,0,0,0};double Max(int y)//求算该次迭代的误差{double sum1,sum2,max;for (i=0;i<P;i++){sum1=0;sum2=0;for (j=0;j<=i-1;j++)sum1+=a[i][j]*x1[j];for (j=i+1;j<P;j++)sum2+=a[i][j]*x0[j];x1[i]=(b[i]-sum1-sum2)/a[i][i];}max=fabs(x_jing[0]-x1[0]);for (i=1;i<P;i++){if (fabs(x_jing[i]-x1[i])>max)max=fabs(x_jing[i]-x1[i]);}cout<<"第"<<y<<"次迭代的误差为"<<max<<endl;return max;}void main(){double e[3]={10e-3,10e-4,10e-5};double max;int t;cout<<"请选择精确度：0、10e-3 1、10e-4 2、103-5 ";cin>>t;for (k=0;k<N;k++){max=Max(k);if (max<e[t])//判断精度是否符合要求，若符合则跳出程序，否则继续迭代{ k=k;break;}else{for (i=0;i<P;i++)x0[i]=x1[i];}}if (k<N)//输出结果{cout<<"迭代次数为"<<k<<endl;cout<<"方程组的解为"<<endl;for (i=0;i<P;i++)cout<<" "<<x1[i]<<endl;}else{cout<<"迭代次数超过"<<N<<"迭代终止!"<<endl;cout<<"方程组的解为"<<endl;for (i=0;i<P;i++)cout<<" "<<x1[i]<<endl;}}//SOR.cpp#include<iostream>#include<cmath>using namespace std;#define N 15//最大迭代次数#define P 10//矩阵的阶数//#define P 8//static double a[10][10]={4,2,-3,-1,2,1,0,0,0,0,// 8,6,-5,-3,6,5,0,1,0,0,// 4,2,-2,-1,3,2,-1,0,3,1,// 矩阵A 0,-2,1,5,-1,3,-1,1,9,4,// -4,2,6,-1,6,7,-3,3,2,3,// 8,6,-8,5,7,17,2,6,-3,5,// 0,2,-1,3,-4,2,5,3,0,1,// 16,10,-11,-9,17,34,2,-1,2,2,// 4,6,2,-7,13,9,2,0,12,4,// 0,0,-1,8,-3,-24,-8,6,3,-1};//static double b[10]={5,12,3,2,3,46,13,38,19,-21};//static double x_jing[10]={1,-1,0,1,2,0,3,1,-1,2};//精确解//static double x0[10]={0,0,0,0,0,0,0,0,0,0};static double x1[P];static double sumx[P];static int k,i,j;//static double a[8][8]={4,2,-4,0,2,4,0,0,// 2,2,-1,-2,1,3,2,0,// -4,-1,14,1,-8,-3,5,6,// 矩阵B 0,-2,1,6,-1,-4,-3,3,// 2,1,-8,-1,22,4,-10,-3,// 4,3,-3,-4,4,11,1,-4,// 0,2,5,-3,-10,1,14,2,// 0,0,6,3,-3,-4,2,19};//static double b[8]={0,-6,6,23,11,-22,-15,45};//static double x_jing[8]={1,-1,0,2,1,-1,0,2};//static double x0[8]={0,0,0,0,0,0,0,0};//static double x1[8];static double a[10][10]={4,-1,0,0,0,0,0,0,0,0,-1,4,-1,0,0,0,0,0,0,0,0,-1,4,-1,0,0,0,0,0,0,0,0,-1,4,-1,0,0,0,0,0,0,0,0,-1,4,-1,0,0,0,0,0,0,0,0,-1,4,-1,0,0,0,0,0,0,0,0,-1,4,-1,0,0,0,0,0,0,0,0,-1,4,-1,0,0,0,0,0,0,0,0,-1,4,-1,0,0,0,0,0,0,0,0,-1,4};static double b[10]={7,5,-13,2,6,-12,14,-4,5,-5};static double x_jing[10]={2,1,-3,0,1,-2,3,0,1,-1};//精确解static double x0[10]={0,0,0,0,0,0,0,0,0,0};double Max(double w,double y){double sum1,sum2,max;for (i=0;i<P;i++){sum1=0;sum2=0;for (j=0;j<=i-1;j++)sum1+=a[i][j]*x1[j];for (j=i;j<P;j++)sum2+=a[i][j]*x0[j];sumx[i]=w*(b[i]-sum1-sum2)/a[i][i];x1[i]=x0[i]+sumx[i];}max=fabs(x_jing[0]-x1[0]);for (i=1;i<P;i++){if (fabs(x_jing[i]-x1[i])>max)max=fabs(x_jing[i]-x1[i]);}cout<<"第"<<y<<"次迭代的误差为"<<max<<endl;return max;}void main(){double e[3]={10e-3,10e-4,10e-5};double w[5]={0.8,0.9,1,1.1,1.2};double max;int t,l;cout<<"请选择精确度：0、10e-3 1、10e-4 2、103-5 ";cin>>t;cout<<"请选择松弛因子:0、0.8 1、0.9 2、1 3、1.1 4、1.2 ";cin>>l;for (k=0;k<N;k++){max=Max(w[l],k);if (max<e[t])//判断精度是否符合要求，若符合则跳出程序，否则继续迭代{ k=k;break;}else{for (i=0;i<P;i++)x0[i]=x1[i];}}if (k<N)//输出结果{cout<<"迭代次数为"<<k<<endl;cout<<"方程组的解为"<<endl;for (i=0;i<P;i++)cout<<" "<<x1[i]<<endl;}else{cout<<"迭代次数超过"<<N<<"迭代终止!"<<endl;cout<<"方程组的解为"<<endl;for (i=0;i<P;i++)cout<<" "<<x1[i]<<endl;}}【运行结果】方程A ：⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡1-421534100368-24-3-81-012029137-2621-234179-11-1003524-31-23-6217758-6233-761-62911-31-512-301-231-2-2010563-5-6000121-3-2416084-0484⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡10987654321x x x x x x x x x x =⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡-2119381346323125Jacobi 迭代Gauss-Seidol迭代SOR迭代方程B Jacobi迭代Gauss-Seidol迭代SOR迭代方程C ⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡----=⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡554141262135741-000000001-000000041-0000001-41-0000001-41-0000001-41-0000001-41-0000001-41-0000001-41-0000001-400000001-000000001-410987654321x x x x x x x x x xJacobi 迭代Gauss-Seidol迭代（选取了不同的精度）SOR迭代（选取了不同的松弛因子）【结果分析】1、通过实验结果看出（方程C的Gauss-Seidol迭代），取的精度不同，迭代的次数也不同。
数值分析实验1
东北大学数学实验中心实验报告规范（暂行）一、每个学生每个实验项目一份实验报告。
二、实验报告内容一般包括以下几个内容：1.实验项目名称2.实验目的和要求3.实验原理4.实验内容及步骤5.实验数据记录和处理6.实验结果与分析（含以上1、2、3、4、5、6项，需经指导教师签字认可，附在实验报告后）注：各专业各课程的实验报告内容与格式可由指导教师根据实验具体情况做出要求。
三、实验报告第一页按学院统一的实验报告格式书写，附页用A4纸书写，字迹工整，曲线要画在座标纸上，线路图要整齐、清楚（不得徒手画）。
如打印也应采用统一的实验报告的版头（A4纸）。
四、每学期将拟存档的学生实验报告按课程、实验项目分类装订成册，即每个实验项目每门课程的所有实验报告装订成一本。
装订线在左侧，第一页加订实验报告封皮。
五、东北大学理学院数学实验报告模板范本，本实验报告双面打印（附后）。
理学院数学实验中心实验报告专业：软件工程姓名：黄蕾学号：成绩：实验地点：数学实验中心指导教师签名：。
在迭代过程中需要对最后一行进行直接计算，其公式为输出选取模尽可能小的非零元素为主元代码附件：实验一：列主元Gauss法：package Excise; public class Lie {static double a[][];static double b[];static double x[];static double l[][];static double h[];static int n = 3;static int count = 0;public static void main(String[] arg) { double max;int maxn;Scanner sc = new Scanner(System.in);int n = sc.nextInt();x = new double[n];l = new double[n][n];h = new double[n];a = new double[n][n];for (int i = 0; i < n; i++) {for (int j = 0; j < n; j++) {if (i == j) {a[i][j] = 6;if (j >= 1) {a[i][j - 1] = 8;}if (j < n - 1) {a[i][j + 1] = 1;}}if (i != j && j != (i + 1)) {a[i][j] = 0;}}}for (int i = 0; i < n; i++) {for (int j = 0; j < n; j++) {}}b = new double[n];b[0] = 7;b[n - 1] = 14;for (int i = 1; i < n - 1; i++) { b[i] = 15;}for (int i = 0; i < n; i++) {}for (int i = 0; i < n - 1; i++) { max = a[i][i];maxn = i;for (int j = i + 1; j < n; j++) {if (Math.abs(max) < Math.abs(a[j][i])) {max = a[i][j];maxn = j;}}if (max == 0) {}for (int p = 0; p < n; p++) {h[p] = a[maxn][p];a[maxn][p] = a[i][p];a[i][p] = h[p];}double jh;jh = b[maxn];b[maxn] = b[i];b[i] = jh;for (int k = i + 1; k < n; k++) {l[k][i] = a[k][i] / a[i][i];for (int m = i; m < n; m++) {a[k][m] = a[k][m] - l[k][i] * a[i][m];}b[k] = b[k] - l[k][i] * b[i];}}for (int i = 0; i < n; i++) {for (int j = 0; j < n; j++) {}}for (int i = 0; i < n; i++) {}x[n - 1] = b[n - 1] / a[n - 1][n - 1];for (int m = n - 2; m >= 0; m--) {double zj = b[m];for (int i = n - 1; i > m; i--) {zj = zj - a[m][i] * x[i];}x[m] = zj / a[m][m];}DecimalFormat df = new DecimalFormat("#,##0.000000");for (int i = 0; i < n; i++) {}}}顺序消去法（主要部分）：for (int i = 0; i < n - 1; i++) {while (a[i][i] == 0) {count++;if (count == n - 1 - i) {}for (int j = 0; j < n; j++) {double temp[] = null;temp[j] = a[i][j];a[i][j] = a[i + count][j];a[i + count][j] = temp[j];}}for (int k = i + 1; k < n; k++) {l[k][i] = a[k][i] / a[i][i];for (int m = i; m < n; m++) {a[k][m] = a[k][m] - l[k][i] * a[i][m];}b[k] = b[k] - l[k][i] * b[i];} }。
数值分析实验报告
数值分析实验报告一、实验目的数值分析是一门研究用计算机求解数学问题的数值方法及其理论的学科。
本次实验的目的在于通过实际操作和编程实现，深入理解和掌握数值分析中的常见算法，提高运用数值方法解决实际问题的能力，并对算法的精度、稳定性和效率进行分析和比较。
二、实验环境本次实验使用的编程语言为 Python，使用的开发工具为 PyCharm。
实验所依赖的主要库包括 NumPy、Matplotlib 等。
三、实验内容（一）函数逼近与插值1、拉格朗日插值法通过给定的离散数据点，构建拉格朗日插值多项式，对未知点进行函数值的估计。
2、牛顿插值法与拉格朗日插值法类似，但采用了不同的形式和计算方式。
（二）数值积分1、梯形公式将积分区间划分为若干个梯形，通过计算梯形面积之和来近似积分值。
2、辛普森公式基于抛物线拟合的方法，提高积分近似的精度。
（三）线性方程组求解1、高斯消元法通过逐行消元将线性方程组化为上三角形式，然后回代求解。
2、 LU 分解法将系数矩阵分解为下三角矩阵 L 和上三角矩阵 U，然后通过两次前代和回代求解。
（四）非线性方程求解1、二分法通过不断将区间一分为二，逐步缩小根所在的区间，直到满足精度要求。
2、牛顿迭代法利用函数的切线来逼近根，通过迭代逐步收敛到根的近似值。
四、实验步骤（一）函数逼近与插值1、拉格朗日插值法定义计算拉格朗日基函数的函数。
根据给定的数据点和待求点，计算插值多项式的值。
输出插值结果，并与真实值进行比较。
2、牛顿插值法计算差商表。
构建牛顿插值多项式。
进行插值计算和结果分析。
（二）数值积分1、梯形公式定义积分区间和被积函数。
按照梯形公式计算积分近似值。
分析误差。
2、辛普森公式同样定义积分区间和被积函数。
运用辛普森公式计算积分近似值。
比较与梯形公式的精度差异。
（三）线性方程组求解1、高斯消元法输入系数矩阵和右端项向量。
进行消元操作。
回代求解方程。
输出解向量。
2、 LU 分解法对系数矩阵进行 LU 分解。
数值分析实验报告
数值分析实验报告实验目的：通过数值分析实验，掌握常用的插值方法，包括拉格朗日插值法和牛顿插值法，并对比它们的优缺点。
实验原理：插值法是一种在已知数据点的基础上，通过构造一个函数来逼近给定数据集以及这个函数本身。
其中，拉格朗日插值法采用一个多项式来逼近数据集，而牛顿插值法则采用一个多项式和差商来逼近。
实验步骤：1.使用拉格朗日插值法：a)根据给定的n+1个数据点，构造一个n次的插值多项式。
b)计算插值多项式在给定点x处的值。
2.使用牛顿插值法：a)根据给定的n+1个数据点，计算差商的递归表达式。
b)利用递归表达式计算插值多项式在给定点x处的值。
3.通过实验数据进行验证，并对比两种插值方法的优缺点。
实验结果与分析：以一个具体的实验数据为例，假设已知数据点为{(0,1),(1,3),(2,5)}，要求在给定点x=0.5处进行插值。
1.拉格朗日插值法：a)构造插值多项式：L(x)=1*(x-1)(x-2)/(1-0)(1-2)+3*(x-0)(x-2)/(1-0)(1-2)+5*(x-0)(x-1)/(2-0)(2-1)=(x^2-3x+2)/2+(3x^2-6x)/(-1)+5x^2/2=-3x^2/2+7x/2+1b)计算L(0.5)=-3(0.5)^2/2+7(0.5)/2+1=22.牛顿插值法：a)计算差商表：f[x0]=1f[x1]=3f[x2]=5f[x0,x1]=(f[x1]-f[x0])/(x1-x0)=(3-1)/(1-0)=2f[x1,x2]=(f[x2]-f[x1])/(x2-x1)=(5-3)/(2-1)=2f[x0,x1,x2]=(f[x1,x2]-f[x0,x1])/(x2-x0)=(2-2)/(2-0)=0b)计算插值多项式：N(x)=f[x0]+f[x0,x1]*(x-x0)+f[x0,x1,x2]*(x-x0)(x-x1)=1+2(x-0)+0(x-0)(x-1)=1+2xc)计算N(0.5)=1+2(0.5)=2对比结果可得到拉格朗日插值法和牛顿插值法得到的插值点的值都为2，验证了所使用方法的正确性。
东北大学软件学院数值分析程序实践报告
数值分析程序实践 实验报告东北大学软件学院实验目的:用SOR 法求解方程组：=0.65、1、1.2、1.45计算.要求精度为10-6；并指出迭代次数。
实验代码和结果：#include<iostream>⎪⎪⎩⎪⎪⎨⎧=+-+-=-+-=+-+--=-+-1322151481615356212146106882644321432143214321x x x x x x x x x x x x x x x x#include<iomanip>#include<cmath> // fabs();using namespace std;void SolveEquation(const int &dim){double *Arr = new double[dim*dim]; //方程矩阵double *B = new double[dim]; //方程右端系数double *X = new double[dim]; //初始解double *dX = new double[dim];double e; //解的精度double w; //w==1时，为GS迭代double S, S1;const int N = 5000; //最大迭代次数,防止死机int n=0;bool hasSolved = false;cout << endl << "初始化方程组左端系数矩阵!" << endl;for (int i=0; i<dim; i++){for (int j=0; j<dim; j++){cout << "Arr[" << i << "][" << j << "]: ";cin >> Arr[i*dim+j];}}cout << "初始化方程组右端系数矩阵!" << endl;for (i=0; i<dim; i++){cout << "B[" << i << "]: ";cin >> B[i];}system("cls");cout << "方程组如下: " << endl << endl;for (i=0; i<dim; i++){for (int j=0; j<dim; j++){cout << setw(8) << Arr[i*dim+j] << " X" << j+1;if (j < dim-1) cout << " + ";else if (j == dim-1) cout << " = ";}cout << setw(8) << B[i] << endl;}cout << endl << "设置解的精度要求:(比如1e-6)" << endl; cin >> e;cout << endl;cout << "输入初始向量!" << endl;for (i=0; i<dim; i++){cout << "X[" << i+1 << "]: ";cin >> X[i];}cout << endl << "设置参数ω ( 0<ω<2 )!" << endl;cin >> w;for (int k=0; k<N; k++) //3-8{S = 0.0;for (i=0; i<dim; i++) //5-7{double sum = 0.0;for (int j=0; j<dim; j++){sum += Arr[i*dim+j]*X[j];}if (fabs(Arr[i*dim+i]) < 1e-10){cout << "被零除!" << endl << Arr[i*dim+i] << endl; exit(0);}dX[i] = w * (B[i] - sum) / Arr[i*dim+i];S1 = dX[i];if (fabs(S1) > fabs(S)){//fabs()取绝对值函数S = S1;}X[i] = X[i] + S1;}n++;if (fabs(S) <= e){cout<<"迭代次数为："<<endl;cout<<n<<endl;hasSolved = true;//system("cls");cout << "线性方程组的解为：" << endl;for (int t=0; t<dim; t++){cout << "X" << t+1 << "=" << X[t] << "\t";}cout << endl;break;}}if (!hasSolved){cout << "初始向量或ω不合理, 请重新设置!" << endl; }delete[] Arr;delete[] B;delete[] X;delete[] dX;}void main(){int dim;cout << "输入线性方程组未知数个数: ";cin >> dim;SolveEquation(dim);}w=0.65W=1W=1.2W=1.45。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数值分析设计实验实验报告课题一 迭代格式的比较一、问题提出设方程f(x)=x3- 3x –1=0 有三个实根 x*1=1.8793 ,x *2=-0.34727 ,x *3=-1.53209现采用下面三种不同计算格式，求 f(x)=0的根 x *1 或x *21、 x =213x x + 2、 x = 313-x3、 x = 313+x二、要求1、编制一个程序进行运算，最后打印出每种迭代格式的敛散情况；2、用事后误差估计k k x x -+1〈ε来控制迭代次数，并且打印出迭代的次数；3、初始值的选取对迭代收敛有何影响；4、分析迭代收敛和发散的原因。
三、目的和意义1、通过实验进一步了解方程求根的算法；2、认识选择计算格式的重要性；3、掌握迭代算法和精度控制；4、明确迭代收敛性与初值选取的关系。
四、程序设计流程图五、源程序代码#include<stdio.h>#include<math.h>void main(){float x1,x2,x3,q,a,z,p,e=0.00001;x1=-1.0000;x2=-1.0000;x3=1.0000;int i,y=3;printf("0 %f %f %f\n",x1,x2,x3);q=x1-p;a=x2-p;z=x3-p;for(i=1;i<=60;i++){if(q<e&&q>(0-e))goto a;else{ p=x1;x1=(3*x1+1)/(x1*x1);printf("%d 1 %f\t",i,x1);q=x1-p;}a: if(a<e&&a>(0-e))goto z;else{ p=x2;x2=(x2*x2*x2-1)/3;printf("%d 2 %f\t",i,x2);a=x2-p;}z: if(z<e&&z>(0-e))goto end;else{p=x3;x3=pow((3*x3+1),1.0/y);printf("%d 3 %f\n",i,x3);z=x3-p;}end:;}}六。
程序运行结果七.程序运行结果讨论和分析：对于迭代格式一、二、三对于初值为-1.0000，-1.0000，1.0000分别迭代了37次，8次，10次，由此可知，简单迭代法的收敛性取决于迭代函数，以及初值x 的选取，并且对初值的选取要求较高，需谨慎选取。
课题二 线性方程组的直接算法一、问题提出给出下列几个不同类型的线性方程组，请用适当算法计算其解。
1、 设线性方程组⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡--------------------------1368243810041202913726422123417911101610352431205362177586832337616244911315120130123122400105635680000121324⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡10987654321x x x x x x x x x x =⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡-2119381346323125x *= ( 1, -1, 0, 1, 2, 0, 3, 1, -1, 2 )TGsuss 列主元消去法#include <math.h>#include <conio.h>#include <stdio.h>#define MAX 100typedef struct{int row,col;float MAT[MAX][MAX];float Solution[MAX];}Matrix;void Gauss(Matrix *M);void MBack(Matrix *M);void MSave(Matrix *M);void MInput(Matrix *M);void MOutput(Matrix *M); void Solution(Matrix *M); void MSort(Matrix *M,int n);void main(){Matrix Mat;MInput(&Mat);MSave(&Mat);Gauss(&Mat);MSave(&Mat);if(Mat.row==Mat.col-1) {MBack(&Mat);Solution(&Mat);}printf("Press any key to halt...");getch();}void MInput(Matrix *M){int i,j;printf("输入行数:"); scanf("%d",&M->row); printf("输入列数:"); scanf("%d",&M->col); for(i=0;i<M->row;i++){printf("第%d行:",i+1);for(j=0;j<M->col;j++){scanf("%f",&M->MAT[i][j]);}}for(i=0;i<M->row;i++)M->Solution[i] = 0;}void MOutput(Matrix *M){int i,j;printf("MATRIX:\n");for(i=0;i<M->row;i++){for(j=0;j<M->col;j++)printf("%10.3f",M->MAT[i][j]);printf("\n");}}void Gauss(Matrix *M){int i,j,k;float temp;for(i=0;i<M->row-1;i++) {MSort(M,i); MOutput(M);for(j=i+1;j<M->row;j++) {temp = M->MAT[j][i];for(k=0;k<M->col;k++)if(temp!=0) {M->MAT[j][k] /= temp;M->MAT[j][k] *= M->MAT[i][i];M->MAT[j][k] -= M->MAT[i][k];}}}MOutput(M);}void MSort(Matrix *M,int n){int i,j,k;float temp[MAX];for(i=n;i<M->row-1;i++) {for(j=n;j<M->row-i-1;j++) {if(fabs(M->MAT[j][n])<fabs(M->MAT[j+1][n])) { for(k=0;k<M->col;k++) {temp[k] = M->MAT[j+1][k];M->MAT[j+1][k] = M->MAT[j][k];M->MAT[j][k] = temp[k];}}}}}void MBack(Matrix *M){int i,j;float sum;M->Solution[M->row-1] = M->MAT[M->row-1][M->col-1] /M->MAT[M->row-1][M->row-1];for(i=M->row-2;i>=0;i--) {sum = M->MAT[i][M->col-1];for(j=i+1;j<M->row;j++)sum -= M->MAT[i][j]*M->Solution[j];M->Solution[i] = sum/M->MAT[i][i];}}void Solution(Matrix *M){int i;printf("Solution:\n");for(i=0;i<M->row;i++)printf("X[%d] = %f\n",i+1,M->Solution[i]); }void MSave(Matrix *M){int i,j;FILE *eryar;eryar = fopen("Matrix.txt","a");for(i=0;i<M->row;i++) {for(j=0;j<M->col;j++)fprintf(eryar,"%10.3f",M->MAT[i][j]);fprintf(eryar,"\n");}fclose(eryar);}2、设对称正定阵系数阵线方程组⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡----------------------19243360021411035204111443343104221812334161206538114140231212200420424⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡87654321x x x x x x x x = ⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡---4515229232060x *= ( 1, -1, 0, 2, 1, -1, 0, 2 )T平方根法#include<iostream>#include<cmath>#include<cstdlib>using namespace std;int main(){int n,i,j,k,m;cout<<"输入维数:";cin>>n;double **A=new double*[(n+1)];for(i=1;i<=n;i++)A[i]=new double[n+1];double *b=new double[n+1];double *x=new double[n+1];double *y=new double[n+1];cout<<"输入系数对称正定矩阵A[][]:"<<endl;for(i=1;i<=n;i++)for(j=1;j<=n;j++)cin>>A[i][j];cout<<"输入向量b[]:";for(i=1;i<=n;i++)cin>>b[i];cout<<endl;for(k=1;k<=n;k++){double sum=0;for(m=1;m<=k-1;m++){sum=sum+pow(A[k][m],2.0);}sum=A[k][k]-sum;A[k][k]=sqrt(sum);for(i=k+1;i<=n;i++){double temp1=0;for(m=1;m<=k-1;m++){temp1=temp1+A[i][m]*A[k][m];}temp1=A[i][k]-temp1;A[i][k]=temp1/A[k][k];}double temp2=0;for(m=1;m<=k-1;m++){temp2=temp2+A[k][m]*y[m];}y[k]=(b[k]-temp2)/A[k][k];}x[8]=y[8]/A[8][8];for(k=n-1;k>=1;k--){double temp3=0;for(m=k+1;m<=n;m++){temp3=temp3+A[m][k]*x[m];}x[k]=(y[k]-temp3)/A[k][k];}cout<<"输出结果向量x[]:"<<endl;for(i=1;i<=n;i++) cout<<x[i]<<endl;;system("pause");return 0;}3、三对角形线性方程组⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡------------------4100000000141000000001410000000014100000000141000000001410000000014100000000141000000001410000000014⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡10987654321x x x x x x x x x x = ⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎥⎦⎤⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎢⎣⎡----5541412621357x *= ( 2, 1, -3, 0, 1, -2, 3, 0, 1, -1 )T追赶法#include<iostream>#include<cmath>#include<cstdlib>using namespace std;int main(){int n,i;cout<<"输入系数矩阵的维数:";cin>>n;double *a=new double[n+1];double *c=new double[n+1];double *d=new double[n+1];double *b=new double[n+1];double *x=new double[n+1];double *y=new double[n+1];cout<<"输入系数矩阵A[]数据："<<endl;for(i=1;i<=n;i++) cin>>a[i];for(i=1;i<=n;i++) cin>>c[i];for(i=1;i<=n;i++) cin>>d[i];cout<<"输入b[] :"<<endl;for(i=1;i<=n;i++) cin>>b[i];for(i=1;i<=n-1;i++){c[i]=c[i]/a[i];a[i+1]=a[i+1]-d[i+1]*c[i];}cout<<"输出解向量a[]:"<<endl;for(i=1;i<=n;i++)cout<<a[i]<<endl;cout<<"输出解向量c[]:"<<endl;for(i=1;i<=n;i++)cout<<c[i]<<endl;y[1]=b[1]/a[1];for(i=2;i<=n;i++){y[i]=(b[i]-d[i]*y[i-1])/a[i];}cout<<"输出解向量y[]:"<<endl;for(i=1;i<=n;i++)cout<<y[i]<<endl;x[n]=y[n];for(i=n-1;i>=1;i--){x[i]=y[i]-c[i]*x[i+1];}cout<<"输出解向量x[]:"<<endl;for(i=1;i<=n;i++)cout<<x[i]<<endl;system("pause");return 0;}四、 程序运行结果分析误差分析：列主元高斯法解决了一部分大数吃掉小数的现象，但在计算机运算时，仍会对中间数据进行舍入，影响结果的精度，这种误差同样也存在其他两种算法中；对于三对角阵，选用追赶法可以得到更准确的解。