数值分析期末复习总结(精选)-范文网

数值分析期末复习总结

时间过得很快，四季轮回的过程中，一年忙碌的工作时间结束。在这一年的工作中，大家通过工作，可学到更多方面的工作知识，也留下了众多的学习回忆。为记录这一年的成长，可编写一份年终总结。以下是小编精心整理的《数值分析期末复习总结》相关资料，欢迎阅读！

第一篇：数值分析期末复习总结

《软件系统分析与设计》期末复习知识点总结

一、方法论模型。

1、 BOOCH、OMT、OOSE、Coad-Yourdon(前三者组成UML)

2、 UML包括9种图，分别为用例图、静态图(包图、类图、对象图)、实现图(构件图、部署图)、行为图(活动图、状态图、交互图(顺序图、协作图))基本规范，泛化关联，包含关联，扩展关联

3、基本模型——类图、需求模型——用例图、辅助模型——其他各种图

4、两大工具：Rose、PowerDesigner

5、方法三要素：模型、工具和过程

6、结构化分析三视图模型E-R、DFD、STD

7、 OMT方法的三大模型：对象模型、功能模型、动态模型

8、 Coad/Yourdon方法的五大层次：对象-类、结构、主题、属性、服务

二、基本建模(类图与对象图)

1、类之间的关系：关联关系、依赖关系、泛化关系。

2、抽象类与接口：抽象类有些方法可以提供实现代码，接口所有的方法都没有提供实现代码。抽象类只能被继承，接口只能被实现。

3、类的版型：实体类(数据库、文件等)、边界类(如窗体、对话框)、控制类(协调交互)

三、需求建模(用例图)

1、参与者指系统以外的、需要使用系统或与系统交互的外部实体。可以分为：人、外部设备、外部系统。

2、参与者之间的关系：泛化关系，参与者与用例之间的关系：关联关系。用例之间的关系：泛化关系，包含关系，扩展关系。包含关系和扩展关系都是依赖关系的特例。

3、用例是对一个参与者使用系统的一项功能时所进行的交互过程的一个文字描述序列。是参与者可以感受到的系统服务或功能单元。

4、用例描述是一个关于参与者与系统如何交互的规范说明(包含用例用例名称、用例描述、基本事件流、参与者、前置后置条件等)

5、用例的进一步描述：活动图、顺序图(通信图)

四、行为建模(状态图与活动图)

1、行为模型包括：状态模型(状态图，单对象)、活动模型(活动图，多对象)、交互模型(顺序图，多对象)。

2、调用事件表示的是对操作的调用，变化事件一个布尔表达式变量的值发生变化。时间事件满足某一时间表达式的情况的出现。信号事件就是由一个对象异步地发送、并由另一个对象(即状态图所对应的对象)接收的已命名的实体。调用事件状态图内对象和外部对象都能发起，信号事件只能由外部发起。

3、对象处于不同的状态，导致后续要执行不同的操作。这些操作可能归属于不同的用例。一个用例的执行对应一个顺序图。顺序图刻画了多个对象之间的消息发送关系。需要多个用例的顺序图，来融合地描述一个对象的完整状态图。

4、活动表示的是某流程中的任务的执行，它可以表示某算法过程中语句的执行。

5、分叉表示的是一个控制流被两个或多个控制流代替，经过分叉后，这些控制流是并发进行的。汇合正好与分叉相反，表示两个或多个控制流被一个控制流代替。

6、泳道(swimlane)是活动图中的区域划分，根据每个活动的职责对所有活动进行划分，每个泳道代表一个责任区。关心的是其所代表的职责。

7、活动图用途：对业务过程进行建模。对某个方法具体过程建模。

8、状态与活动的区别：状态是一个对象所处的境况。通常是执行了一个(或多个)活动后的结局。活动是一段程序代码的执行，对应于若干个步骤的集成。不同的状态会导致不同的功能(对应于若干个活动)的执行。一个方法可能需要多个(也可以是一个)活动来完成。一个活动只能属于一个方法。一个用例对应于若干个活动。

五、交互建模(顺序图和协作图)

1、静态结构使用类图，动态结构使用顺序图、协作图、状态图、活动图。

2、对象：同类图中的对象，是类的实例

生命线：从对象图标向下延伸的一条虚线，表示对象存在的生命期控制焦点(激活期)：对象执行一个动作的时间段消息：对象间的一次通信

调用消息的发送者把控制传递给消息的接收者，然后停止活动，等待消息接收者放弃或返回控制。调用消息可以用来表示同步的意义。

3、顺序图一般对应一个用例。一个类中的职责对应该对象执行一个动作。

4、对象：同类图中的对象，是类的实例 ;链：对象之间的连接关系;消息：对象间的一次通信;对象生命周期：对象名称之后标以{new}约束表示创建对象，标以{destroy}约束表示销毁对象

5、协作图的建模同顺序图的建模，或者：可以从顺序图直接变换过来，或者：根据类图，画出对应的对象图。在链上附着消息。

6、顺序图和协作图的联系：都用于描述系统中对象之间的交互协作完成一项功能，彼此可以相互转换。区别：顺序图强调的是消息的时间顺序;协作图强调的是对象的空间位置关系。顺序图中有对象生命线和控制焦点;协作图中有路径，消息必须要有消息顺序号。顺序图可以表示生命线的分叉;协作图可以表示多对象、主动对象。

第二篇：数值分析学习心得报告

班级：11级软工一班

姓名：***

学号: 20117610***

指导老师：***

学习数值分析的心得体会

无意中的一次选择，让我接触了数值分析。

作为这学期的选修课，我从内心深处来讲，数值分析真的有点难。感觉它是在高等数学和线性代数的基础上，又加深了探讨。虽然这节课很难，我学的不是很好，但我依然对它比较感兴趣。下面就具体说说我的学习体会，让那些感兴趣的同学有个参考。

学习数值分析，我们首先得知道一个软件——MATLAB。MATrix LABoratory，即矩阵实验室，是Math work公司推出的一套高效率的数值计算和可视化软件。它是当今科学界最具影响力、也是最具活力的软件，它起源于矩阵运算，并高速发展成计算机语言。它的优点是强大的科学运算、灵活的程序设计流程、高质量的图形可视化与界面、便捷的与其他程序和语言接口。

根据上网搜集到的资料，你就会发现MATLAB有许多优点：

首先，编程简单使用方便。到目前为止，我已经学过C语言，机器语言，JAVA语言，这三个语言相比，我感觉C语言还是很简单的一种编程语言。只要入门就很好掌握，但是想学精一门语言可不是那么容易的。惭愧的说，到目前为止，我依然处于入门阶段，只会编写小的简单的程序，但是班里依然还是有学习好的。

C语言是简单且容易掌握的，但是，MATLAB的矩阵和向量操作功能是其他语言无法比拟的。在MATLAB环境下，数组的操作与数的操作一样简单，基本数据单元是不需要指定维数的，不需要说明数据类型的矩阵，而其数学表达式和运算规则与通常的习惯相同。

其次，函数库可任意扩充。众所周知，C语音有着丰富的函数库，我们可以随时调用，大大方便了程序员的操作。可是作为IT人士的你知道吗，由于MATLAB语言库函数与用户文件的形式相同，用户文件可以像库函数一样随意调用，所以用户可任意扩充库函数。这是不是很方便呢?

