系统简介

 随着人类文明的不断发展，科学技术的不断进步，数值计算一直在帮助人们解决各类生活与工作问题。用迭代法求解非线性方程组是数值计算中重要的研究内容，也是科学计算和计算数学的核心问题，它在国防、科技、经济、工程、管理等许多领域有着广泛的应用。因此，研究非线性方程组的各种迭代方法具有非常重要的理论意义和实际价值。

本文主要介绍几种迭代法来求解非线性方程组，主要以牛顿迭代法为主，再加上它的一些改进后的迭代方法。利用语言编程来模拟几种迭代方法，得到它们的近似解和迭代次数。在求解非线性方程组的过程中，预先设置的初值和误差精度是非常重要的，它们能直接影响所求的解的可信程度。用语言编程的方法能更好的帮助人们了解迭代法求解非线性方程组的过程与结果，为数值分析提供了良好的环境，让学者更好的研究改善迭代方法。对牛顿迭代法及其一些改进方法通过算例进行了比较，得出当所给初值最接近精确解时，牛顿弦截法计算效率最高，收敛速度最快。再牛顿迭代法与不动点迭代法的比较算例中，不动点迭代法的计算效率与收敛速度更高。

关键词 数值分析 非线性方程组 迭代方法 迭代次数 语言编程

1.绪论

1.1 引言
在人类文明不断发展，科学技术的不停进步的当下，数值计算一直在帮助人们解决各类生活与工作问题。用迭代法求解非线性方程组是数值计算中重要的研究内容，也是科学计算和计算数学的核心问题，它在国防、科技、经济、工程，管理等许多领域有着广泛的应用。生活中的大部分问题都可以用非线性方程组来表示，然而基本上这些非线性方程组都不能求得它们的精确解，所以要想解决问题就需要求出它们的近似解。因此，研究非线性方程组的各种迭代方法具有非常重要的理论意义和实际价值[1]。
要想解决有关非线性方程组的相关问题[2]，人们一般采用迭代的方法进行计算[3]，通过一次又一次地重复地运算由旧值递推出新值，不断地逼近精确解。因为计算机计算速度快，可以让它做一些简单的，重复的且目标明确的工作。例如迭代算法，可以设定让计算机重复地执行某个指令或者某段步骤，每次执行时都可以从原来的旧值得到一个新的值。
采用迭代法求解非线性方程组时[3]，通常要准备好三个步骤的工作：首先要确定该非线性方程组的变量，其次要建立适当的迭代公式，最后要对迭代过程进行人为的控制。

1.2 非线性方程组的基本介绍
非线性方程组的一般形式如下[4]：
（1.1）
在一个包含个方程的个未知数的方程组中，，为这个方程组的个分量函数，每个分量函数为定义在维空间中的一个开域上的实值函数，并且要求它们至少有一个是非线性的。
若记，则有
（1.2）
所以可将非线性方程组简记为。若存在某向量，使得。则称为非线性方程组的解。
关于非线性方程组的求解[7]，它比线性方程组求解要困难且复杂的多，没有直接的方法和一定的章程可循。通常学者们用迭代的方式来求解这类问题，类似于最经典的牛顿迭代法，再经过很多年的研究人们不断地改进牛顿迭代法，解决了它的一些局限性，创造出来其他实用的迭代方法来解决非线性方程组的问题[5]。
像求解非线性方程组这类问题，通常来源于生活中的方方面面，例如桥梁问题，种植问题，大数据分析等方面。
1.3 本文的主要章节内容
在第二章中给出几种常用的求解非线性方程组的迭代方法，介绍其理论原理。
在第三章中选出几种常用的数值方法进行语言编程模拟，带入数值，比较其精度，收敛性（收敛速度），迭代次数等。对比较结果进行汇总分析，做成表格。
在第四章中对本文内容进行总结，深度思考。

2.几种常用的求解非线性方程组的迭代方法理论

