计算方法实验报告.doc
计算方法实验报告
计算方法实验报告计算方法实验报告概述：计算方法是一门研究如何用计算机解决数学问题的学科。
在本次实验中，我们将学习和应用几种常见的计算方法，包括数值逼近、插值、数值积分和常微分方程求解。
通过实验，我们将深入了解这些方法的原理、应用场景以及其在计算机科学和工程领域的重要性。
数值逼近：数值逼近是一种通过使用近似值来计算复杂函数的方法。
在实验中，我们通过使用泰勒级数展开和牛顿迭代法等数值逼近技术，来计算函数的近似值。
这些方法在科学计算和工程领域中广泛应用，例如在信号处理、图像处理和优化问题中。
插值：插值是一种通过已知数据点来估算未知数据点的方法。
在实验中，我们将学习和应用拉格朗日插值和牛顿插值等方法，以及使用这些方法来构造函数的近似曲线。
插值技术在数据分析、图像处理和计算机图形学等领域中具有重要的应用价值。
数值积分：数值积分是一种通过将函数曲线划分为小矩形或梯形来估算函数的积分值的方法。
在实验中，我们将学习和应用矩形法和梯形法等数值积分技术，以及使用这些方法来计算函数的近似积分值。
数值积分在物理学、金融学和统计学等领域中被广泛使用。
常微分方程求解：常微分方程求解是一种通过数值方法来求解微分方程的方法。
在实验中，我们将学习和应用欧拉法和龙格-库塔法等常微分方程求解技术，以及使用这些方法来求解一些常见的微分方程。
常微分方程求解在物理学、生物学和工程学等领域中具有广泛的应用。
实验结果：通过实验，我们成功地应用了数值逼近、插值、数值积分和常微分方程求解等计算方法。
我们得到了准确的结果，并且在不同的应用场景中验证了这些方法的有效性和可靠性。
这些实验结果将对我们进一步理解和应用计算方法提供重要的指导和支持。
结论：计算方法是计算机科学和工程领域中的重要学科，它提供了解决复杂数学问题的有效工具和方法。
通过本次实验，我们深入了解了数值逼近、插值、数值积分和常微分方程求解等计算方法的原理和应用。
这些方法在科学研究、工程设计和数据分析等领域中具有广泛的应用价值。
数学计算方法实验报告
数学计算方法实验报告习题二2.估计用二分法求方程f(x)=x3+4x2-10=0在区间[1,2]内根的近似值，为使方程不超过10时所需的二分次数。
f(x k)程序过程：function two (tolerance)a=1;b=2;counter=0;while (abs(b-a)>tolerance)c=(a+b)/2;fa=a^3+4*a^2-10;fb=b^3+4*b^2-10;fc=c^3+4*c^2-10;if ((fa==0|fb==0)) disp(counter);elseif (fa*fc<0)b=c;counter=counter+1;elseif (fb*fc<0)a=c;counter=counter+1;elseif (fb==0)disp(counter);endendsolution=(a+b)/2;disp(solution);disp(counter);实验结果：6.取x0=1.5,用牛顿迭代法求第三中的方程根.f(x)=x3+4x2-10=0的近似值（精确到||x k+1-x k|≦10-5,并将迭代次数与3题比较。
程序过程：function six (g)a=1.5;fa=a^3+4*a^2-10;ga=3*a^2+8*a;b=a-fa/ga;k=1;while(abs(b-a)>g)a=b;fa=a^3+4*a^2-10;ga=3*a^2+8*a;b=a-fa/ga;k=k+1;endformat long;disp(a);disp(k);实验结果：程序结果计算结果8.用弦割法求方程f(x)=x3-3x2-x+9=0在区间[-2,-1]内的一个实根近似值x k,|f(x k)|≦10-5.程序过程：function eight (t)a=-2;b=-1;fa=a^3-3*a^2-a+9;fb=b^3-3*b^2-b+9;c=b-fb*(b-a)/(fb-fa);k=1;while(abs(c-b)>t)a=b;b=c;fa=a^3-3*a^2-a+9;fb=b^3-3*b^2-b+9;c=b-fb*(b-a)/(fb-fa);k=k+1;endformat long;disp(k);disp(b);实验结果： 计算结果9.用艾特肯算法求方程x3+4x2-10=0在区间[1,2]内的根的近似值（取x0=1.5，g(x)=410 x ,精确到|x k+1-x k |≦10-5,并与2，3,6结果比较。
计算方法_实验报告
一、实验目的1. 理解并掌握计算方法的基本概念和原理；2. 学会使用计算方法解决实际问题；3. 提高编程能力和算法设计能力。
二、实验内容本次实验主要涉及以下内容：1. 线性方程组的求解；2. 多项式插值；3. 牛顿法求函数零点；4. 矩阵的特征值和特征向量求解。
三、实验环境1. 操作系统：Windows 102. 编程语言：Python3.83. 科学计算库：NumPy、SciPy四、实验步骤及结果分析1. 线性方程组的求解（1）实验步骤a. 导入NumPy库；b. 定义系数矩阵A和增广矩阵b；c. 使用NumPy的linalg.solve()函数求解线性方程组。
（2）实验结果设系数矩阵A和增广矩阵b如下：A = [[2, 1], [1, 2]]b = [3, 2]解得：x = [1, 1]2. 多项式插值（1）实验步骤a. 导入NumPy库；b. 定义插值点x和对应的函数值y；c. 使用NumPy的polyfit()函数进行多项式拟合；d. 使用poly1d()函数创建多项式对象；e. 使用多项式对象计算插值点对应的函数值。
（2）实验结果设插值点x和对应的函数值y如下：x = [1, 2, 3, 4, 5]y = [1, 4, 9, 16, 25]拟合得到的二次多项式为：f(x) = x^2 + 1在x = 3时，插值得到的函数值为f(3) = 10。
3. 牛顿法求函数零点（1）实验步骤a. 导入NumPy库；b. 定义函数f(x)和导数f'(x)；c. 设置初始值x0；d. 使用牛顿迭代公式进行迭代计算；e. 判断迭代结果是否满足精度要求。
（2）实验结果设函数f(x) = x^2 - 2x - 3，初始值x0 = 1。
经过6次迭代，得到函数零点x ≈ 3。
4. 矩阵的特征值和特征向量求解（1）实验步骤a. 导入NumPy库；b. 定义系数矩阵A；c. 使用NumPy的linalg.eig()函数求解特征值和特征向量。
计算方法实验报告
班级：地信11102班序号： 20姓名：任亮目录计算方法实验报告（一） (3)计算方法实验报告（二） (6)计算方法实验报告（三） (9)计算方法实验报告（四） (13)计算方法实验报告（五） (18)计算方法实验报告（六） (22)计算方法实验报告（七） (26)计算方法实验报告（八） (28)计算方法实验报告（一）一、实验题目：Gauss消去法解方程组二、实验学时: 2学时三、实验目的和要求1、掌握高斯消去法基础原理2、掌握高斯消去法法解方程组的步骤3、能用程序语言对Gauss消去法进行编程实现四、实验过程代码及结果1、实验算法及其代码模块设计（1）、建立工程，建立Gauss.h头文件，在头文件中建类，如下：class CGauss{public:CGauss();virtual ~CGauss();public:float **a; //二元数组float *x;int n;public:void OutPutX();void OutputA();void Init();void Input();void CalcuA();void CalcuX();void Calcu();};（2）、建立Gauss.cpp文件，在其中对个函数模块进行设计2-1：构造函数和析构函数设计CGauss::CGauss()//构造函数{a=NULL;x=NULL;cout<<"CGauss类的建立"<<endl;}CGauss::~CGauss()//析构函数{cout<<"CGauss类撤销"<<endl;if(a){for(int i=1;i<=n;i++)delete a[i];delete []a;}delete []x;}2-2：函数变量初始化模块void CGauss::Init()//变量的初始化{cout<<"请输入方程组的阶数n=";cin>>n;a=new float*[n+1];//二元数组初始化，表示行数for(int i=1;i<=n;i++){a[i]=new float[n+2];//表示列数}x=new float[n+1];}2-3：数据输入及输出验证函数模块void CGauss::Input()//数据的输入{cout<<"--------------start A--------------"<<endl;cout<<"A="<<endl;for(int i=1;i<=n;i++)//i表示行，j表示列{for(int j=1;j<=n+1;j++){cin>>a[i][j];}}cout<<"--------------- end --------------"<<endl;}void CGauss::OutputA()//对输入的输出验证{cout<<"-----------输出A的验证-----------"<<endl;for(int i=1;i<=n;i++){for(int j=1;j<=n+1;j++){cout<<a[i][j]<<" ";}cout<<endl;}cout<<"---------------END--------------"<<endl;}2-4：消元算法设计及实现void CGauss::CalcuA()//消元函数for(int k=1 ;k<n;k++){for(int i=k+1;i<=n;i++){double lik=a[i][k]/a[k][k];for(int j=k;j<=n+1;j++){a[i][j]-=lik*a[k][j];}a[i][k]=0; //显示消元的效果}}}2-5：回代计算算法设计及函数实现void CGauss::CalcuX()//回带函数{for(int i=n;i>=1;i--){double s=0;for(int j=i+1;j<=n;j++){s+=a[i][j]*x[j];}x[i]=(a[i][n+1]-s)/a[i][i];}}2-6：结果输出函数模块void CGauss::OutPutX()//结果输出函数{cout<<"----------------X---------------"<<endl;for(int i=1 ;i<=n;i++){cout<<"x["<<i<<"]="<<x[i]<<endl;}}（3）、“GAUSS消元法”主函数设计int main(int argc, char* argv[]){CGauss obj;obj.Init();obj.Input();obj.OutputA();obj.CalcuA();obj.OutputA();obj.CalcuX();obj.OutPutX();//obj.Calcu();return 0;2、实验运行结果计算方法实验报告（二）一、实验题目：Gauss列主元消去法解方程组二、实验学时: 2学时三、实验目的和要求1、掌握高斯列主元消去法基础原理（1）、主元素的选取（2）、代码对主元素的寻找及交换2、掌握高斯列主元消去法解方程组的步骤3、能用程序语言对Gauss列主元消去法进行编程实现四、实验过程代码及结果1、实验算法及其代码模块设计（1）、新建头文件CGuassCol.h，在实验一的基础上建立类CGauss的派生类CGuassCol公有继承类CGauss，如下：#include "Gauss.h"//包含类CGauss的头文件class CGaussCol:public CGauss{public:CGaussCol();//构造函数virtual ~CGaussCol();//析构函数public:void CalcuA();//列主元的消元函数int FindMaxIk(int k);//寻找列主元函数void Exchange(int k,int ik);//交换函数void Calcu();};（2）、建立CGaussCol.cpp文件，在其中对个函数模块进行设计2-1:头文件的声明#include "stdafx.h"#include "CGuassCol.h"#include "math.h"#include "iostream.h"2-2：派生类CGaussCol的构造函数和析构函数CGaussCol::CGaussCol()//CGaussCol类构造函数{cout<<"CGaussCol类被建立"<<endl;}CGaussCol::~CGaussCol()//CGaussCol类析构函数{cout<<"~CGaussCol类被撤销"<<endl;}2-3：高斯列主元消元函数设计及代码实现void CGaussCol::CalcuA()//{for(int k=1 ;k<n;k++){int ik=this->FindMaxIk(k);if(ik!=k)this->Exchange(k,ik);for(int i=k+1;i<=n;i++){float lik=a[i][k]/a[k][k];for(int j=k;j<=n+1;j++){a[i][j]-=lik*a[k][j];}}}}2-4：列主元寻找的代码实现int CGaussCol::FindMaxIk(int k)//寻找列主元{float max=fabs(a[k][k]);int ik=k;for(int i=k+1;i<=n;i++){if(max<fabs(a[i][k])){ik=i;max=fabs(a[i][k]);}}return ik;}2-5：主元交换的函数模块代码实现void CGaussCol::Exchange(int k,int ik)//做交换{for(int j=k;j<=n+1;j++){float t=a[k][j];a[k][j]=a[ik][j];a[ik][j]=t;}}（3）、建立主函数main.cpp文件，设计“Gauss列主元消去法”主函数模块3-1：所包含头文件声明#include "stdafx.h"#include "Gauss.h"#include "CGuassCol.h"3-2：主函数设计int main(int argc, char* argv[]){CGaussCol obj;obj.Init();//调用类Gauss的成员函数obj.Input();//调用类Gauss的成员函数obj.OutputA();//调用类Gauss的成员函数obj.CalcuA();obj.OutputA();obj.CalcuX();obj.OutPutX();return 0;}2、实验结果计算方法实验报告（三）一、实验题目：Gauss完全主元消去法解方程组二、实验学时: 2学时三、实验目的和要求1、掌握高斯完全主元消去法基础原理；2、掌握高斯完全主元消去法法解方程组的步骤；3、能用程序语言对Gauss完全主元消去法进行编程（C++）实现。
计算方法实验报告册
实验一——插值方法实验学时：4实验类型：设计 实验要求：必修一 实验目的通过本次上机实习，能够进一步加深对各种插值算法的理解；学会使用用三种类型的插值函数的数学模型、基本算法，结合相应软件（如VC/VB/Delphi/Matlab/JAVA/Turbo C ）编程实现数值方法的求解。
并用该软件的绘图功能来显示插值函数，使其计算结果更加直观和形象化。
二 实验内容通过程序求出插值函数的表达式是比较麻烦的，常用的方法是描出插值曲线上尽量密集的有限个采样点，并用这有限个采样点的连线，即折线，近似插值曲线。
取点越密集，所得折线就越逼近理论上的插值曲线。
本实验中将所取的点的横坐标存放于动态数组[]X n 中，通过插值方法计算得到的对应纵坐标存放于动态数组[]Y n 中。
以Visual C++.Net 2005为例。
本实验将Lagrange 插值、Newton 插值和三次样条插值实现为一个C++类CInterpolation ，并在Button 单击事件中调用该类相应函数，得出插值结果并画出图像。
CInterpolation 类为 class CInterpolation { public :CInterpolation();//构造函数CInterpolation(float *x1, float *y1, int n1);//结点横坐标、纵坐标、下标上限 ~ CInterpolation();//析构函数 ………… …………int n, N;//结点下标上限，采样点下标上限float *x, *y, *X;//分别存放结点横坐标、结点纵坐标、采样点横坐标float *p_H,*p_Alpha,*p_Beta,*p_a,*p_b,*p_c,*p_d,*p_m;//样条插值用到的公有指针，分别存放i h ，i α，i β，i a ，i b ，i c ，i d 和i m};其中，有参数的构造函数为CInterpolation(float *x1, float *y1, int n1) {//动态数组x1，y1中存放结点的横、纵坐标，n1是结点下标上限（即n1+1个结点） n=n1;N=x1[n]-x1[0]; X=new float [N+1]; x=new float [n+1]; y=new float [n+1];for (int i=0;i<=n;i++) {x[i]=x1[i]; y[i]=y1[i]; }for (int i=0;i<=N;i++) X[i]=x[0]+i; }2.1 Lagrange 插值()()nn i i i P x y l x ==∑，其中0,()nj i j j ni jx x l x x x =≠-=-∏对于一个自变量x ，要求插值函数值()n P x ，首先需要计算对应的Lagrange 插值基函数值()i l x float l(float xv,int i) //求插值基函数()i l x 的值 {float t=1;for (int j=0;j<=n;j++) if (j!=i)t=t*(xv-x[j])/(x[i]-x[j]); return t; }调用函数l(float x,int i)，可求出()n P xfloat p_l(float x) //求()n P x 在一个点的插值结果 {float t=0;for (int i=0;i<=n;i++) t+=y[i]*l(x,i); return t; }调用p_l(float x)可实现整个区间的插值float *Lagrange() //求整个插值区间上所有采样点的插值结果 {float *Y=new float [N+1]; for (int k=0;k<=N;k++) Y[k]=p_l(x[0]+k*h); return Y; } 2.2Newton 插值010()(,,)()nn i i i P x f x x x x ω==∑，其中101,0()(),0i i j j i x x x i ω-==⎧⎪=⎨-≠⎪⎩∏，0100,()(,,)()ik i nk k j j j kf x f x x x x x ==≠=-∑∏对于一个自变量x ，要求插值函数值()n P x ，首先需要计算出01(,,)i f x x x 和()i x ωfloat *f() {//该函数的返回值是一个长度为n ＋1的动态数组，存放各阶差商 }float w(float x, int i) {//该函数计算()i x ω }在求()n P x 的函数中调用*f()得到各阶差商，然后在循环中调用w(float x)可得出插值结果 float p_n(float x) {//该函数计算()n P x 在一点的值 }调用p_n(float x)可实现整个区间的插值 float *Newton() {//该函数计算出插值区间内所有点的值 }2.3 三次样条插值三次样条插值程序可分为以下四步编写： （1） 计算结点间的步长i hi 、i α、i β；（2） 利用i hi 、i α、i β产生三对角方程组的系数矩阵和常数向量； （3） 通过求解三对角方程组，得出中间结点的导数i m ； （4） 对自变量x ，在对应区间1[,]i i x x +上，使用Hermite 插值； （5）调用上述函数，实现样条插值。
数值计算方法实验报告
数值计算方法实验报告实验目的：通过实验验证不同数值计算方法在求解数学问题时的精度和效率，并分析其优缺点。
实验原理：实验内容：本实验选取了三个典型的数值计算问题，并分别采用了二分法、牛顿迭代法和梯度下降法进行求解。
具体问题和求解方法如下：1. 问题一：求解方程sin(x)=0的解。
-二分法：利用函数值的符号变化将解空间不断缩小，直到找到满足精度要求的解。
-牛顿迭代法：通过使用函数的斜率来逼近方程的解，并不断逼近真实解。
-梯度下降法：将方程转化为一个极小化问题，并利用梯度下降的方式逼近极小值点，进而找到方程的解。
2.问题二：求解函数f(x)=x^2-3x+2的极小值点。
-二分法：通过确定函数在一个区间内的变化趋势，将极小值所在的区间不断缩小，从而找到极小值点。
-牛顿迭代法：通过使用函数的导数和二阶导数来逼近极小值点，并不断逼近真实解。
-梯度下降法：将函数转化为一个极小化问题，并利用梯度下降的方式逼近极小值点，进而找到函数的极小值点。
3. 问题三：求解微分方程dy/dx = -0.1*y的解。
-二分法：通过离散化微分方程，将微分方程转化为一个差分方程，然后通过迭代计算不同点的函数值，从而得到函数的近似解。
-牛顿迭代法：将微分方程转化为一个积分方程，并通过迭代计算得到不同点的函数值，从而得到函数的近似解。
-梯度下降法：将微分方程转化为一个极小化问题，并利用梯度下降的方式逼近极小值点，从而得到函数的近似解。
实验步骤：1.编写代码实现各个数值计算方法的求解过程。
2.对每个数值计算问题，设置合适的初始值和终止条件。
3.运行程序，记录求解过程中的迭代次数和每次迭代的结果。
4.比较不同数值计算方法的精度和效率，并分析其优缺点。
实验结果：经过实验测试，得到了如下结果：-问题一的二分法迭代次数为10次，求解结果为x=0；牛顿迭代法迭代次数为4次，求解结果为x=0；梯度下降法迭代次数为6次，求解结果为x=0。
-问题二的二分法迭代次数为10次，求解结果为x=1;牛顿迭代法迭代次数为3次，求解结果为x=1;梯度下降法迭代次数为4次，求解结果为x=1-问题三的二分法迭代次数为100次，求解结果为y=e^(-0.1x);牛顿迭代法迭代次数为5次，求解结果为y=e^(-0.1x);梯度下降法迭代次数为10次，求解结果为y=e^(-0.1x)。
东南大学计算方法实验报告
计算方法与实习实验报告学院：电气工程学院指导老师：***班级：160093******学号：********实习题一实验1 拉格朗日插值法一、方法原理n次拉格朗日插值多项式为：L n(x)=y0l0(x)+y1l1(x)+y2l2(x)+…+y n l n(x)n=1时，称为线性插值，L1(x)=y0(x-x1)/(x0-x1)+ y1(x-x0)/(x1-x0)=y0+(y1-x0)(x-x0)/(x1-x0)n=2时，称为二次插值或抛物线插值，精度相对高些L2(x)=y0(x-x1)(x-x2)/(x0-x1)/(x0-x2)+y1(x-x0)(x-x2)/(x1-x0)/(x1-x2)+y2(x-x0)(x-x1)/(x2-x0)/(x2-x1)二、主要思路使用线性方程组求系数构造插值公式相对复杂，可改用构造方法来插值。
对节点x i(i=0,1,…,n)中任一点x k(0<=k<=n)作一n 次多项式l k(x k)，使它在该点上取值为1，而在其余点x i(i=0,1,…,k-1,k+1,…,n)上为0，则插值多项式为L n(x)=y0l0(x)+y1l1(x)+y2l2(x)+…+y n l n(x) 上式表明：n 个点x i(i=0,1,…,k-1,k+1,…,n)都是l k(x)的零点。
可求得l k三．计算方法及过程：1.输入节点的个数n2.输入各个节点的横纵坐标3.输入插值点4.调用函数，返回z函数语句与形参说明程序源代码如下：#include<iostream>#include<math.h>using namespace std;#define N 100double fun(double *x,double *y, int n,double p);void main(){int i,n;cout<<"输入节点的个数n：";cin>>n;double x[N], y[N],p;cout<<"please input xiangliang x= "<<endl;for(i=0;i<n;i++)cin>>x[i];cout<<"please input xiangliang y= "<<endl;for(i=0;i<n;i++)cin>>y[i];cout<<"please input LagelangrichazhiJieDian p= "<<endl;cin>>p;cout<<"The Answer= "<<fun(x,y,n,p)<<endl;system("pause") ;}double fun(double x[],double y[], int n,double p){double z=0,s=1.0;int k=0,i=0;double L[N];while(k<n){ if(k==0){ for(i=1;i<n;i++)s=s*(p-x[i])/(x[0]-x[i]);L[0]=s*y[0];k=k+1;}else{s=1.0;for(i=0;i<=k-1;i++)s=s*((p-x[i])/(x[k]-x[i]));for(i=k+1;i<n;i++) s=s*((p-x[i])/(x[k]-x[i]));L[k]=s*y[k];k++;}}for(i=0;i<n;i++)z=z+L[i];return z;}五．实验分析n=2时，为一次插值，即线性插值n=3时，为二次插值，即抛物线插值n=1，此时只有一个节点，插值点的值就是该节点的函数值n<1时，结果都是返回0的；这里做了n=0和n=-7两种情况3<n<100时，也都有相应的答案常用的是线性插值和抛物线插值，显然，抛物线精度相对高些n次插值多项式Ln（x）通常是次数为n的多项式，特殊情况可能次数小于n.例如：通过三点的二次插值多项式L2(x),如果三点共线，则y=L2(x)就是一条直线，而不是抛物线，这时L2(x)是一次式。
计算方法实验报告
计算方法实验报告班级：学号：姓名：时间：成绩：题目：分别用单点弦截法和双点弦截法求方程310x x --=的在1.5附近的根，并分析比较两种方法。
要求误差不超过410-一、 单点弦截法算法： =-(-) k=0,1,…1) 输入两个相近的初值和,误差限ε，最大允许迭代次数为N2) 设置n=13) 计算=-()4) <ε,则输出x=，停机，否则转（5）5) 若n < N,n+1n,转（3）且（3）式中的为所输入的初始值程序：Private Sub Command1_Click()Dim n As Integersing1 = Text1.Text ‘设置方程的系数sing2 = Text2.Textsing3 = Text3.Textsing4 = Text4.Textsing5 = Text5.Textsing6 = Text6.Textx0 = sing5: x1 = sing6 ‘设置迭代初值Do While Abs(x1 - x0) > 0.0001 ‘迭代过程n = n + 1 ‘迭代次数x2 = x1 - F(x1) * (x1 - Val(Text5.Text)) / (F(x1) - F(Val(Text5.Text))) ‘迭代表达式List1.AddItem "n=" & n & Space(4) & x2x0 = x1x1 = x2LoopText7.Text = x2End Sub二、双点弦截法算法：=-(-)1)输入选定的两个相近的初始值和，误差限ε，最大迭代次数N2)设置n=13）计算=-()4）若<ε,则输出x=，停机，否则转（5）5）若n < N,n+1n,转（3）程序：Private Sub Command2_Click()Dim n As Integerx0 = sing5: x1 = sing6Do While Abs(x1 - x0) > 0.0001n = n + 1x2 = x1 - F(x1) * (x1 - x0) / (F(x1) - F(x0))List2.AddItem "n=" & n & Space(4) & x2x0 = x1x1 = x2LoopText8.Text = x2End Sub其中的全局变量定义以及自定义函数过程程序：全局变量定义：Option ExpliciPublic sing1 As Single, sing2 As Single, sing3 As Single, sing4 As Single, sing5 As Single, sing6 As SinglePublic x0 As Single, x1 As Single, x2 As Single自定义函数过程：Private Function F(x As Single) As SingleF = sing1 * x ^ 3 + sing2 * x ^ 2 + sing3 * x + sing4 End Function运行结果：结果与分析：由程序运行结果可知在精度为10^-4时，单点弦截法的迭代结果为x=1.324723,而双点弦截法的迭代结果为x=1.324718结果分析：用单点弦截法迭代需要5次，而双点弦截法所需的迭代次数为4次。
计算方法-解线性方程组的直接法实验报告
cout<<endl;
for(k=i+1;k<m;k++)
{
l[k][i]=a[k][i]/a[i][i];
for(r=i;r<m+1;r++) /*化成三角阵*/
a[k][r]=a[k][r]-l[k][i]*a[i][r];
}
}
x[m-1]=a[m-1][m]/a[m-1][m-1];
{
int i,j;
float t,s1,s2;
float y[100];
for(i=1;i<=n;i++) /*第一次回代过程开始*/
{
s1=0;
for(j=1;j<i;j++)
{
t=-l[i][j];
s1=s1+t*y[j];
}
y[i]=(b[i]+s1)/l[i][i];
}
for(i=n;i>=1;i--) /*第二次回代过程开始*/
s2=s2+l[i][k]*u[k][r];
l[i][r]=(a[i][r]-s2)/u[r][r];
}
}
printf("array L:\n");/*输出矩阵L*/ for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
printf("%7.3f ",l[i][j]);
printf("\n");
{
s2=0;
for(j=n;j>i;j--)
计算方法实验报告(附代码)
实验一 牛顿下山法实验说明：求非线性方程组的解是科学计算常遇到的问题，有很多实际背景．各种算法层出不穷，其中迭代是主流算法。
只有建立有效的迭代格式，迭代数列才可以收敛于所求的根。
因此设计算法之前，对于一般迭代进行收敛性的判断是至关重要的。
牛顿法也叫切线法，是迭代算法中典型方法，只要初值选取适当，在单根附近，牛顿法收敛速度很快，初值对于牛顿迭代 至关重要。
当初值选取不当可以采用牛顿下山算法进行纠正。
牛顿下山公式：)()(1k k k k x f x f x x '-=+λ下山因子 ，，，，322121211=λ下山条件|)(||)(|1k k x f x f <+实验代码：#include<iostream> #include<iomanip> #include<cmath>using namespace std;double newton_downhill(double x0,double x1); //牛顿下山法函数，返回下山成功后的修正初值double Y; //定义下山因子Y double k; //k为下山因子Y允许的最小值double dfun(double x){return 3*x*x-1;} //dfun()计算f(x)的导数值double fun1(double x){return x*x*x-x-1;} //fun1()计算f(x)的函数值double fun2(double x) {return x-fun1(x)/dfun(x);} //fun2()计算迭代值int N; //N记录迭代次数double e; //e表示要求的精度int main(){double x0,x1;cout<<"请输入初值x0:";cin>>x0;cout<<"请输入要求的精度:";cin>>e;N=1;if(dfun(x0)==0){cout<<"f'(x0)=0,无法进行牛顿迭代!"<<endl;}x1=fun2(x0);cout<<"x0"<<setw(18)<<"x1"<<setw(18)<<"e"<<setw(25)<<"f(x1)-f(x0)"<<endl;cout<<setiosflags(ios::fixed)<<setprecision(6)<<x0<<" "<<x1<<" "<<fabs(x1-x0)<<" "<<fabs(fun1(x1))-fabs(fun1(x0))<<endl;if(fabs(fun1(x1))>=fabs(fun1(x0))){ //初值不满足要求时,转入牛顿下山法x1=newton_downhill(x0,x1);} //牛顿下山法结束后,转入牛顿迭代法进行计算while(fabs(x1-x0)>=e){ //当精度不满足要求时N=N+1;x0=x1;if(dfun(x0)==0){cout<<"迭代途中f'(x0)=0,无法进行牛顿迭代!"<<endl;} x1=fun2(x0);cout<<setiosflags(ios::fixed)<<setprecision(6)<<x0<<" "<<x1<<" "<<fabs(x1-x0)<<endl;}cout<<"迭代值为:"<<setiosflags(ios::fixed)<<setprecision(6)<<x1<<'\n';cout<<"迭代次数为:"<<N<<endl;return 0;}double newton_downhill(double x0,double x1){Y=1;cout<<"转入牛顿下山法,请输入下山因子允许的最小值:";cin>>k;while(fabs(fun1(x1))>=fabs(fun1(x0))){if(Y>k){Y=Y/2;}else {cout<<"下山失败!";exit(0);}x1=x0-Y*fun1(x0)/dfun(x0);}//下山成功则cout<<"下山成功!Y="<<Y<<",转入牛顿迭代法计算!"<<endl;return x1;}实验结果：图4.1G-S 迭代算法流程图实验二 高斯-塞德尔迭代法实验说明：线性方程组大致分迭代法和直接法。
计算方法实验报告
实验一：误差传播与算法稳定性实验目的：体会稳定性在选择算法中的地位。
实验内容：考虑一个简单的由积分定义的序列10I ,0,1,10nn x dx n a x==+⎰其中a 为参数，分别对0.05a =及15a =按下列两种方法计算。
方案1：用递推公式11,1,2,,10n n I aI n n-=-+= 递推初值可由积分直接得01lna I a+= 方案2：用递推公式111(),,1,,1n n I I n N N a n-=-+=-根据估计式当1n a n ≥+时，11(1)(1)(1)n I a n a n <<+++或当01n a n ≤<+时，11(1)(1)n I a n n<≤++ 取递推初值 当1n a n ≥+时， 11121()2(1)(1)(1)2(1)(1)N N a I I a N a N a a N +≈+=+++++ 当01n a n ≤<+时，111()2(1)(1)N N I I a N N≈+++ 实验要求：列出结果，并对其稳定性进行分析比较，说明原因。
实验二：非线性方程数值解法实验目的：探讨不同方法的计算效果和各自特点 实验内容：应用算法（1）牛顿法；（2）割线法 实验要求：（1）用上述各种方法，分别计算下面的两个例子。
在达到精度相同的前提下，比较其迭代次数。
（I ）31080x x +-=，取00x =；(II) 2281(0.1)sin 1.060x x x -+++=，取00x =；（2） 取其它的初值0x ，结果如何？反复选取不同的初值，比较其结果； （3） 总结归纳你的实验结果，试说明各种方法的特点。
实验三：选主元高斯消去法----主元的选取与算法的稳定性问题提出：Gauss 消去法是我们在线性代数中已经熟悉的。
但由于计算机的数值运算是在一个有限的浮点数集合上进行的，如何才能确保Gauss 消去法作为数值算法的稳定性呢？Gauss 消去法从理论算法到数值算法，其关键是主元的选择。
计算方法实验报告 拟合
南京信息工程大学实验（实习）报告
一、实验目的:
用最小二乘法将给定的十个点拟合成三次多项式。
二、实验步骤：
用matlab编制以函数为基的多项式最小二乘拟合程序，并用于对下列数据作三次多项式最小二乘拟合(取权函数wi=1)
给定直线方程为：y=1/4*x3+1/2*x2+x+1
三、实验结论：
最小二乘法：通过最小化误差的平方和寻找数据的最佳函数匹配。
利用最小二乘法可以简便地求得未知的数据，并使得这些求得的数据与实际数据之间误差的平方和为最小。
最小二乘法还可用于曲线拟合。
一般地。
当测量数据的散布图无明显的规律时，习惯上取n次代数多项式。
程序运行结果为：
a =
0.9731
1.1023
0.4862
0.2238
即拟合的三次方程为：y=0.9731+1.1023x+0.4862*x2+0.2238*x3
x 轴
y 轴
拟合图
结论：
一般情况下，拟合函数使得所有的残差为零是不可能的。
由图形可以看出最小二乘解决了残差的正负相互抵消的问题，使得拟合函数更加密合实验数据。
优点：曲线拟合是使拟合函数和一系列的离散点与观测值的偏差平方和达到最小。
缺点：由于计算方法简单，若要保证数据的精确度，需要大量的数据代入计算。
计算方法实验报告_列主元高斯消去法
row_first=A[i][i]; for(int j=0;j<n+1;j++)
计算方法实验报告
{ A[i][j]=A[i][j]/row_first;
} }
for(int k=n-1;k>0;k--) {
for(int i=0;i<N;i++) {
for(int j=0;j<N;j++) {
A_B[i][j]=A[i][j]; } A_B[i][N]=B[i][0]; } return A_B; }
3
//输出矩阵 A 的 row x col 个元素 void Show_Matrix(double **A,int row,int col) {
for(int i=0;i<N;i++)
{
int row=Choose_Colum_Main_Element(N,A_B,i);
if(Main_Element<=e) goto A_0;
Exchange(A_B,N+1,row,i);
Elimination(N,A_B,i);
cout<<"选取列主元后第"<<i+1<<"次消元:"<<endl;
double factor; for(int i=start+1;i<n;i++) {
factor=A[i][start]/A[start][start]; for(int j=start;j<n+1;j++) {
计算方法实验报告
1. 熟悉并掌握常用的计算方法，包括数值积分、数值微分、线性方程组求解等。
2. 培养运用计算机进行数值计算的能力。
3. 增强对数值计算误差的分析和判断能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.83. 库：NumPy、SciPy、Matplotlib三、实验内容1. 数值积分（1）函数：f(x) = x^2（2）区间：[0, 1]（3）方法：梯形法、辛普森法、复合梯形法2. 数值微分（1）函数：f(x) = e^x（2）点：x = 1（3）方法：有限差分法、中点法、牛顿法3. 线性方程组求解（1）方程组：2x + 3y - z = 8-x + 2y + 2z = -3x - y + 3z = 5（2）方法：高斯消元法、LU分解法1. 数值积分（1）编写函数f(x) = x^2（2）定义积分区间[0, 1]（3）实现梯形法、辛普森法、复合梯形法（4）计算积分结果2. 数值微分（1）编写函数f(x) = e^x（2）定义点x = 1（3）实现有限差分法、中点法、牛顿法（4）计算导数结果3. 线性方程组求解（1）定义方程组系数矩阵A和常数向量b（2）实现高斯消元法、LU分解法（3）求解方程组（4）输出解向量x五、实验结果与分析1. 数值积分（1）梯形法：积分结果约为1.6667（2）辛普森法：积分结果约为1.6447（3）复合梯形法：积分结果约为1.6458分析：三种方法计算结果接近，但辛普森法误差最小。
2. 数值微分（1）有限差分法：导数结果约为2.7183（2）中点法：导数结果约为2.7183（3）牛顿法：导数结果约为2.7183分析：三种方法计算结果一致，误差较小。
3. 线性方程组求解（1）高斯消元法：解向量x = [2, 1, 1]（2）LU分解法：解向量x = [2, 1, 1]分析：两种方法求解结果一致，且解向量正确。
六、实验总结本次实验通过Python编程，实现了数值积分、数值微分和线性方程组求解。
计算方法 实验报告 拉格朗日 龙贝格 龙格库塔
主界面：
/*lagrange.c*/
float real_value(float x) /*由被插值函数计算真实值*/
c=getchar();
if(c=='N'||c=='n') break;
}
}
/*romberg.c*/
double function(double x) /*被积函数*/
{
return 4.0/(1+(x)*(x));
}
double t(double a,double b,int m) /*计算T1*/
实验二（龙贝格公式）
§公式
§算法描述
§流程图
§运行结果
§结果分析：Romberg积分法是在积分步长逐步折半的过程中，用低精度求积公式的组合得到更高精度求积公式的一种方法，它算法简单，且收敛加速效果极其显著。
实验三（四阶龙格库塔）
§公式
k1=h*f(xn,yn);
k2=h*f(xn+h/2,yn+k1/2);
T1=t(a,b,0);
T2=T1/2.0+t(a,b,1);
S1=(4*T2-T1)/3.0;
T1=T2;
T2=T1/2.0+t(a,b,2);
S2=(4*T2-T1)/3.0;
C1=(16*S2-S1)/15.0;
T1=T2;
T2=T1/2.0+t(a,b,3);
S1=S2;
S2=(4*T2-T1)/3.0;
数值计算方法实验报告
数值计算方法实验报告一、实验目的本实验旨在通过Python语言编写数值计算方法程序，掌握常见数值计算方法的实现原理及应用。
具体包括：插值法、最小二乘法、数值微积分、数值解方程、数值解微分方程等。
二、实验环境Python编程语言、Jupyter Notebook环境三、实验内容1.插值法（1）代码实现：在Python中使用Scipy库中的Interpolate模块实现拉格朗日插值法和牛顿插值法，并通过数据可视化展示其效果。
（2）实验步骤：- 导入所需库，准备所需数据；- 定义拉格朗日插值法函数；- 定义牛顿插值法函数；- 测试函数并可视化结果。
（3）实验结果：2.最小二乘法（1）代码实现：在Python中使用Numpy库实现最小二乘法，并通过数据可视化展示其效果。
（2）实验步骤：- 导入所需库，准备所需数据；- 定义最小二乘法函数；- 测试函数并可视化结果。
（3）实验结果：3.数值微积分（1）代码实现：在Python中实现梯形法和辛普森法，并通过数据可视化展示其效果。
（2）实验步骤：- 导入所需库，准备所需数据；- 定义梯形法函数和辛普森法函数；- 测试函数并可视化结果。
（3）实验结果：4.数值解方程（1）代码实现：在Python中实现二分法、牛顿法和割线法，并通过数据可视化展示其效果。
（2）实验步骤：- 导入所需库，准备所需数据；- 定义二分法函数、牛顿法函数和割线法函数；- 测试函数并可视化结果。
（3）实验结果：5.数值解微分方程（1）代码实现：在Python中实现欧拉法和龙格-库塔法，并通过数据可视化展示其效果。
（2）实验步骤：- 导入所需库，准备所需数据；- 定义欧拉法函数和龙格-库塔法函数；- 测试函数并可视化结果。
（3）实验结果：四、实验总结通过本次实验，我学习了数值计算方法的常用算法和实现原理，掌握了Python 语言实现数值计算方法的方法，加深了对数值计算方法的理解和应用。
实验中遇到的问题，我通过查找资料和与同学的讨论得到了解决，也更加熟练地掌握了Python语言的使用。
计算方法实验报告(2)----Gauss列主元法
计算方法实验报告实验名称：班级：学生姓名：学号：班级序号：课内序号:指导老师：2018-2019学年第2学期一、实验名称：Gauss消去法二、实验学时: 2学时三、实验目的和要求1、掌握高斯列主元法基础原理2、掌握高斯列主元法解方程组的步骤3、能用程序语言对Gauss列主元法进行编程实现四、实验过程代码及结果1、代码：using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;namespace ConsoleApplication_Gauss{public class GaussBase{private double[,] a;public double[,] A{get { return a; }set { a = value; }}private double[] x;public double[] X{get { return x; }set { x = value; }}public int n;public void CalcuX(){for (int i = n - 1; i >= 0; i--){double sum = 0;for (int j = i + 1; j < n; j++){sum += a[i, j] * x[j];}x[i] = (a[i, n] - sum) / a[i, i];}}public virtual void CalcuA(){}public void Output(){for (int i = 0; i < n; i++){//string s="";for (int j = 0; j <= n; j++){//s += string.Format("{0,-4}", a[i, j]);Console.Write("{0,6}", a[i, j]);}Console.WriteLine();}}public void Output(bool isX){Console.WriteLine("------最终的解为：----------");for (int i = 0; i < n; i++){Console.WriteLine("x[{0}]={1}", i, x[i]);}}public void Input(){Console.WriteLine("请输入方程阶数N：");n = int.Parse(Console.ReadLine());a = new double[n, n + 1];x = new double[n];Console.WriteLine("请输入方程系数A（i,j)：");for (int i = 0; i <= n - 1; i++){string s = Console.ReadLine();string[] ss = s.Split(' ');for (int j = 0; j <= n; j++){a[i, j] = Convert.ToDouble(ss[j]);}}}public void Calcu(){//Input();Console.WriteLine("------原始的矩阵为：----------");Output();CalcuA();Console.WriteLine("------应用高斯列主元法消元之后的矩阵A（i,j)为：----------");Output();CalcuX();Output(true);}public class GaussCol : GaussBase{public int FindMaxCol(int k){int ik = k;for (int i = k; i < n; i++){if (Math.Abs(A[i, k]) > Math.Abs(A[ik, k])){ik = i;}}if (A[ik, k] == 0) return -1;if (ik != k){for (int j = k; j <= n; j++){double t = A[ik, j];A[ik, j] = A[k, j];A[k, j] = t;}}return ik;}public override void CalcuA(){for (int k = 0; k < n - 1; k++){//-----------------------------------------int ik = FindMaxCol(k);//------------------------------------for (int i = k + 1; i < n; i++){//double Lik = a[i, k] / a[k, k];// for (int j = k ; j <= n; j++)for (int j = n; j >= k; j--){A[i, j] = A[i, j] - A[i, k] / A[k, k] * A[k, j];}//a[i, k] = 0;}//Output}}}class Program{static void Main(string[] args){GaussBase obj = new GaussCol();obj.Input();obj.Calcu();Console.ReadLine();}}}}2、结果：。
《计算方法》实验报告材料
double Newton(double x,vector<double>&X,vector<double>&Y);
int main(){
char a='n';
do{
int n;
cout<<"请输入插值点个数："<<endl;
for(int i=0;i<N;i++){
X[i]=p;
Y[i]=1/(1+p*p);
p=p+c;
}
cout<<"请输入要求值x的值："<<endl;
double x;
cin>>x;
double result=fenduan(N,X,Y,x,c);
cout<<"由分段线性插值法得出结果： "<<result<<endl;
cin>>n;
vector<double>X(n,0);
vector<double>Y(n,0);
cout<<"请输入插值点对应的值及函数值(Xi,Yi)："<<endl;
for(int i=0;i<n;i++){
cin>>X[i]>>Y[i];
}
cout<<"请输入要求值x的值："<<endl;
数值计算方法实验报告
数值计算方法实验报告一、实验目的本实验旨在通过数值计算方法的实验操作，深入理解数值计算方法的原理与应用，掌握数值计算方法的相关技能，提高数值计算方法的实际应用能力。
二、实验内容1.数值微积分2.数值代数3.数值微分方程4.数值线性代数5.数值优化6.数值统计分析7.数值随机模拟8.数值傅立叶分析9.数值偏微分方程三、实验步骤1.数值微积分：通过不同的数值积分方法，计算给定函数的定积分值，并对不同数值积分方法的误差进行分析。
2.数值代数：通过使用线性代数方法，求解给定的线性方程组，并分析不同线性方程组求解方法的优劣。
3.数值微分方程：通过使用常微分方程数值解法，求解给定的微分方程，并比较不同求解方法的精度和稳定性。
4.数值线性代数：通过使用特征值分解方法，对给定的矩阵进行特征值分解，并分析不同特征值分解方法的优缺点。
5.数值优化：通过使用不同的优化方法，求解给定的优化问题，并比较不同的优化方法的效率和精度。
6.数值统计分析：通过使用不同的统计分析方法，对给定的数据进行统计分析，并分析不同的统计方法的优缺点。
7.数值随机模拟：通过使用随机模拟方法，模拟给定的概率分布，并分析不同随机模拟方法的效率和精度。
8.数值傅立叶分析：通过使用傅立叶分析方法，对给定的信号进行频谱分析，并分析不同的傅立叶分析方法的优缺点。
9.数值偏微分方程：通过使用偏微分方程数值解法，求解给定的偏微分方程，并比较不同求解方法的精度和稳定性。
四、实验结果与分析本实验中，通过对不同的数值计算方法的实验操作，我们可以更深入地理解数值计算方法的原理与应用，并掌握数值计算方法的相关技能，提高数值计算方法的实际应用能力。
同时，通过实验结果的分析，我们可以更好地比较不同数值计算方法的优缺点，为实际应用提供参考依据。
五、实验总结本实验旨在通过数值计算方法的实验操作，深入理解数值计算方法的原理与应用，掌握数值计算方法的相关技能，提高数值计算方法的实际应用能力。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
计算方法实验报告实验报告一、求方程fxx3-sinx-12x1的全部根, ε1e-6 1、用一般迭代法; 2、用牛顿迭代法; 并比较两种迭代的收敛速度。
一、首先，由题可求得. 其次，分析得到其根所在的区间。
①令，可得到. ②用一阶导数分析得到和两个函数的增减区间；再用二阶导数分析得到两个函数的拐点以及凹凸区间. ③在直角坐标轴上描摹出和的图，在图上可以看到他们的交点，然后估计交点所在的区间，即是所要求的根的区间。
经过估计，得到根所在的区间为，和. 1、一般迭代法（1）算法步骤设为给定的允许精度，迭代法的计算步骤为①选定初值.由确定函数，得等价形式. ②计算.由迭代公式得.③如果，则迭代结束，取为解的近似值；否则，用代替，重复步骤②和步骤③. （2）程序代码①在区间内，代码clc x0-3.5; 初值iter_max100; 迭代的最大次数ep1e-6; 允许精度k0; while kiter_max k从0开始到iter_max循环x1sinx012*x0-1.1/3; 代入，算出的值if absx1-x0ep 与允许精度作比较break; 条件成立，跳出循环end x0x1; 条件不成立，用代替kk1; k加1 end x_starx1, iterk 为解的近似值，iter为迭代次数运行结果x_star -3.4101 ；iter 14 ②在区间内，代码clc x00.5; 初值iter_max100; 迭代的最大次数ep1e-6; 允许精度k0; while kiter_max k从0开始到iter_max循环x11/12*x0.3-sinx01; 代入，算出的值if absx1-x0ep 与允许精度作比较break; 条件成立，跳出循环end x0x1; 条件不成立，用代替kk1; k加1 end x_starx1, iterk 为解的近似值，iter 为迭代次数结果x_star 0.07696；iter 6 ③在区间内，代码clc x03.5; 初值iter_max100; 迭代的最大次数ep1e-6; 允许精度k0; while kiter_max k从0开始到iter_max循环x1sinx012*x0-1.1/3; 代入，算出的值if absx1-x0ep 与允许精度作比较break; 条件成立，跳出循环end x0x1; 条件不成立，用代替kk1; k加1 end x_starx1, iterk 为解的近似值，iter 为迭代次数运行结果x_star 3.4101 ；iter 10 2、牛顿迭代法（1）算法步骤①选定初值，计算，. ②按公式迭代，得新的近似值，并计算，. ③对于给定的允许精度，如果，则终止迭代，取；否则，，在转回步骤②计算. （2）程序代码①在区间内，clc x1-3.5; 初值k0; while k100 k从0开始到100循环x0x1; 将初值赋给f0x0.3-sinx0-12*x01; 计算f13*x0.2-cosx0-12; 计算x1x0-f0/f1; 计算得到新的近似值if absx1-x0 1.0e-6 与允许精度作比较break; 条件成立，跳出循环end kk1; 条件不成立，k加1 end x_starx1, iterk 为解的近似值，iter为迭代次数运行结果x_star -3.4911；iter 2 ②在区间内，clc x10.5; 初值k0; while k100 k从0开始到100循环x0x1; 将初值赋给f0x0.3-sinx0-12*x01; 计算f13*x0.2-cosx0-12; 计算x1x0-f0/f1; 计算得到新的近似值if absx1-x0 1.0e-6 与允许精度作比较break; 条件成立，跳出循环end kk1; 条件不成立，k加1 end x_starx1, iterk 为解的近似值，iter为迭代次数运行结果x_star 0.07696 ；iter 3 ③在区间内，clc x13.5; 初值k0; while k100 k从0开始到100循环x0x1; 将初值赋给f0x0.3-sinx0-12*x01; 计算f13*x0.2-cosx0-12; 计算x1x0-f0/f1; 计算得到新的近似值if absx1-x0 1.0e-6 与允许精度作比较break; 条件成立，跳出循环end kk1; 条件不成立，k加1 end x_starx1, iterk 为解的近似值，iter为迭代次数运行结果x_star 3.4101；iter 3 3、运行结果x_star iter x_star iter x_star iter 一般迭代3.4101 14 0.7696 6 3.4101 10 牛顿法3.4911 2 0.70696 3 3.4101 3 4、结果分析从这题的结果可以看出，牛顿迭代法的迭代速度比一般迭代法的速度要快，牛顿法的迭代次数比较少。
例如，求在的根时，一般迭代法迭代了14次（iter 14），而牛顿法只用了2次（iter 2）。
总而言之，一般迭代法是一种逐次逼近的方法，具有原理简单、编制程序方便等优点，但存在是否收敛和收敛速度的快慢等问题。
牛顿迭代法是一种特殊的迭代法，用于求方程的单根时具有2阶收敛。
因此是一种求非线性方程解的好方法，还可以用于求重根和复根，而且可以推广到求非线性方程组的解.二、解方程组直接法1、已知对矩阵A做LU分解。
2、用追赶法解下述方程组，并给出n10的结果，其中，1、杜利特尔分解法（直接三角分解法）设方程组的系数矩阵的各阶主子式，则可知该方程组存在唯一的杜利特尔分解，其中，. 我们记矩阵的第行第列元素为，则矩阵的第一行和的第一列可由公式（1.1）求出（2.1）再由公式（2.2）求出的第行、的第列元素（2.2）（1）算法步骤由于系数矩阵的各阶主子式，则可知该方程组存在唯一的杜利特尔分解。
①利用公式（2.1）和（2.2）求出和的元素和。
②求解单位下三角形方程组，即按公式（2.3）求出。
④求解上三角形方程组，即按公式（2.4）可求得方程组的解。
（2）程序代码function [L,U]LUA A [n,n]sizeA; 定义为阶矩阵Lzerosn,n; 矩阵初始化Uzerosn,n; 矩阵初始化for i1n Li,i1; 矩阵的对角线元素为 1 end for k1n for jkn Uk,jAk,j-sumLk,1k-1.*U1k-1,j ; 求出元素end for ik1n Li,kAi,k-sumLi,1k-1.*U1k-1,k /Uk,k; 求出的元素end end A[4 2 1 5;8 7 2 10;4 8 3 6;12 6 11 20]; 矩阵[L,U]LUA 2、追赶法设所求方程组为，（2.5）（1）算法步骤①由方程组的第1个方程，将未知元用表示为记，，得。
①以此类推，用表示，用表示。
我们可以得到一般式（其中记）（2.6）（2.7）②将代入方程组（2.5）的第n个方程，并解出得，上式右端恰好是式（2.6）的。
于是，可由式（2.7）求出三对角方程组的解，即，（2.8）（2）程序代码clc a[0 1 1 1 1 1 1 1 1 1]; b[2 2 2 2 2 2 2 2 2 2]; c[1 1 1 1 1 1 1 1 1 0]; r[-7 -5 -5 -5 -5 -5 -5 -5 -5 -5]; u[0 0 0 0 0 0 0 0 0 0]; v[0 0 0 0 0 0 0 0 0 0]; x[0 0 0 0 0 0 0 0 0 0]; u1r1/b1; 计算v1c1/b1; 计算for k210 ukrk-uk-1*ak/bk-vk-1*ak; 计算vkck/bk-vk-1*ak; 计算end x10u10; for k19 xkuk-vk*xk1; 由，解出end x 运行结果x[-3.5000 -1.0000 -3.0000 -1.6000 -2.8333 -1.8571 -2.7500 -2.0000 -0.8182 -2.0909] 3、运行结果（1）杜利特尔分解法（2）追赶法。
4、结果分析（1）杜利特尔分解法在实现分解后，解具有相同系数矩阵的方程组，非常方便，每解一个方程只需用式（2.3）和式（2.4）解两个三角形方程组即可，大大减少了运算工作量。
另外，矩阵和的元素可采用紧凑格式存放在系数矩阵的相应元素位置上，节省了存储单元。
（2）追赶法追赶法仅适用于三对角方程组的求解。
我们由式（2.6）和式（2.8）可以算出，追赶法的乘、除运算次数仅为，加、减运算次数仅为。
故追赶法具有运算量小和存储量小的优势。
三、解方程组迭代法1、用迭代法解Axb，其中b5，5，，5T，给定误差，用Jacobi和SOR两种迭代法计算，并给出n10的结果。
对于阶方程组，假定系数矩阵的对角元时，可得雅可比迭代格式为，（3.1）记为方程组的系数矩阵的对角元组成的对角阵，和分别为由的元素组成的严格下三角阵和上三角阵，则系数矩阵可分解为. 1、Jacobi（雅可比）迭代法（1）算法步骤①根据矩阵，算出矩阵、和，即，，。
②计算雅可比迭代矩阵. ③计算矩阵. ④代入给出的初值，得到雅可比迭代公式（3.1）的矩阵形式. 3.2 由式（3.2）就可以得到向量序列. （2）程序代码clc A[3 -1/2 -1/4 0 0 0 0 0 0 0;-1/2 3 -1/2 -1/4 0 0 0 0 0 0; -1/4 -1/2 3 -1/2 -1/4 0 0 0 0 0;0 -1/4 -1/2 3 -1/2 -1/4 0 0 0 0; 0 0 -1/4 -1/2 3 -1/2 -1/4 0 0 0;0 0 0 -1/4 -1/2 3 -1/2 -1/4 0 0; 0 0 0 0 -1/4 -1/2 3 -1/2 -1/4 0;0 0 0 0 0 -1/4 -1/2 3 -1/2 -1/4; 0 0 0 0 0 0 -1/4 -1/2 3 -1/2;0 0 0 0 0 0 0 -1/4 -1/2 3]; x0[0 0 0 0 0 0 0 0 0 0] ; 初值b[5 5 5 5 5 5 5 5 5 5] ; L [0 0 0 0 0 0 0 0 0 0;1/2 0 0 0 0 0 0 0 0 0; 1/4 1/2 0 0 0 0 0 0 0 0;0 1/4 1/2 0 0 0 0 0 0 0; 0 0 1/4 1/2 0 0 0 00 0;0 0 0 1/4 1/2 0 0 0 0 0; 0 0 0 0 1/4 1/2 0 0 0 0;0 0 0 0 0 1/4 1/2 0 0 0; 0 0 0 0 0 0 1/4 1/2 0 0;0 0 0 0 0 0 0 1/4 1/2 0]; U[ 0 1/2 1/4 0 0 0 0 0 0 0;0 0 1/2 1/4 0 0 0 0 0 0; 0 0 0 1/2 1/4 0 0 0 0 0;0 0 0 0 1/2 1/4 0 0 0 0; 0 0 0 0 0 1/2 1/4 0 0 0;0 0 0 0 0 0 1/2 1/4 0 0; 0 0 0 0 0 0 0 1/2 1/4 0;0 0 0 0 0 0 0 0 1/2 1/4; 0 0 0 0 0 0 0 0 0 1/2;0 0 0 0 0 0 0 0 0 0]; D[3 0 0 0 0 0 0 0 0 0; 0 3 0 0 0 0 0 0 0 0; 0 0 3 0 0 0 0 0 0 0; 0 0 0 3 0 0 0 0 0 0; 0 0 0 0 3 0 0 0 0 0; 0 0 0 0 0 3 0 0 0 0; 0 0 0 0 0 0 3 0 0 0; 0 0 0 0 0 0 0 3 0 0; 0 0 0 0 0 0 0 0 3 0; 0 0 0 0 0 0 0 0 0 3]; BJinvD*LU; 计算雅可比迭代矩阵FJinvD*b; 计算矩阵N1000; ep1e-10; 误差k0; while kiter_max k从0开始到iter_max循环x1BJ*x0fJ; 计算if normx1-x0, inf ep 与误差做比较break; 满足，跳出循环end x0x1; 不满足，将赋给kk1; k加1 end x_starx1, iterk 2、SOR（超松弛）迭代法（1）算法步骤①根据矩阵，算出矩阵、和，即，，。