接着，语言简单内涵丰富。数值分析所用的语言中，最重要的成分是函数，其一般形式为：Function[a,b,c„„]=fun(d,e,f„„)，你也发现了吧，这样的语音是不是很容易掌握呢!Fun是自定义的函数名，只要不与库函数想重，并且符合字符串书写规则即可。

然后是丰富的工具箱。由于MATLAB 的开放性，许多领域的专家都为MATLAB 编写了各种程序工具箱。这些工具箱提供了用户在特别应用领域所需的许多函数，这使得用户不必花大量的时间编写程序就可以直接调用这些函数，达到事半功倍的效果。不过你得提前知道这些工具箱，并且会使用。

最后，我们来说一下MATLAB的运算。利用matlab可以做向量与矩阵的运算，与普通加减运算几乎相似。

矩阵乘法用 “ * ” 符号表示，当A矩阵列数与B矩阵的行数相等时，二者可以进行乘法运算，否则是错误的。如果A或B是标量，则A*B返回标量A(或B)乘上矩阵B(或A)的每一个元素所得的矩阵。

对n×m阶矩阵A和p×q阶矩阵B，A和B的Kronecher乘法运算可定义为：

Kronecker乘法的Matlab命令为C=kron(A,B)：例如，在matlab中输入：

A=[12;34]; B=[132;246];C=kron(A,B) 则程序会给出相应的答案

C =

132264

2464812

3964128

6121881624

这就充分的考验了我们的实际动手能力，当然运用一般的计算方法能算出结果，但相对来说没有用它来运算节省时间，其他算法又很不方便。

上面介绍了Matlab的特点与使用方法，接着我们要说它的程序设计，其实跟c语言相比，它们的程序设计都差不多。

大家都知道，Matlab与其它计算机语言一样，也有控制流语句。而控制流语句本身，可使原本简单地在命令行中运行的一系列命令或函数，组合成为一个整体—程序，从而提高效率。以下是具体的几个例子，看过之后，你会发现，Matlab的控制流语句跟其他计算机真的很相似：

(1)for 循环for循环的通用形式为：for v=expressionstatementsend其中expression 表达式是一个矩阵，因为Matlab中都是矩阵，矩阵的列被一个接一个的赋值到变量v，然后statements语句运行。

(2)while 循环while循环的通用形式为：while v=expressionstatementsend当expression的所有运算为非零值时，statements 语句组将被执行。如果判断条件是向量或矩阵的话，可能需要all 或any函数作为判断条件。

(3)if和break语句通用形式为：if 条件1，命令组1;elesif条件2，命令组2;„„;else命令组k;endbreak%中断执行，用在循环语句内表示跳出循环。

对于数值分析这节课，我的理解是：只要学习并掌握好MATLAB，你就已经成功了。因此说，MATLAB是数学分析的基础。另外，自我感觉这是一个很好的软件，其语言简便，实用性强。但是作为一个做新手，想要学习好这门语言，还是比较困难的。在平常的上机课中，虽然我没有问过老师，但是我向那些学习不错的学生还是交流了许多，比如说，张**，贾**，还有那个皮肤白白的女生。跟他们交流，我确实学到不少有用的东西。但是，毕竟没有他们学得好，总之，在我接触这门语言的这些天，除了会画几个简单的三维图形，其他的还是有待提高。在这个软件中，虽然有help，但大家不要以为有了这个就万事大吉了，反而，从另一个方面也对我们大学生提出了两个要求——充实的课外基础和良好的英语基础。在现代，几乎所有好的软件都是来自国外，假如你不会外语，想学好是非常难的，即使高考中的英语比重降低了，但我们依旧得学好。这样我们才能走得更远。

其实想要学习好一们语言，不能只靠老师，靠朋友，关键是自己。每个人内心深处都是有抵触意识的，不可能把老师的所有都学到。其实，我发现学习数值分析这门课，不光是学习一种语言，一些知识，更重要的是学习一种方法，一种学习软件的方法，还有学习的态度。

在最后，我想说的是，谢谢郭老师的辛勤付出，我们每个学生都会看在眼里记在心里的，谢谢您。

第三篇：数值分析实验报告写作范本

学号：

姓名：

实验二插值法

实验2.1(多项式插值的振荡现象)

问题提出：考虑一个固定的区间上用插值逼近一个函数。显然拉格朗日插值中使用的节点越多，插值多项式的次数就越高。我们自然关心插值多项式的次数增加时，L(x)是否也更加靠近被逼近的函数。龙格给出了一个极著名例子。设区间[-1，1]上函数

f(x)=1/(1+25x^2)

实验内容：考虑区间[-1，1]的一个等距划分，分点为：

x(i)=-1+2i/n,i=0,1,2…,n

则拉格朗日插值多项式为：

L(x)=∑l(i)(x)/(1+25x(j)^2 ) i=0,1,…n

其中l(i)(x), i=0,1,…n,n是n次拉格朗日插值基函数。

实验要求：

⑴ 选择不断增大的分点数目n=2,3…，画出f(x)及插值多项式函数L(x)在[-1，1]上的图象，比较分析实验结果。

(2)选择其它的函数，例如定义在区间[-5，5]上的函数

h(x)=x/(1+x^4) ,g(x)=arctanx

重复上述的实验看其结果如何。

(3)区间[a,b]上切比雪夫点的定义为：

xk=(b+a)/2+((b-a)/2)cos((2k-1)π/(2(n+1))),k=1,2,^,n+1

以x1,x2^x(n+1)为插值节点构造上述各函数的拉格朗日插值多项式，比较其结果。

实验过程：

程序：。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

数值实验结果及分析：。。。。。。。。。。。。。。。。。。。。。。。。。。。

讨论。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

实验总结：。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

第四篇：清华大学数值分析实验报告

数值分析实验报告

一、实验3.1

题目：

考虑线性方程组，，，编制一个能自动选取主元，又能手动选取主元的求解线性代数方程组的Gauss消去过程。

(1)取矩阵，，则方程有解。取计算矩阵的条件数。分别用顺序Gauss消元、列主元Gauss消元和完全选主元Gauss消元方法求解，结果如何?

(2)现选择程序中手动选取主元的功能，每步消去过程都选取模最小或按模尽可能小的元素作为主元进行消元，观察并记录计算结果，若每步消去过程总选取按模最大的元素作为主元，结果又如何?分析实验的结果。

(3)取矩阵阶数n=20或者更大，重复上述实验过程，观察记录并分析不同的问题及消去过程中选择不同的主元时计算结果的差异，说明主元素的选取在消去过程中的作用。

(4)选取其他你感兴趣的问题或者随机生成的矩阵，计算其条件数，重复上述实验，观察记录并分析实验的结果。

算法介绍

首先，分析各种算法消去过程的计算公式，

顺序高斯消去法：

第k步消去中，设增广矩阵中的元素(若等于零则可以判定系数矩阵为奇异矩阵，停止计算)，则对k行以下各行计算，分别用乘以增广矩阵的第行并加到第行，则可将增广矩阵中第列中以下的元素消为零;重复此方法，从第1步进行到第n-1步，则可以得到最终的增广矩阵，即;

列主元高斯消去法：

第k步消去中，在增广矩阵中的子方阵中，选取使得，当时，对中第行与第行交换，然后按照和顺序消去法相同的步骤进行。重复此方法，从第1步进行第n-1步，就可以得到最终的增广矩阵，即;