2.1 牛顿迭代法
介绍牛顿迭代方法的基本原理[7]，首先设定一个点，作为曲线的精确解，再适当地选取一个初始值，然后通过选择的初始点作该曲线的一条切线，。从而得到切线与轴交点的横坐标值，这个就是第一次迭代的近似值。继续过曲线上的点再作其切线得到下一个近似值。如此循环往复，重复上述过程，就可以得到一组曲线近似解的数值。总结规律，得到为的次近似值，也将它称之为牛顿迭代公式。相关原理见图1。
通常学者们解决用经典的牛顿迭代法求解非线性方程组的时候[9]，首先要设定一个，能够让它化简成，这是将非线性方程组线性化的一种方法。然后把在点的相关邻域内通过运算，将它展开成泰勒级数的样子，如
（2.1）
计算时只取得它的线性的部分（即泰勒展开公式的前两项），并让它等于0，变成。最后，把它当作非线性方程的近似方程，若，则其解为。如此，就可以得到牛顿迭代法的迭代公式：
。 （2.2）

图1 牛顿迭代法示意图
关于牛顿迭代法的收敛定理，设，，且在的邻域上存在，连续，则可得
牛顿迭代公式在单根情况下至少2阶收敛；
（2.3）

有关牛顿迭代法的优缺点的简单描述如下：
优点：牛顿迭代法在单根情况下至少2阶收敛，所以在迭代过程中不需要迭代太多次数就能得到很精确的近似解。
缺点：牛顿迭代法在重根情况下为局部线性收敛；它的计算量比较大，它每次进行迭代的时候都要重新计算一遍函数值和微商值；如果一开始选择的初值不接近原非线性方程组的精确解，有可能得不到想要的收敛结果。
有关牛顿迭代法解二元非线性方程组的迭代公式[9]，假设在初值点的某一邻域内连续且连续的2阶偏导数，设点为此邻域内的任意一点，则有
（2.4）
其中，所以方程可以近似地表示为

即
（2.5）
同理可得，方程同样可以近似地表示为

即
（2.6）
所以得到它的方程组：
（2.7）
求解这个方程组，当时，解得
（2.8）
由于
（2.9）
（2.10）
（2.11）
可将所得解改写为
（2.12）
所以其迭代公式为
（2.13）
通过给定的初值代入迭代公式求出的值，当其满足所给的误差范围时，非线性方程组的根就是，这就是二元函数牛顿迭代法。
有关牛顿迭代法的基本算法实现流程：
首先给定的初值，精度要求与最大迭代次数，设一个迭代次数初值；然后开始循环，判断是否为0，若是则输出奇异标志，若不是则计算牛顿迭代公式，得到；再进行判断是否满足精度要求，若满足则就是精确解，进行输出循环结束，若不满足进行下一步判断；判断迭代次数是否超出最大迭代次数，若是则输出迭代失败标志，若否则迭代次数加一，并将赋值给进行数值替换；再进入循环重新开始，直到求得的精确解输出结束循环。
相关牛顿迭代法的简单流程如图2所示：

图2 牛顿迭代法基本算法实现流程图

2.2 简化牛顿迭代法
已知牛顿迭代法的迭代公式为，
因为求解每个迭代处的导数过于复杂，所以用近似替代中的，可得：
（2.14）
这个公式就被称为简化牛顿迭代公式[8]。简化牛顿迭代法虽然克服了牛顿迭代法每步都要计算微商值的缺点，但它本身计算会精度稍低。
简化牛顿迭代法的流程只需将中的固定为初值不变，其他与牛顿迭代法相同。

2.3 牛顿弦截法
牛顿弦截法也是牛顿迭代法的改进方法[8]，与简化牛顿迭代法一样克服了牛顿迭代法每步都要计算微商值的缺点。牛顿弦截法采用数值导数代替，因为，所以牛顿弦截法的迭代公式为
（2.15）
这就是牛顿弦截法，其收敛阶约为1.618小于牛顿迭代法。
有关牛顿弦截法的基本算法实现流程：
首先给定的初值，精度要求与最大迭代次数，设一个迭代次数初值；然后用牛顿迭代公式代入初值，求得，将迭代次数加一；之后进入迭代循环，判断是否为0，若是则输出奇异标志，若不是则计算牛顿弦截法迭代公式，得到，再进行判断是否满足精度要求，若满足则就是精确解，进行输出循环结束，若不满足进行下一步判断；判断迭代次数是否超出最大迭代次数，若是则输出迭代失败标志，若否则迭代次数加一，并将赋值给，将赋值给进行数值替换；再进入循环重新开始，直到求得的精确解输出结束循环。

2.4 牛顿下山法
牛顿下山法克服了牛顿迭代法的初值近似问题[8]，一般而言，牛顿迭代法的收敛性依赖于初值的选取，如果的选取偏离精确解，则牛顿迭代法可能会发散。
为了防止发散，常常对迭代过程额外加上一项要求，用来保证函数数值的单调下降：
满足这项要求的算法被称作下山法。
牛顿下山法的迭代公式如下：
（2.16）
将称为下山因子，且。值的选取满足的顺序，直到条件的成立。牛顿下山法的迭代序列是大范围收敛的，但收敛速度只是线性的。
有关牛顿下山法的基本算法实现流程：
首先给定的初值，精度要求，最大迭代次数与下山因子，设一个迭代次数初值；然后用牛顿迭代公式，得到，进行第一次判断，如果第一次判断成立，就继续进行第二次判断是否小于精度，如果是则退出流程，输出精确解，如果不是则迭代次数加一并将赋值给，再次代入牛顿迭代公式得到新的的值，之后将之代入第一次判断公式进行判断。但如果第一次判断不成立，则将下山因子减半，代入牛顿下山法迭代公式中，得到了新的，将之代入第一次判断公式。至此循环往复，直到满足第二次判断公式，输出精确解。

2.5 不动点迭代法
假设存在个未知数与个方程的某个非线性方程组化简后为，再将方程组更改为方便迭代的一种等价形式，有：。若满足，则称为函数的不动点。所以，的不动点就是非线性方程组的解，求非线性方程组化简后式子的解就可以转化为求函数的不动点[1]。
再选取合适的初始向量，将之构成迭代公式迭代公式也被称为求解非线性方程组的不动点迭代法，且将称为迭代函数。
不动点迭代法的基础定理采用的是压缩映射原理，假设：在闭域上满足条件：
把映入它自身，即；
在上是压缩映射，即存在常数，使，

所以可得出以下的相关结论：
对任意取得的，通过迭代公式产生的序列收敛于函数在区域内存在唯一的不动点；
创建误差估计式
（2.17）
（2.18）
关于不动点迭代法的局部收敛定理，设：，是方程组的解，在可微。若谱半径，则存在，对任取的，由迭代公式产生序列收敛于。
对于不动点迭代法，由微分中值定理:
（2.19）
（2.20）
由于，所以

附 录
牛顿迭代法代码：
#include<stdio.h>
#include<math.h>
#include<time.h>

#define tol -10 //精度
/--------------------
方程组及一阶导数
--------------------/
double func1(double x, double y){
return 2xx-x-3*y+2;
}

double func2(double x, double y){
return xx+3y*y-2;
}

double func11(double x, double y){
return 4x-4;
}
double func21(double x, double y){
return 2x+6*y;
}