完全主元高斯消去法：

第k步消去中，在增广矩阵中对应的子方阵中，选取使得，若或，则对中第行与第行、第列与第列交换，然后按照和顺序消去法相同的步骤进行即可。重复此方法，从第1步进行到第n-1步，就可以得到最终的增广矩阵，即;

接下来，分析回代过程求解的公式，容易看出，对上述任一种消元法，均有以下计算公式：

实验程序的设计

一、输入实验要求及初始条件；

二、计算系数矩阵A的条件数及方程组的理论解；

三、对各不同方法编程计算，并输出最终计算结果。

计算结果及分析

(1)

先计算系数矩阵的条件数，结果如下，

可知系数矩阵的条件数较大，故此问题属于病态问题，

b或A的扰动都可能引起解的较大误差;

采用顺序高斯消去法，计算结果为：

最终解为x=(1.000000000000000,

1.000000000000000,

1.000000000000001,

0.999999999999998,

1.000000000000004,

0.999999999999993,

1.000000000000012,

0.999999999999979,

1.000000000000028)T

使用无穷范数衡量误差，得到=2.842170943040401e-14，可以发现，采用顺序高斯消元法求得的解与精确解之间误差较小。通过进一步观察，可以发现，按照顺序高斯消去法计算时，其选取的主元值和矩阵中其他元素大小相近，因此顺序高斯消去法方式并没有对结果造成特别大的影响。

若采用列主元高斯消元法，则结果为：

最终解为x=(1.000000000000000,

1.000000000000000,

1.000000000000000)T

同样使用无穷范数衡量误差，有=0;

若使用完全主元高斯消元法，则结果为

最终解x=(1.000000000000000,

1.000000000000000,

1.000000000000000)T

同样使用无穷范数衡量误差，有=0;

(2)

若每步都选取模最小或尽可能小的元素为主元，则计算结果为

最终解x=(1.000000000000000

1.000000000000000

1.000000000000001

0.999999999999998

1.000000000000004

0.999999999999993

1.000000000000012

0.999999999999979

1.000000000000028)T

使用无穷范数衡量误差，有为2.842170943040401e-14;而完全主元消去法的误差为=0。

从(1)和(2)的实验结果可以发现，列主元消去法和完全主元消去法都得到了精确解，而顺序高斯消去法和以模尽量小的元素为主元的消去法没有得到精确解。在后两种消去法中，由于程序计算时的舍入误差，对最终结果产生了一定的影响，但由于方程组的维度较低，并且元素之间相差不大，所以误差仍比较小。

为进一步分析，计算上述4种方法每步选取的主元数值，并列表进行比较，结果如下：

第n次消元

顺序

列主元

完全主元

模最小

6.000000000000000

4.666666666666667

4.285714285714286

4.133333333333333

4.064516129032258

4.031746031746032

4.015748031496063

4.007843137254902

4.003913894324853

4.001955034213099

0.015617370605469

4.001955034213099

从上表可以发现，对这个方程组而言，顺序高斯消去选取的主元恰好事模尽量小的元素，而由于列主元和完全主元选取的元素为8，与4在数量级上差别小，所以计算过程中的累积误差也较小，最终4种方法的输出结果均较为精确。

在这里，具体解释一下顺序法与模最小法的计算结果完全一致的原因。该矩阵在消元过程中，每次选取主元的一列只有两个非零元素，对角线上的元素为4左右，而其正下方的元素为8，该列其余位置的元素均为0。在这样的情况下，默认的主元也就是该列最小的主元，因此两种方法所得到的计算结果是一致的。

理论上说，完全高斯消去法的误差最小，其次是列主元高斯消去法，而选取模最小的元素作为主元时的误差最大，但是由于方程组的特殊性(元素相差不大并且维度不高)，这个理论现象在这里并没有充分体现出来。

(3)

时，重复上述实验过程，各种方法的计算结果如下所示，在这里，仍采用无穷范数衡量绝对误差。

顺序高斯消去法

列主元高斯消去

完全主元高斯消去

选取模最小或尽可能小元素作为主元消去

1.000000000000000

1.000000000000001

0.999999999999998

1.000000000000004

0.999999999999993

1.000000000000014

0.999999999999972

1.000000000000057

0.999999999999886

1.000000000000227

0.999999999999547

1.000000000000902

0.999999999998209

1.000000000003524

0.999999999993179

1.000000000012732

0.999999999978173

1.000000000029102

1.000000000000000

1.000000000000001

0.999999999999998

1.000000000000004

0.999999999999993

1.000000000000014

0.999999999999972

1.000000000000057

0.999999999999886

1.000000000000227

0.999999999999547

1.000000000000902

0.999999999998209

1.000000000003524

0.999999999993179

1.000000000012732

0.999999999978173

1.000000000029102

2.910205409989430e-11

可以看出，此时列主元和完全主元的计算结果仍为精确值，而顺序高斯消去和模尽可能小方法仍然产生了一定的误差，并且两者的误差一致。与n=10时候的误差比相比，n=20时的误差增长了大约1000倍，这是由于计算过程中舍入误差的不断累积所致。所以，如果进一步增加矩阵的维数，应该可以看出更明显的现象。

(4)

不同矩阵维度下的误差如下，在这里，为方便起见，选取2-条件数对不同维度的系数矩阵进行比较。

维度

条件数

顺序消去

列主元

完全主元

模尽量小

1.7e+3

2.84e-14

1.8e+6

2.91e-11

5.7e+7

9.31e-10

1.8e+9

2.98e-08

1.9e+12

3.05e-05

3.8e+16

3.28e+04

3.88e-12

3.28e+04

8.5e+16

3.52e+13

4.2e-3

3.52e+13

从上表可以看出，随着维度的增加，不同方法对计算误差的影响逐渐体现，并且增长较快，这是由于舍入误差逐步累计而造成的。不过，方法二与方法三在维度小于40的情况下都得到了精确解，这两种方法的累计误差远比方法一和方法四慢;同样地，出于与前面相同的原因，方法一与方法四的计算结果保持一致，方法二与方法三的计算结果保持一致。

结论

本文矩阵中的元素差别不大，模最大和模最小的元素并没有数量级上的差异，因此，不同的主元选取方式对计算结果的影响在维度较低的情况下并不明显，四种方法都足够精确。

对比四种方法，可以发现采用列主元高斯消去或者完全主元高斯消去法，可以尽量抑制误差，算法最为精确。不过，对于低阶的矩阵来说，四种方法求解出来的结果误差均较小。

另外，由于完全选主元方法在选主元的过程中计算量较大，而且可以发现列主元法已经可以达到很高的精确程度，因而在实际计算中可以选用列主元法进行计算。

附录：程序代码

clear

clc;

format

long;

%方法选择

n=input('矩阵A阶数:n=');

disp('选取求解方式');