int main(void){
int begintime,endtime; //定义开始，结束时间
unsigned int c_times = 0; //定义迭代次数初值
double r_x,r_y,p_x,p_y; //定义变量
double n_tol=1;
p_x = -1; //给定方程组初值
p_y = 1;
n_tol = pow((double)10,tol); //误差界限

printf("%s\t%s\t%s\n","迭代次数","X","Y");          //输出列号

/牛顿迭代法/
begintime=clock(); //开始计时

for(c_times = 1; c_times < 1000; c_times++){        //进行for循环，每执行一次以下程序迭代次数加一

	r_x = p_x - func1(p_x,p_y)/func11(p_x,p_y);     //牛顿迭代法迭代公式
	r_y = p_y - func2(p_x,p_y)/func21(p_x,p_y);

	printf("%d\t%-.20lg\t%-.20lg\n",c_times,r_x,r_y);    //输出每次迭代后的x，y值和迭代次数

	if(((p_x-r_x)>0?p_x-r_x:r_x-p_x) < n_tol)       //与误差精度比较，若小于则退出循环
		break;

	p_x = r_x;      //将新的x值赋予旧的x值，进行数值替换
	p_y = r_y;      //将新的y值赋予旧的y值，进行数值替换

}

printf("迭代次数:%d\n",c_times-1);     //输出该算法所需的迭代次数
printf("方程组的解:\n");     //输出“方程组的解：”
printf("%.20lg\t%.20lg\n",r_x,r_y);    //输出x，y具体数值
endtime = clock();    //结束计时
printf("\n\nRunning Time：%dms\n", endtime-begintime);    //输出程序运行时间
getchar();    //让程序暂停
return 0;

}

简化牛顿迭代法代码：
#include<stdio.h>
#include<math.h>
#include<time.h>

#define tol -10 //精度
/--------------------
方程组及一阶导数
--------------------/
double func1(double x, double y){
return 2xx-x-3*y+2;
}

double func2(double x, double y){
return xx+3y*y-2;
}

double func11(double x, double y){
return 4x-4;
}
double func21(double x, double y){
return 2x+6*y;
}

int main(void){
int begintime,endtime; //定义开始，结束时间
unsigned int c_times = 0; //定义迭代次数初值
double r_x,r_y,p_x,p_y; //定义变量
double n_tol=1;
p_x = -1; //给定方程组初值
p_y = 1;
n_tol = pow((double)10,tol); //误差界限

printf("%s\t%s\t%s\n","迭代次数","X","Y");          //输出列号
/*简化牛顿迭代法*/
begintime=clock();    //开始计时

for(c_times = 1; c_times < 1000; c_times++){        //进行for循环，每执行一次迭代次数加一

	r_x = p_x - func1(p_x,p_y)/func11(-1,1);     //简化牛顿迭代法迭代公式保持导数初值不变
	r_y = p_y - func2(p_x,p_y)/func21(-1,1);

	printf("%d\t%-.20lg\t%-.20lg\n",c_times,r_x,r_y);    //输出每次迭代后的x，y值和迭代次数

	if(((p_x-r_x)>0?p_x-r_x:r_x-p_x) < n_tol)       //与误差精度比较，若小于则退出循环
		break;

	p_x = r_x;      //将新的x值赋予旧的x值，进行数值替换
	p_y = r_y;      //将新的y值赋予旧的y值，进行数值替换

}

printf("迭代次数:%d\n",c_times-1);     //输出该算法所需的迭代次数
printf("方程组的解:\n");     //输出“方程组的解：”
printf("%.20lg\t%.20lg\n",r_x,r_y);    //输出x，y具体数值
endtime = clock();    //结束计时
printf("\n\nRunning Time：%dms\n", endtime-begintime);    //输出程序运行时间
getchar();    //让程序暂停
return 0;

}

牛顿弦截法代码：

#include<stdio.h>

#include<math.h>
#include<time.h>

#define tol -10 //精度
/--------------------
方程组及一阶导数
--------------------/
double func1(double x, double y){
return 2xx-x-3*y+2;
}

double func2(double x, double y){
return xx+3y*y-2;
}

double func11(double x, double y){
return 4x-4;
}
double func21(double x, double y){
return 2x+6*y;
}

int main(void){
int begintime,endtime; //定义开始，结束时间
unsigned int c_times = 0; //定义迭代次数初值
double r_x,r_y,p_x,p_y,a_x,a_y;//定义变量
double n_tol=1;
p_x = -1;//给定方程组初值
p_y = 1;
n_tol = pow((double)10,tol); //误差界限

printf("%s\t%s\t%s\n","迭代次数","X","Y");//输出列号
/*牛顿弦截法*/
begintime=clock();//开始计时

r_x = p_x - func1(p_x,p_y)/func11(p_x,p_y);//牛顿迭代法迭代公式进行一次迭代
r_y = p_y - func2(p_x,p_y)/func21(p_x,p_y);

c_times++;//迭代次数加一

printf("%d\t%-.20lg\t%-.20lg\n",c_times,r_x,r_y); //输出迭代后的x，y值和迭代次数

for(c_times = 2; c_times < 1000; c_times++){//进行for循环，每执行一次以下程序迭代次数加一

	a_x = r_x - (func1(r_x,r_y))*(r_x-p_x)/(func1(r_x,r_y) - func1(p_x,p_y));//牛顿弦截法迭代公式
	a_y = r_y - (func2(r_x,r_y))*(r_y-p_y)/(func2(r_x,r_y) - func2(p_x,p_y));
	
	printf("%d\t%-.20lg\t%-.20lg\n",c_times,r_x,r_y);//输出每次迭代后的x，y值和迭代次数
	
	if(((a_x-r_x)>0?a_x-r_x:r_x-a_x) < n_tol)//与误差精度比较，若小于则退出循环
		break;
	p_x = r_x;//进行数值替换
	p_y = r_y;
	r_x = a_x;
	r_y = a_y;

}

printf("迭代次数:%d\n",c_times-1);//输出该算法所需的迭代次数
printf("方程组的解:\n");//输出“方程组的解：”
printf("%.20lg\t%.20lg\n",r_x,r_y);//输出x，y具体数值
endtime = clock();//结束计时
printf("\n\nRunning Time：%dms\n", endtime-begintime);//输出程序运行时间
getchar(); //让程序暂停
return 0;

}

不动点迭代法代码：

#include<stdio.h>

#include<math.h>
#include<time.h>

#define tol -12 //精度
/--------------------
方程组及一阶导数
--------------------/
double func1(double x, double y){
return 3*x-cos(x)-sin(y);
}

double func2(double x, double y){
return 4*y-sin(x)-cos(y);
}

double func11(double x, double y){
return 3+sin(x)-cos(y);
}
double func21(double x, double y){
return 4-cos(x)+sin(y);
}