disp('1

顺序Gauss消元法，2

列主元Gauss消元法，3

完全选主元Gauss消元法，4

模最小或近可能小的元素作为主元');

a=input('求解方式序号：');

%赋值A和b

A=zeros(n,n);

b=zeros(n,1);

for

i=1:n

A(i,i)=6;

i>1

A(i,i-1)=8;

end

A(i,i+1)=1;

end

for

i=1:n

for

j=1:n

b(i)=b(i)+A(i,j);

end

disp('给定系数矩阵为：');

disp('右端向量为：');

%求条件数及理论解

disp('线性方程组的精确解：');

X=(A)'

fprintf('矩阵A的1-条件数:

',cond(A,1));

fprintf('矩阵A的2-条件数:

',cond(A));

fprintf('矩阵A的无穷-条件数:

',cond(A,inf));

%顺序Gauss消元法

a==1

A1=A;b1=b;

for

k=1:n

A1(k,k)==0

disp('主元为零，顺序Gauss消元法无法进行');

break

end

fprintf('第%d次消元所选取的主元：%g',k,A1(k,k))

%disp('此次消元后系数矩阵为：');

%A1

for

p=k+1:n

l=A1(p,k)/A1(k,k);

A1(p,k:n)=A1(p,k:n)-l*A1(k,k:n);

b1(p)=b1(p)-l*b1(k);

end

x1(n)=b1(n)/A1(n,n);

for

k=n-1:-1:1

for

w=k+1:n

b1(k)=b1(k)-A1(k,w)*x1(w);

end

x1(k)=b1(k)/A1(k,k);

end

disp('顺序Gauss消元法解为:');

disp(x1);

disp('所求解与精确解之差的无穷-范数为');

norm(x1-X,inf)

end

%列主元Gauss消元法

a==2

A2=A;b2=b;

for

k=1:n

[max_i,max_j]=find(A2(:,k)==max(abs(A2(k:n,k))));

max_i~=k

A2_change=A2(k,:);

A2(k,:)=A2(max_i,:);

A2(max_i,:)=A2_change;

b2_change=b2(k);

b2(k)=b2(max_i);

b2(max_i)=b2_change;

end

A2(k,k)==0

disp('主元为零，列主元Gauss消元法无法进行');

break

end

fprintf('第%d次消元所选取的主元：%g',k,A2(k,k))

%disp('此次消元后系数矩阵为：');

%A2

for

p=k+1:n

l=A2(p,k)/A2(k,k);

A2(p,k:n)=A2(p,k:n)-l*A2(k,k:n);

b2(p)=b2(p)-l*b2(k);

end

x2(n)=b2(n)/A2(n,n);

for

k=n-1:-1:1

for

w=k+1:n

b2(k)=b2(k)-A2(k,w)*x2(w);

end

x2(k)=b2(k)/A2(k,k);

end

disp('列主元Gauss消元法解为:');

disp(x2);

disp('所求解与精确解之差的无穷-范数为');

norm(x2-X,inf)

end

%完全选主元Gauss消元法

a==3

A3=A;b3=b;

for

k=1:n

VV=eye(n);

[max_i,max_j]=find(A3(k:n,k:n)==max(max(abs(A3(k:n,k:n)))));

numel(max_i)==0

[max_i,max_j]=find(A3(k:n,k:n)==-max(max(abs(A3(k:n,k:n)))));

end

W=eye(n);

W(max_i(1)+k-1,max_i(1)+k-1)=0;

W(k,k)=0;

W(max_i(1)+k-1,k)=1;

W(k,max_i(1)+k-1)=1;

V=eye(n);

V(k,k)=0;

V(max_j(1)+k-1,max_j(1)+k-1)=0;

V(k,max_j(1)+k-1)=1;

V(max_j(1)+k-1,k)=1;

A3=W*A3*V;

b3=W*b3;

VV=VV*V;

A3(k,k)==0

disp('主元为零，完全选主元Gauss消元法无法进行');

break

end

fprintf('第%d次消元所选取的主元：%g',k,A3(k,k))

%disp('此次消元后系数矩阵为：');

%A3

for

p=k+1:n

l=A3(p,k)/A3(k,k);

A3(p,k:n)=A3(p,k:n)-l*A3(k,k:n);

b3(p)=b3(p)-l*b3(k);

end

x3(n)=b3(n)/A3(n,n);

for

k=n-1:-1:1

for

w=k+1:n

b3(k)=b3(k)-A3(k,w)*x3(w);

end

x3(k)=b3(k)/A3(k,k);

end

disp('完全选主元Gauss消元法解为:');

disp(x3);

disp('所求解与精确解之差的无穷-范数为');

norm(x3-X,inf)

end

%模最小或近可能小的元素作为主元

a==4

A4=A;b4=b;

for

k=1:n

AA=A4;

AA(AA==0)=NaN;

[min_i,j]=find(AA(k:n,k)==min(abs(AA(k:n,k))));

numel(min_i)==0

[min_i,j]=find(AA(k:n,k)==-min(abs(AA(k:n,k:n))));

end

W=eye(n);

W(min_i(1)+k-1,min_i(1)+k-1)=0;

W(k,k)=0;

W(min_i(1)+k-1,k)=1;

W(k,min_i(1)+k-1)=1;

A4=W*A4;

b4=W*b4;

A4(k,k)==0

disp('主元为零，模最小Gauss消元法无法进行');

break

end

fprintf('第%d次消元所选取的主元：%g',k,A4(k,k))

%A4

for

p=k+1:n

l=A4(p,k)/A4(k,k);

A4(p,k:n)=A4(p,k:n)-l*A4(k,k:n);

b4(p)=b4(p)-l*b4(k);

end

x4(n)=b4(n)/A4(n,n);

for

k=n-1:-1:1

for

w=k+1:n

b4(k)=b4(k)-A4(k,w)*x4(w);

end

x4(k)=b4(k)/A4(k,k);

end

disp('模最小Gauss消元法解为:');

disp(x4);

disp('所求解与精确解之差的无穷-范数为');

norm(x4-X,inf)

end

二、实验3.3

题目：

考虑方程组的解，其中系数矩阵H为Hilbert矩阵：

这是一个著名的病态问题。通过首先给定解(例如取为各个分量均为1)再计算出右端的办法给出确定的问题。

(1)选择问题的维数为6，分别用Gauss消去法(即LU分解)、J迭代法、GS迭代法和SOR迭代法求解方程组，其各自的结果如何?将计算结果与问题的解比较，结论如何。

(2)逐步增大问题的维数，仍用上述的方法来解它们，计算的结果如何?计算的结果说明的什么?

(3)讨论病态问题求解的算法。

算法设计

对任意线性方程组，分析各种方法的计算公式如下，

(1)Gauss消去法：

首先对系数矩阵进行LU分解，有，则原方程转化为，令，则原方程可以分为两步回代求解：

具体方法这里不再赘述。

(2)J迭代法：

首先分解，再构造迭代矩阵，其中

，进行迭代计算，直到误差满足要求。

(3)GS迭代法：

首先分解，再构造迭代矩阵

，其中

，进行迭代计算，直到误差满足要求。

(4)SOR迭代法：

首先分解，再构造迭代矩阵

，其中，进行迭代计算，直到误差满足要求。

实验过程

一、根据维度n确定矩阵H的各个元素和b的各个分量值；

二、选择计算方法（

Gauss消去法，J迭代法，GS迭代法，SOR迭代法)，对迭代法设定初值，此外SOR方法还需要设定松弛因子;

三、进行计算，直至满足误差要求（对迭代法，设定相邻两次迭代结果之差的无穷范数小于0.0001；

对SOR方法，设定为输出迭代100次之后的结果及误差值)，输出实验结果。

计算结果及分析

(1)时，问题可以具体定义为

计算结果如下，

Gauss消去法

第1次消元所选取的主元是：1

第2次消元所选取的主元是：0.0833333

第3次消元所选取的主元是：0.00555556

第4次消元所选取的主元是：0.000357143

第5次消元所选取的主元是：2.26757e-05

第6次消元所选取的主元是：1.43155e-06

解得X=(0.999999999999228

1.000000000021937

0.999999999851792

1.000000000385369

0.999999999574584

1.000000000167680)T

使用无穷范数衡量误差，可得=4.254160357319847e-10;

J迭代法

设定迭代初值为零，计算得到

J法的迭代矩阵B的谱半径为4.30853>1，所以J法不收敛;

GS迭代法

设定迭代初值为零，计算得到GS法的迭代矩阵G的谱半径为：0.999998<1，故GS法收敛，经过541次迭代计算后，结果为X=(1.001178105812706

0.999144082651860

0.968929093984902

1.047045569989162

1.027323158370281

0.954352032784608)T

使用无穷范数衡量误差，有=0.047045569989162;

SOR迭代法

设定迭代初值为零向量，并设定，计算得到SOR法迭代矩阵谱半径为0.999999433815223，经过100次迭代后的计算结果为

X=(1.003380614145078

0.962420297458423

1.031857023134559

1.061814901289881

1.014037815827164

0.917673642493527)T;

使用无穷范数衡量误差，有=0.082326357506473;

对SOR方法，可变，改变值，计算结果可以列表如下

迭代次数

100

迭代矩阵的谱半径

0.999999433815223

0.999998867083155

0.999996830135013

0.999982309342386

1.003653917714694

0.974666041209353

1.011814573842440

1.042837929171827

1.017190220902681

0.945462001336268

1.014676015634604

0.896636864424096

1.090444578936265

1.107070542628148

1.006315452225331

0.873244842279255

1.028022215505147

0.790604920509843

1.267167365524072

1.061689730857891

0.990084054872602

0.846005956774467

1.051857392323966

0.653408758549156

1.486449891152510

0.783650360698119

1.349665420488270

0.664202350634588

0.054537998663732

0.126755157720745

0.267167365524072

0.486449891152510

可以发现，松弛因子的取值对迭代速度造成了不同的影响，上述四种方法中，松弛因子=0.5时，收敛相对较快。

综上，四种算法的结果列表如下：

算法

Gauss消去法

Jacobi法

GS法

SOR法(取)

迭代次数

不收敛

541

100

迭代矩阵的谱半径

4.30853

0.999998

0.999999433815223

0.999999999999228

1.000000000021937

0.999999999851792

1.000000000385369

0.999999999574584

1.000000000167680

1.001178105812706

0.999144082651860

0.968929093984902

1.047045569989162

1.027323158370281

0.954352032784608

1.003380614145078

0.962420297458423

1.031857023134559

1.061814901289881

1.014037815827164

0.917673642493527

4.254160357319847e-10

0.047045569989162

0.082326357506473

计算可得，矩阵H的条件数为>>1，所以这是一个病态问题。由上表可以看出，四种方法的求解都存在一定的误差。下面分析误差的来源：

LU分解方法的误差存在主要是由于Hilbert矩阵各元素由分数形式转换为小数形式时，不能除尽情况下会出现舍入误差，在进行LU分解时也存在这个问题，所以最后得到的结果不是方程的精确解

，但结果显示该方法的误差非常小;

Jacobi迭代矩阵的谱半径为4.30853，故此迭代法不收敛;

GS迭代法在迭代次数为541次时得到了方程的近似解，其误差约为0.05

，比较大。GS迭代矩阵的谱半径为0.999998，很接近1，所以GS迭代法收敛速度较慢;

SOR迭代法在迭代次数为100次时误差约为0.08，误差较大。SOR迭代矩阵的谱半径为0.999999，也很接近1，所以时SOR迭代法收敛速度不是很快，但是相比于GS法，在迭代速度方面已经有了明显的提高;另外，对不同的，SOR方法的迭代速度会相应有变化，如果选用最佳松弛因子，可以实现更快的收敛;

(2)

考虑不同维度的情况，时，

算法

Gauss消去

J法

GS法

SOR法(w=0.5)

计算结果

0.999999999966269

1.000000001809060

0.999999976372676

1.000000127868103

0.999999655764116

1.000000487042164

0.999999653427125

1.000000097774747

0.997829221945349

1.037526203106839

0.896973261976015

1.020345136375036

1.069071166932576

1.051179995036612

0.996814757185364

0.926343237325536

1.012938972275634

0.939713836855171

0.988261805073081

1.064637090535154

1.083633345093974

1.045060177115514

0.970603024778469

0.880212649657655

迭代次数

356

100

谱半径

6.04213

0.999999999208776

时，

算法

Gauss消去法

Jacobi法

GS法

SOR法(w=0.5)

计算结果

0.999999994751197

1.000000546746354

0.999985868343700

1.000157549468631

0.999063537004329

1.003286333127805

0.992855789229370

1.009726486881556

0.991930155925812

1.003729850349020

0.999263885025643

0.997442073306751

1.019069909358409

0.992278247786739

0.956441858313237

0.986420333361353

1.021301611956591

1.038701026806608

1.035942773498533

1.016693763149422

0.985716454946250

0.947181287500697

1.015776039786572

0.966429147064483

0.928674868157910

0.996931548482727

1.066737803913537

1.097792430596468

1.088030440855069

1.048110620811192

0.989919418572424

0.922840813704142

0.853252417221922

迭代次数

1019

100

谱半径

8.64964

0.999999999999966

时

算法

Gauss消去法

Jacobi法

GS法

SOR法(w=0.5)

计算结果

0.999999968723799

1.000002417094896

0.999994922439769

0.998640261957706

1.025668111139297

0.781933485305194

2.066840925345890

-2.279036697492128

7.532393125791018

-7.355047567109081

7.380667063930484

-1.129041418095142

0.425748747257065

1.733284233971601

0.817952344733362

不收敛

1.004385740641590

1.046346067877554

0.907178347707729

0.905763455949053

0.972521802788457

1.043731445367903

1.091535169448764

1.110090020703944

1.103129684679768

1.077168651146056

1.038514736265176

0.992259990832041

0.942151390478003

0.890785366684065

0.839876442493220

迭代次数

262

100

谱半径

6.04213

1.000000000000000

8.355047567109082

0.160123557506780

分析以上结果可以发现，随着n值的增加，Gauss消去法误差逐渐增大，而且误差增大的速度很快，在维数小于等于10情况下，Gauss消去法得到的结果误差较小;但当维数达到15时，计算结果误差已经达到精确解的很多倍;

J法迭代不收敛，无论n如何取值，其谱半径始终大于1，因而J法不收敛，所以J迭代法不能用于Hilbert矩阵的求解;

对于GS迭代法和SOR迭代法，两种方法均收敛，GS迭代法是SOR迭代法松弛因子取值为1的特例，SOR方法受到取值的影响，会有不同的收敛情况。可以得出GS迭代矩阵的谱半径小于1但是很接近1，收敛速度很慢。虽然随着维数的增大，所需迭代的次数逐渐减少，但是当维数达到15的时候，GS法已经不再收敛。因此可以得出结论，GS迭代方法在Hilbert矩阵维数较低时，能够在一定程度上满足迭代求解的需求，不过迭代的速度很慢。另外，随着矩阵维数的增加，

SOR法的误差水平基本稳定，而且误差在可以接受的范围之内。

经过比较可以得出结论，如果求解较低维度的Hibert矩阵问题，Gauss消去法、GS迭代法和SOR迭代法均可使用，且Gauss消去法的结果精确度较高;如果需要求解较高维度的Hibert矩阵问题，只有采用SOR迭代法。

(3)

系数矩阵的条件数较大时，为病态方程。由实验可知，Gauss法在解上述方程时，结果存在很大的误差。而对于收敛的迭代法，可以通过选取最优松弛因子的方法来求解，虽然迭代次数相对较多，但是结果较为精确。

总体来看，对于一般病态方程组的求解，可以采用以下方式：

低维度下采用Gauss消去法直接求解是可行的;

Jacobi迭代方法不适宜于求解病态问题;

GS迭代方法可以解决维数较低的病态问题，但其谱半径非常趋近于1，导致迭代算法收敛速度很慢，维数较大的时候，GS法也不再收敛;

SOR方法较适合于求解病态问题，特别是矩阵维数较高的时候，其优势更为明显。

采用高精度的运算，如选用双倍或更多倍字长的运算，可以提高收敛速度;

可以对原方程组作某些预处理，从而有效降低系数矩阵的条件数。

实验结论

(1)对Hibert矩阵问题，其条件数会随着维度的增加迅速增加，病态性会越来越明显;在维度较低的时候，Gauss消去法、GS迭代法和SOR迭代法均可使用，且可以优先使用Gauss消去法;如果需要求解较高维度的Hibert矩阵问题，只有SOR迭代法能够求解。

(2)SOR方法比较适合于求解病态问题，特别是矩阵维数较高的时候，其优点更为明显。从本次实验可以看出，随着矩阵维数的增大，SOR方法所需的迭代次数减少，而且误差基本稳定，是解决病态问题的适宜方法。

附录：程序代码

clear

all

clc;

format

long;

%矩阵赋值

n=input('矩阵H的阶数:n=');

for

i=1:n

for

j=1:n

H(i,j)=1/(i+j-1);

end

b=H*ones(n,1);

disp('H矩阵为：');

disp('向量b：');

%方法选择

disp('选取求解方式');

disp('1

Gauss消去法，2

J迭代法，3

GS迭代法，4

SOR迭代法');

a=input('求解方式序号：');

%Gauss消去法

a==1;

H1=H;b1=b;

for

k=1:n

H1(k,k)==0

disp('主元为零，Gauss消去法无法进行');

break

end

fprintf('第%d次消元所选取的主元是：%g',k,H1(k,k))

for

p=k+1:n

m5=-H1(p,k)/H1(k,k);

H1(p,k:n)=H1(p,k:n)+m5*H1(k,k:n);

b1(p)=b1(p)+m5*b1(k);

end

x1(n)=b1(n)/H1(n,n);

for

k=n-1:-1:1

for

v=k+1:n

b1(k)=b1(k)-H1(k,v)*x1(v);

end

x1(k)=b1(k)/H1(k,k);

end

disp('Gauss消去法解为:');

disp(x1);

disp('解与精确解之差的无穷范数');

norm((x1-a),inf)

end

D=diag(diag(H));

L=-tril(H,-1);

U=-triu(H,1);

%J迭代法

a==2;

%给定初始x0

ini=input('初始值设定:x0=');

x0(:,1)=ini*diag(ones(n));

disp('初始解向量为:');

xj(:,1)=x0(:,1);

B=(D^(-1))*(L+U);

f=(D^(-1))*b;

fprintf('(J法B矩阵谱半径为：%g',vrho(B));

vrho(B)<1;

for

m2=1:5000

xj(:,m2+1)=B*xj(:,m2)+fj;

norm((xj(:,m2+1)-xj(:,m2)),inf)<0.0001

break

end

disp('J法计算结果为:');

xj(:,m2+1)

disp('解与精确解之差的无穷范数');

norm((xj(:,m2+1)-diag(ones(n))),inf)

disp('J迭代法迭代次数:');

else

disp('由于B矩阵谱半径大于1，因而J法不收敛');

end

%GS迭代法

a==3;

%给定初始x0

ini=input('初始值设定:x0=');

x0(:,1)=ini*diag(ones(n));

disp('初始解向量为:');

xG(:,1)=x0(:,1);

G=inv(D-L)*U;

fG=inv(D-L)*b;

fprintf('GS法G矩阵谱半径为：%g',vrho(G));

vrho(G)<1

for

m3=1:5000

xG(:,m3+1)=G*xG(:,m3)+fG;

norm((xG(:,m3+1)-xG(:,m3)),inf)<0.0001

break;

end

disp('GS迭代法计算结果:');

xG(:,m3+1)

disp('解与精确解之差的无穷范数');

norm((xG(:,m3+1)-diag(ones(n))),inf)

disp('GS迭代法迭代次数:');

else

disp('由于G矩阵谱半径大于1，因而GS法不收敛');

end

%SOR迭代法

a==4;

%给定初始x0

ini=input('初始值设定:x0=');

x0(:,1)=ini*diag(ones(n));

disp('初始解向量为:');

A=H;

for

i=1:n

b(i)=sum(A(i,:));

end

x_star=ones(n,1);

format

long

w=input('松弛因子:w=');

Lw=inv(D-w*L)*((1-w)*D+w*U);

f=w*inv(D-w*L)*b;

disp('迭代矩阵的谱半径：')

p=vrho(Lw)

time_max=100;%迭代次数

x=zeros(n,1);%迭代初值

for

i=1:time_max

x=Lw*x+f;

end

disp('SOR迭代法得到的解为');

disp('解与精确解之差的无穷范数');

norm((x_star-x),inf)

end

pause

三、实验4.1

题目：

对牛顿法和拟牛顿法。进行非线性方程组的数值求解

(1)用上述两种方法，分别计算下面的两个例子。在达到精度相同的前提下，比较其迭代次数、CPU时间等。

(2)取其他初值，结果又如何?反复选取不同的初值，比较其结果。

(3)总结归纳你的实验结果，试说明各种方法适用的问题。

算法设计

对需要求解的非线性方程组而言，牛顿法和拟牛顿法的迭代公式如下，

(1)牛顿法：

牛顿法为单步迭代法，需要取一个初值。

(2)拟牛顿法：(Broyden秩1法)

其中，

拟牛顿法不需要求解的导数，因此节省了大量的运算时间，但需要给定矩阵的初值，取为。

实验过程

一、输入初值；

二、根据误差要求，按公式进行迭代计算；

三、输出数据；

计算结果及分析

(1)首先求解方程组(1)，在这里，设定精度要求为，

方法

牛顿法

拟牛顿法

初始值

计算结果X

0.905539609855914

0.905539493347151

1.085219168370031

1.085218882394940

0.672193668718306

0.672193293825304

迭代次数

CPU计算时间/s

3.777815

2.739349

可以看出，在初始值相同情况下，牛顿法和拟牛顿法在达到同样计算精度情况下得到的结果基本相同，但牛顿法的迭代次数明显要少一些，但是，由于每次迭代都需要求解矩阵的逆，所以牛顿法每次迭代的CPU计算时间更长。

之后求解方程组(2)，同样设定精度要求为

方法

牛顿法

拟牛顿法

初始值

计算结果X

0.500000000009699

0.499999994673600

0.000000001063428

0.000000572701856

-0.523598775570483

-0.523598762908871

迭代次数

CPU计算时间/s

2.722437

3.920195

同样地，可以看出，在初始值相同情况下，牛顿法和拟牛顿法在达到同样计算精度情况下得到的结果是基本相同的，但牛顿法的迭代次数明显要少，但同样的，由于每次迭代中有求解矩阵的逆的运算，牛顿法每次迭代的CPU计算时间较长。

(2)对方程组(1)，取其他初值，计算结果列表如下，同样设定精度要求为

初始值

方法

牛顿法

拟牛顿法

计算结果

0.905539609855914

1.085219168370031

0.672193668718305

9.211852562357894

-5.574005400255346

18.118173639381205

迭代次数

CPU计算时间/s

3.907164

4.818019

计算结果

0.905539609855914

1.085219168370031

0.672193668718305

9.211849682114591

-5.573999165383549

18.118182491302807

迭代次数

2735

CPU计算时间/s

8.127286

5.626023

计算结果

0.905539609855914

1.085219168370031

0.672193668718306

0.905539493347151

1.085218882394940

0.672193293825304

迭代次数

CPU计算时间/s

3.777815

2.739349

计算结果

0.905539609855914

1.085219168370031

0.672193668718306

0.905548384395773

1.085220084502458

0.672219278250136

迭代次数

188

CPU计算时间/s

3.835697

2.879070

计算结果

9.211852448563722

-5.574005155684773

18.118173976918605

Matlab警告矩阵接近奇异值，程序进入长期循环计算中

迭代次数

CPU计算时间/s

4.033868

计算结果

0.905539609857335

1.085219168371536

0.672193668734922

Matlab警告矩阵接近奇异值，程序进入长期循环计算中

迭代次数

CPU计算时间/s

12.243263

从上表可以发现，方程组(1)存在另一个在(9.2,

-5.6,

18.1)T附近的不动点，初值的选取会直接影响到牛顿法和拟牛顿法最后的收敛点。

总的来说，设定的初值离不动点越远，需要的迭代次数越多，因而初始值的选取非常重要，合适的初值可以更快地收敛，如果初始值偏离精确解较远，会出现迭代次数增加直至无法收敛的情况;

由于拟牛顿法是一种近似方法，拟牛顿法需要的的迭代次数明显更多，而且收敛情况不如牛顿法好(初值不够接近时，甚至会出现奇异矩阵的情况)，但由于牛顿法的求解比较复杂，计算时间较长;

同样的，对方程组(2)，取其他初值，计算结果列表如下，同样设定精度要求为

初始值

方法

牛顿法

拟牛顿法

计算结果

0.500000000009699

0.000000001063428

-0.523598775570483

0.499999994673600

0.000000572701856

-0.523598762908871

迭代次数

CPU计算时间/s

2.722437

3.920195

计算结果

0.500000000011085

0.000000001215427

-0.523598775566507

0.331099293590753

-0.260080189442266

76.532092226437129

迭代次数

CPU计算时间/s

5.047111

5.619752

计算结果

0.500000000000916

0.000000000100410

-0.523598775595672

1.0e+02

-0.001221250784775

-0.000149282572886

1.754185881622843

迭代次数

CPU计算时间/s

3.540668

3.387829

计算结果

0.500000000000152

0.000000000016711

-0.523598775597862

1.0e+04

0.000026556790770

-0.000020396841295

1.280853105748650

迭代次数

CPU计算时间/s

2.200571

2.640901

计算结果

0.500000000000005

0.000000000000503

-0.523598775598286

矩阵为奇异值，无法输出准确结果

迭代次数

CPU计算时间/s

1.719072

计算结果

0.500000000002022

0.000000000221686

-0.523598775592500

矩阵为奇异值，无法输出准确结果

迭代次数

149

CPU计算时间/s

2.797116

计算结果

矩阵为奇异值，无法输出准确结果

迭代次数

CPU计算时间/s

在这里，与前文类似的发现不再赘述。

从这里看出，牛顿法可以在更大的区间上实现压缩映射原理，可以在更大的范围上选取初值并最终收敛到精确解附近;

在初始值较接近于不动点时，牛顿法和拟牛顿法计算所得到的结果是基本相同的，虽然迭代次数有所差别，但计算总的所需时间相近。

(3)

牛顿法在迭代过程中用到了矩阵的求逆，其迭代收敛的充分条件是迭代满足区间上的映内性，对于矩阵的求逆过程比较简单，所以在较大区间内满足映内性的问题适合应用牛顿法进行计算。一般而言，对于函数单调或者具有单值特性的函数适合应用牛顿法，其对初始值敏感程度较低，算法具有很好的收敛性。

另外，需要说明的是，每次计算给出的CPU时间与计算机当时的运行状态有关，同时，不同代码的运行时间也不一定一致，所以这个数据并不具有很大的参考价值。

实验结论

对牛顿法和拟牛顿法，都存在初始值越接近精确解，所需的迭代次数越小的现象;

在应用上，牛顿法和拟牛顿法各有优势。就迭代次数来说，牛顿法由于更加精确，所需的迭代次数更少;但就单次迭代来说，牛顿法由于计算步骤更多，且计算更加复杂，因而每次迭代所需的时间更长，而拟牛顿法由于采用了简化的近似公式，其每次迭代更加迅速。当非线性方程组求逆过程比较简单时，如方程组1的情况时，拟牛顿法不具有明显的优势;而当非线性方程组求逆过程比较复杂时，如方程组2的情况，拟牛顿法就可以体现出优势，虽然循环次数有所增加，但是CPU耗时反而更少。

另外，就方程组压缩映射区间来说，一般而言，对于在区间内函数呈现单调或者具有单值特性的函数适合应用牛顿法，其对初始值敏感程度较低，使算法具有很好的收敛性;而拟牛顿法由于不需要在迭代过程中对矩阵求逆，而是利用差商替代了对矩阵的求导，所以即使初始误差较大时，其倒数矩阵与差商偏差也较小，所以对初始值的敏感程度较小。

附录：程序代码

%方程1，牛顿法

tic;

format

long;

%%初值

disp('请输入初值');

a=input('第1个分量为：');

b=input('第2个分量为：');

c=input('第3个分量为：');

disp('所选定初值为');

x=[a;b;c]

%%误差要求

E=0.0001;

%%迭代

i=0;

e=2*E;

while

e>E

F=[12*x(1)-x(2)^2-4*x(3)-7;x(1)^2+10*x(2)-x(3)-11;x(2)^3+10*x(3)-8];

f=[12,-2*x(2),-4;2*x(1),10,-1;0,3*x(2)^2,10];

det_x=((f)^(-1))*(-F);

x=x+det_x;

e=max(norm(det_x));

i=i+1;

end

disp('迭代次数');

toc;

%方程1，拟牛顿法

tic;

format

long;

%%初值

disp('请输入初值');

a=input('第1个分量为：');

b=input('第2个分量为：');

c=input('第3个分量为：');

disp('所选定初值为');

x0=[a;b;c]

%%误差要求

E=0.0001;

%%迭代

i=0;

e=2*E;

A0=eye(3);

while

e>E

F0=[12*x0(1)-x0(2)^2-4*x0(3)-7;x0(1)^2+10*x0(2)-x0(3)-11;x0(2)^3+10*x0(3)-8];

x1=x0-A0^(-1)*F0;

s=x1-x0;

F1=[12*x1(1)-x1(2)^2-4*x1(3)-7;x1(1)^2+10*x1(2)-x1(3)-11;x1(2)^3+10*x1(3)-8];

y=F1-F0;

A1=A0+(y-A0*s)*s'/(s'*s);

x0=x1;

A0=A1;

e=max(norm(s));

i=i+1;

end

disp('迭代次数');

toc;

%方程2，牛顿法

tic;

format

long;

%%初值

disp('请输入初值');

a=input('第1个分量为：');

b=input('第2个分量为：');

c=input('第3个分量为：');

disp('所选定初值为');

x=[a;b;c]

%%误差要求

E=0.0001;

%%迭代

i=0;

e=2*E;

while

e>E

F=[3*x(1)-cos(x(2)*x(3))-0.5;x(1)^2-81*(x(2)+0.1)^2+sin(x(3))+1.06;exp(1)^(-x(1)*x(2))+20*x(3)+(10*pi-3)/3];

f=[3,x(3)*sin(x(2)*x(3)),x(2)*sin(x(2)*x(3));2*x(1),-162*x(2)-81/5,cos(x(3));-x(2)*exp(1)^(-x(1)*x(2)),-x(1)*exp(1)^(-x(1)*x(2)),20];

det_x=((f)^(-1))*(-F);

x=x+det_x;

e=max(norm(det_x));

i=i+1;

end

disp('迭代次数');

toc;

%方程2，拟牛顿法

tic;

format

long;

%%初值

disp('请输入初值');

a=input('第1个分量为：');

b=input('第2个分量为：');

c=input('第3个分量为：');

disp('所选定初值为');

x0=[a;b;c]

%%误差要求

E=0.0001;

%%迭代

i=0;

e=2*E;

A0=eye(3);

while

e>E

F0=[3*x0(1)-cos(x0(2)*x0(3))-0.5;x0(1)^2-81*(x0(2)+0.1)^2+sin(x0(3))+1.06;exp(1)^(-x0(1)*x0(2))+20*x0(3)+(10*pi-3)/3];

x1=x0-A0^(-1)*F0;

s=x1-x0;

F1=[3*x1(1)-cos(x1(2)*x1(3))-0.5;x1(1)^2-81*(x1(2)+0.1)^2+sin(x1(3))+1.06;exp(1)^(-x1(1)*x1(2))+20*x1(3)+(10*pi-3)/3];

y=F1-F0;

A1=A0+(y-A0*s)*s'/(s'*s);

x0=x1;

A0=A1;

e=max(norm(s));

i=i+1;

end

disp('迭代次数');

toc;

第五篇：西南交大数值分析上机实习报告

数值分析上机实习报告要求

1.应提交一份完整的实习报告。具体要求如下：

(1)要有封面，封面上要标明姓名、学号、专业和联系电话;

(2)要有序言，说明所用语言及简要优、特点，说明选用的考量;

(3)要有目录，指明题目、程序、计算结果，图标和分析等内容所在位置，作到

信息简明而完全;

(4)要有总结，全方位总结机编程计算的心得体会;

(5)尽量使报告清晰明了，一般可将计算结果、图表及对比分析放在前面，程序

清单作为附录放在后面，程序中关键部分要有中文说明或标注，指明该部分的功能和作用。

2.程序需完好保存到期末考试后的一个星期，以便老师索取用于验证、询问或质疑部分内容。

3.认真完成实验内容，可以达到既学习计算方法又提高计算能力的目的，还可以切身体会书本内容之精妙所在，期间可以得到很多乐趣。

4.拷贝或抄袭他人结果是不良行为，将视为不合格。

5.报告打印后按要求的时间提交给任课老师。

数值分析上机试题 10(选择其中两个题目)

1. 给定三个n阶线性方程组Ax=b,其中A的元素aij(i,j,=1,…,n)与阶数分别为

(1) aij=(i+j-1)2, n=3,4,5,…,9;

(2) aij=(i+j)2, n=3,4,5

(3) aij=1/(i+j-1), n=3,4,5,6;

b的元素bi=ai1+ai2+…,ain, (i=1,2,…,n)

已知其准确解为x=(1,1,...,1)T, 用列主元素法分别求解上列方程组。输出各步主元，解释所遇到的现象。

2.用雅格比法与高斯-赛德尔迭代法解下列方程组Ax=b，研究其收敛性，上机验证理论分析是否正确，比较它们的收敛速度，观察右端项对迭代收敛有无影响。

(1)A行分别为A1=[6,2,-1],A2=[1,4,-2],A3=[-3,1,4]; b1=[-3,2,4]T, b2=[100,-200,345]T,

(2) A行分别为A1=[1,0,8,0.8],A2=[0.8,1,0.8],A3=[0.8,0.8,1];b1=[3,2,1] T, b2=[5,0,-10]T,1

(3)A行分别为A1=[1,3],A2=[-7,1];b=[4,6]T,

3. 松弛因子对SOR法收敛速度的影响。

用SOR法求解方程组Ax=b,其中

41-3141-2-2...,B ....141-2-314

要求程序中不存系数矩阵A,分别对不同的阶数取w=1.1, 1.2, ...,1.9进行迭代，记录近似解x(k)达到||x(k)-x(k-1)||<10-6时所用的迭代次数k，观察松弛因子对收敛速度的影响，并观察当w0或w2会有什么影响?

4. 某实际问题中两次过程记录测得(x,y)数据点如下：其中yi=f(xi),i=1,…,21

第一次的数据为：

x=[ -5.0000-4.5000-4.0000-3.5000-3.0000-2.5000-2.0000

-1.5000-1.0000-0.500000.50001.00001.5000

2.00002.50003.00003.50004.00004.50005.0000];

y =[-0.0000-0.0001-0.0002-0.0003-0.0004-0.0048-0.0366

-0.1581-0.3679-0.389400.38940.36790.1581

0.03660.00480.00040.00030.00020.00010.0000]

第二次的数据为：

x=[-5.0000-4.7000-4.4000-4.1000-3.8000-3.5000-3.2000

-2.9000-2.6000-2.3000-2.0000-1.7000-1.4000-1.1000

-0.8000-0.5000-0.20000.10000.40000.70001.0000

1.30001.60001.90002.20002.50002.80003.1000

3.40003.70004.00004.30004.60004.9000]

y=[ -0.0000-0.0000-0.0000-0.0000-0.0000-0.0000-0.0001

-0.0006-0.0030-0.0116-0.0366-0.0945-0.1972-0.3280

-0.4218-0.3894-0.19220.09900.34090.42880.3679

0.23990.12370.05140.01740.00480.00110.0002

0.00000.00000.00000.00000.00000.0000]

现考虑分段低次或样条插值，或直接插值，总之用不超过7次的分段或不分段插值多项式近似该过程的对应规律y=f(x)，请给出一种解决方案使得误差尽量小表示尽量简单。

5. 用Runge-Kutta 4阶算法对初值问题y/=-20*y，y(0)=1按不同步长求解，用于观察稳定区间的

作用，推荐两种步长h=0.1,0.2。

注：此方程的精确解为：y=e-20x