int main(void){
int begintime,endtime; //定义开始，结束时间
unsigned int c_times = 0; //定义迭代次数初值
double r_x,r_y,p_x,p_y; //定义变量
double n_tol=1;
p_x = 1; //给定方程组初值
p_y = 1;
n_tol = pow((double)10,tol); //误差界限

printf("%s\t%s\t%s\n","迭代次数","X","Y");     //输出列号
/*不动点迭代法*/
begintime=clock();    //开始计时
for(c_times = 1; c_times < 1000; c_times++){   //进行for循环，每执行一次迭代次数加一
	r_x = (cos(p_x)+sin(p_y))/3;               //该非线性方程组的不动点迭代法迭代公式
	r_y = (sin(p_x)+cos(p_y))/4;
	printf("%d\t%-.20lg\t%-.20lg\n",c_times,r_x,r_y);      //输出每次迭代后的x，y值和迭代次数
	if((((p_x-r_x)>0?p_x-r_x:r_x-p_x)/fabs(r_x)) < n_tol)  //与误差精度比较，若小于则退出循环
		break;
	p_x = r_x;     //将新的x值赋予旧的x值，进行数值替换
	p_y = r_y;     //将新的y值赋予旧的y值，进行数值替换

理论及应用案例

由于，，因此对于任意初值，不动点迭代法都能收敛于，有
（2.21）
不动点迭代法需要注意等价形式的选择，如果选择不当，迭代结果会越来越大，不能趋近于某个极限，这样一个发散的迭代过程是没有价值的。
不动点迭代法原理见图3所示：

图3 不动点迭代法简略理解图
有关不动点迭代法的基本算法实现流程：
首先将方程等价的转化称方程，由此建立不动点迭代公式，将给定的初值代入其中得到，再将所得到的值代入迭代公式进行数值替换得到新的，如此循环往复，不断逼近精确值，直到满足精度条件，迭代就可以终止，可以作为方程的近似解输出。

3.几种常用的求解非线性方程组的迭代方法数值实例

3.1 牛顿迭代法
对于牛顿迭代法解非线性方程组的数值应用实例，列举了如下一个二元二阶非线性方程组：

求解这个非线性方程组，给定它的初值，设定它的误差精度为，用语言编程模拟它的迭代过程，最终给出该非线性方程组的近似解。编译的结果显示，它经历了31次迭代，历时4毫秒得到方程组的解为：,。

误差精度值不变，更改所给定的初值，使之更贴近方程组的解，设。改变后的编译的结果显示，它经历了26次迭代，历时不到一毫秒得到方程组的解为：,。

若不更改初值，将它的误差精度值改为，改变后的编译的结果显示，它经历了15次迭代，历时不到一毫秒得到方程组的解为：,。

3.2 简化牛顿法
用简化牛顿迭代法计算非线性方程组，用语言编程模拟它的迭代过程，最终给出该非线性方程组的近似解。编译的结果显示，它经历了54次迭代，历时10毫秒得到方程组的解为：,。

同样保持误差精度值不变，更改所给定的初值，使之更贴近方程组的解，设。改变后的编译的结果显示，它经历了23次迭代，历时不到一毫秒得到方程组的解为：,。
同样若不更改初值，将它的误差精度值改为，改变后的编译的结果显示，它经历了24次迭代，历时不到一毫秒得到方程组的解为：,。

3.3 牛顿弦截法
用牛顿弦截法计算非线性方程组，用语言编程模拟它的迭代过程，最终给出该非线性方程组的近似解。编译的结果显示，它经历了72次迭代，历时14毫秒得到方程组的解为：,。

同样保持误差精度值不变，更改所给定的初值，使之更贴近方程组的解，设。改变后的编译的结果显示，它经历了22次迭代，历时不到一毫秒得到方程组的解为：,。

同样若不更改初值，将它的误差精度值改为，改变后的编译的结果显示，它经历了36次迭代，历时3毫秒得到方程组的解为：,。

3.4 不动点迭代法
对于不动点迭代法解非线性方程组的数值应用实例，列举了如下一个三角函数非线性方程组：

求解这个非线性方程组，给定它的初值，设定它的误差精度为，用语言编程模拟它的迭代过程，最终给出该非线性方程组的近似解。编译的结果显示，它经历了27次迭代，历时1毫秒得到方程组的解为：,。

对这个三角函数非线性方程组，用牛顿迭代法对它也进行编译，使之与不动点迭代法所产生的结果进行对比，语言牛顿迭代法编译的结果显示，它经历了58次迭代，历时9毫秒得到方程组的解为：,。

保持精度不变，改变初值大小，将初值设为，改变后的编译的结果显示，它经历了26次迭代，历时不到一毫秒得到方程组的解为：,。

继续保持精度不变，改变初值为，改变后的编译的结果显示，它经历了26次迭代，历时1毫秒得到方程组的解为：,。

保持初值不变，将精度改为，改变后的编译的结果显示，它经历了11次迭代，历时不到一毫秒得到方程组的解为：,。

保持初值不变，将精度改为，改变后的编译的结果显示，它经历了37次迭代，历时4毫秒得到方程组的解为：,。

3.5 结果对比分析
关于二元二阶非线性方程组的三种迭代方法的对比如下表所示：

表1 三种迭代方法结果对比表
近似解 近似解 迭代次数
牛顿迭代法 -0.26527251492274895 0.80200384305105021 31
简化牛顿迭代法 -0.26527251509605621 0.80200384302780292 54
牛顿弦截法 -0.26527251508431543 0.80200384318113727 72
保持精度不变，改变初值后三种迭代方法对比表如下所示：

表2 改变初值后三种迭代方法结果对比表
近似解 近似解 迭代次数
牛顿迭代法 -0.26527251494399801 0.8020038430466081 26
简化牛顿迭代法 -0.26527251489730796 0.80200384307828165 23
牛顿弦截法 -0.26527251502178717 0.80200384315999007 22

保持初值不变，改变精度后三种迭代方法对比表如下所示：

表3 改变精度后三种迭代方法结果对比表
近似解 近似解 迭代次数
牛顿迭代法 -0.26528046490022428 0.80200218105357057 15
简化牛顿迭代法 -0.26528979753965148 0.80200126569089558 24
牛顿弦截法 -0.26538823618029506 0.8019902586644716 36

关于三角函数非线性方程组的相关结果对比表如下所示：

表4 关于三角函数非线性方程组相关结果对比表
近似解 近似解 迭代次数
不动点迭代法 0.41516942713919475 0.3367912170253492 27
牛顿迭代法 0.41516942713962368 0.33679121702504372 58
不动点迭代法初值更改接近解 0.41516942713933508 0.33679121702524056 26
不动点迭代法初值更改远离解 0.41516942713916122 0.33679121702537512 26
不动点迭代法误差精度调大 0.41516897278745452 0.33679156890783524 11
不动点迭代法误差精度调小 0.41516942713927385 0.33679121702528797 37

关于二元二阶非线性方程组的语言编译结果分析：
牛顿迭代法的迭代次数最少，牛顿弦截法的迭代次数最多。但当保持误差精度不变，改变它的初值，使之更加接近方程组的近似解时，牛顿弦截法的迭代次数最少，牛顿迭代法的迭代次数最多，而且三种迭代算法的迭代次数都有明显减少。当保持初值不变，调大对它的误差精度要求，三种迭代算法的迭代次数也有明显减少。
关于三角函数非线性方程组的语言编译结果分析：
将不动点迭代法与牛顿迭代法结果进行比较，不动点迭代法的迭代次数远小于牛顿迭代法的迭代次数。保持不动点迭代法的误差精度不变，改变其初值，发现无论怎样改变初值大小，不动点迭代法的迭代次数基本维持不变。保持不动点迭代法的初值不变，将误差精度调大，迭代次数减少，将误差精度调小，迭代次数变大。
通过以上的这些比较发现初值与精度的选取对求解非线性方程组有很大的影响，没一点的小改动都可能使你的结果相差甚远。降低对其精度的要求都能使得迭代次数的减少，提高精度要求也使得迭代次数的增加。当你的初值选取越靠近精确解时，你所需的迭代次数也在减少，但初值的选取对不动点迭代法迭代次数的增减没有明显的改变。
本次论文主要分成了两个非线性方程组进行迭代算法的研究和比较。
第一组实验（见表1，2，3）比较了牛顿迭代法和它的两个改进后的迭代方法，首先假定一个初值进行带入编程计算，将所得结果比较后，得到结论第一次比较牛顿迭代法的迭代次数最少，计算效率最高，牛顿弦截法的迭代次数最多，计算效率最差。本次实验不动点迭代法的迭代效率比牛顿迭代法的迭代效率更高，但是当将它的初值结果改成最接近精确解后再计算结果，结果发生巨大转变，牛顿弦截法迭代次数最少，计算效率最高，牛顿迭代法所用迭代次数最多，计算效率最差。之后又进行了精度改变的实验，当误差精度的要求放低后，实验的三个迭代算法所用迭代次数都普遍减少了，但依旧牛顿迭代法计算效率最高，简化牛顿迭代法次之，牛顿弦截法最低。
第二组实验（见表4）先比较了牛顿迭代法和不动点迭代法的差别，然后对不动点迭代法自身变量的改变进行了比较。在第一次比较中，不动点迭代法的迭代次数远小于牛顿迭代法的跌打次数，效率更高。在初值与误差精度的调整实验中，我发现在同一精度条件下，无论初值调整为多少时，它的非线性方程组的解都没有太大差别。但是，当误差精度调大时，所用迭代次数变少，提高了计算效率，当误差精度调小时，所用迭代次数变多，计算效率也下降了。

4.总结与思考

4.1 内容总结
本文主要介绍的是求解非线性方程组的几种迭代方法的理论及数值应用案例。求解非线性方程组的迭代方法，它的基本思想就是通过一次又一次的求解，不断逼近精确解。迭代方法例如牛顿迭代法，简化牛顿迭代法，牛顿弦截法，牛顿下山法和另一种不动点迭代法。本文简单介绍了它们的算法流程并选取了其中几个算法进行语言编程求解，再对它们的结果进行比较分析。如今，社会在不断进步，科技在不断发展，很多领域都需要求解非线性方程组，其中牛顿迭代法是最常用的求解方式，根据不同的情况，对牛顿迭代法进行修饰，改进。由上文的一些数值实例可以看出这些迭代法的一些优势与缺点。
在同一初值，同一误差精度的条件下，若是初值非常接近精确解，牛顿弦截法的迭代次数最少，计算效率最高，简化牛顿法情况次之，牛顿迭代法计算效率最低。若是初值远离精确解，情况就会倒过来，牛顿弦截法的计算效率最低，牛顿迭代法的计算效率最高。不动点迭代法与牛顿迭代法的比较过程中，不动点迭代法的迭代效率要高于牛顿迭代法。 在同一精度下，初值的改变不会影响不动点迭代法的计算结果，然而在同一初值下，误差精度要求变低时，所用的迭代次数也会减少，相反就会增多。

4.2 思考
除却一些常用的求解非线性方程组的迭代方法，还有对迭代法加速，多步迭代法等。在日常生活中，不只有普通的非线性方程组，还有其他的特殊的非线性方程组，如非线性代数方程组，非线性复数方程组等。对这些求解问题的研究，无论是在理论还是在实际应用中都是十分重要的。
当在生活中遇到这种数值问题时，首先要选取适当的求解方式，然后再不断地运算验证它的可行性，必要时还需要改变它的参数来比较结果。每一个问题的解决都需要经过成千上万次的计算。
本次论文的编写，让我更加深入的了解了数学的世界，懂得了计算机与数学相辅相成的关系。同一个非线性方程组，所使用的求解方式不同，所设定的变量不同，得到的结果也是天差地别，使用语言来编程，能很方便调试每个不一样之处。现如今，科技在飞速发展，人们对数学的研究也越来越深，世界因为数学而精彩。

致 谢

因为疫情原因，大学四年的最后一学期没能在学校度过就要画上一个句号了，我即将正式毕业，告别我的学校生活，踏入社会。回首这几个月写论文的过程，在这里，我要感谢那些对我学习和生活上进行巨大帮助的人。
首先，我要感谢我的指导老师蒋涛蒋老师，蒋老师在一开始分组的时候就依次耐心地讲解每个人毕业论文题目的一些注意点和要求，并在这几个月论文编写的过程中能能不辞辛劳地及时解答我们的困惑与难题。当我在编写材料懈怠懒惰时，也是蒋老师指正批评我，让我能及时地改正悔悟。在这里我要对老师说一声抱歉和感谢。
最后，我要感谢我的家人和朋友，是他们给予了我许多精神和物质上的支持，促使我能更好的完成我的论文，面对我的一些烦人的要求，能心平气和地对我提供帮助。感谢你们的帮助，我会一直记得你们的支持，理解与帮助，再次感谢你们所有人。