二分法和牛顿法求解非线性方程(C语言)

二分法和牛顿迭代法求解方程的比较200822401018 徐小良一、问题叙述求解1232cos 0x x -+=的解；通过编写matlab 程序分别用分析二分法和牛顿迭代法求解方程，通过两种方法的比较，分析二者求解方程的快慢程度。

二、问题分析由matlab 画图命令，容易得到此方程解的范围为（2，4）；两种迭代方法，在使用相同的误差（0.00001）的情况下，得出matlab 迭代次数，通过次数的比较得出二者求解速度快慢比较。

三、实验程序及注释（1）、二分法程序：clear; %清除所有内存数据； f=inline('12-3*x+2*cos(x)');format long %数据显示格式设为长型； a=2;b=4; %求解区间； er=b-a;ya=f(a);k=0;er0=0.00001; %误差分析； while er>er0 x0=.5*(a+b); y0=f(x0); if ya*y0<0b=x0; %二分法求解程序； elsea=x0; ya=y0; enddisp([a,b]);er=b-a;k=k+1 %显示各个区间值和求解次数； enddisp([a,b]); %显示最后一个区间值； （2）、牛顿迭代法程序：clear; %清除所有内存数据； f=inline('12-3*x+2*cos(x)');format long %数据显示格式设为长型； b=3;a=4;k=0; %求解区间； y0=f(b);y=f(a);while abs(b-a)>0.00001 t=a-y*(a-b)/(y-y0);b=a;y0=y; %牛顿迭代法求解程序； a=t;y=f(a); k=k+1;disp([b,a]);k %显示各个区间值和求解次数； enddisp([b,a]); %显示最后一个区间值；四、实验数据结果及分析表2：牛顿迭代法程序结果五、实验结论通过表1可知，在二分法下，程序迭代了17次后和第18次的结果一致，即程序迭代了17次达到要求的试验误差；通过表2可知，在牛顿迭代法下，程序迭代了4次后和第5次的结果一致，即程序迭代了4次达到要求的试验误差；二者比较明显可以看出牛顿迭代法的求解效率要远远优于二分法。

C语言常用算法归纳应当掌握的一般算法一、基本算法：交换、累加、累乘二、非数值计算常用经典算法：穷举、排序（冒泡，选择）、查找（顺序即线性）三、数值计算常用经典算法：级数计算（直接、简接即递推）、一元非线性方程求根（牛顿迭代法、二分法）、定积分计算（矩形法、梯形法）四、其他：迭代、进制转换、矩阵转置、字符处理（统计、数字串、字母大小写转换、加密等）、整数各数位上数字的获取、辗转相除法求最大公约数（最小公倍数）、求最值、判断素数（各种变形）、数组元素的插入（删除）、二维数组的其他典型问题（方阵的特点、杨辉三角形）详细讲解一、基本算法1．交换（两量交换借助第三者）例1、任意读入两个整数，将二者的值交换后输出。

main(){ int a,b,t;scanf("%d%d",&a,&b);printf("%d,%d\n",a,b);t=a; a=b; b=t;printf("%d,%d\n",a,b);}【解析】程序中加粗部分为算法的核心，如同交换两个杯子里的饮料，必须借助第三个空杯子。

假设输入的值分别为3、7，则第一行输出为3，7；第二行输出为7，3。

其中t为中间变量，起到“空杯子”的作用。

注意：三句赋值语句赋值号左右的各量之间的关系！【应用】例2、任意读入三个整数，然后按从小到大的顺序输出。

main(){ int a,b,c,t;scanf("%d%d%d",&a,&b,&c);/*以下两个if语句使得a中存放的数最小*/if(a>b){ t=a; a=b; b=t; }if(a>c){ t=a; a=c; c=t; }/*以下if语句使得b中存放的数次小*/if(b>c) { t=b; b=c; c=t; }printf("%d,%d,%d\n",a,b,c);}2．累加累加算法的要领是形如“s=s+A”的累加式，此式必须出现在循环中才能被反复执行，从而实现累加功能。

⾮线性⽅程求解基于MATLAB的⾮线性⽅程的五种解法探讨摘要：本⽂利⽤matlab软件对⾮线性⽅程解法中的⼆分法、简单迭代法、⽜顿法、割线法以及Steffensen法的数值分析⽅法的算法原理及实现⽅法进⾏了探讨。

对f x x x=+-()2ln2的零点问题，分别运⽤以上五种不同的⽅法进⾏数值实验，⽐较⼏种解法的优缺点并进⾏初步分析评价。

关键词：⼆分法、简单迭代法、⽜顿法、割线法、Steffensen法1、引⾔在很多实际问题中，经常需要求⾮线性⽅程f(x) =0的根。

⽅程f(x) =0的根叫做函数f(x)的零点。

由连续函数的特性知：若f(x)在闭区间[a,b ]上连续,且()()0f a f b<.则f(x) =0在开区间(a,b)内⾄少有⼀个实根。

这时称[a,b]为⽅程f(x) =0的根的存在区间。

本⽂主要对⾮线性⽅程的数值解法进⾏分析，并介绍了⾮线性⽅程数值解法的五种⽅法。

并设=+-.f x x x()2ln2f x在[1,2]上的图形，如图1：. 显然，函数在[1,2]之间有⼀个零点。

⾸先画出()2、计算机配置操作系统Windows 7 旗舰版内存2GB处理器AMD 4核 A6-3400M APU 1.4GHz图.13、⼆分法⼆分法的基本思想是将⽅程根的区间平分为两个⼩区间,把有根的⼩区间再平分为两个更⼩的区间,进⼀步考察根在哪个更⼩的区间内。

如此继续下去,直到求出满⾜精度要求的近似值。

设函数()f x 在区间[a,b ]上连续,且f(a)·f(b) <0，则[a,b ]是⽅程f(x) =0的根的存在区间，设其内有⼀实根，记为x*。

取区间[a,b ]的中点()2k a b x +=并计算1()f x ,则必有下列三种情况之⼀成⽴： (1) 1()f x =0，x1就是⽅程的根x*;(2)()f a .1()f x <0,⽅程的根x*位于区间[a, 1x ]之中,此时令111,a a b x ==; (3)1()f x .()f b <0,⽅程的根x*位于区间[1x ,b ]之中,此时令11a x =,1b b =。

实验报告一：实验题目一、 实验目的掌握求解非线性方程根的二分法、简单迭代法和牛顿迭代法，并通过数值实验比较两种方法的收敛速度。

二、 实验内容1、编写二分法、并使用这两个程序计算02)(=-+=x e x x f 在[0, 1]区间的解，要求误差小于 410- ，比较两种方法收敛速度。

2、在利率问题中，若贷款额为20万元，月还款额为2160元，还期为10年，则年利率为多少？请使用牛顿迭代法求解。

3、由中子迁移理论，燃料棒的临界长度为下面方程的根，用牛顿迭代法求这个方程的最小正根。

4、用牛顿法求方程的根，精确至8位有效数字。

比较牛顿迭代法算单根和重根的收敛速度，并用改进的牛顿迭代法计算重根。

第1题：02)(=-+=x e x x f 区间[0,1] 函数画图可得函数零点约为0.5。

画图函数：function Test1()% f(x) 示意图, f(x) = x + exp(x) - 2; f(x) = 0r = 0:0.01:1;y = r + exp(r) - 2plot(r, y);grid on 二分法程序：计算调用函数：[c,num]=bisect(0,1,1e-4)function [c,num]=bisect(a,b,delta)%Input –a,b 是取值区间范围% -delta 是允许误差%Output -c 牛顿迭代法最后计算所得零点值% -num 是迭代次数ya = a + exp(a) - 2;yb = b + exp(b) - 2;if ya * yb>0return;endfor k=1:100c=(a+b)/2;yc= c + exp(c) - 2;if abs(yc)<=deltaa=c;b=c;elseif yb*yc>0b=c;yb=yc;elsea=c;ya=yc;endif abs(b-a)<deltanum=k; %num为迭代次数break;endendc=(a+b)/2;err=abs(b-a);yc = c + exp(c) - 2;牛顿迭代法程序：计算调用函数：[c,num]=newton(@func1,0.5,1e-4) 调用函数：function [y] = func1(x)y = x + exp(x) - 2;end迭代算法：function[c,num]=newton(func,p0,delta)%Input -func是运算公式% -p0是零点值% -delta是允许误差%Output -c牛顿迭代法最后计算所得零点值% -num是迭代次数num=-1;for k=1:1000y0=func(p0);dy0=diff(func([p0 p0+1e-8]))/1e-8;p1=p0-y0/dy0;err=abs(p1-p0);p0=p1;if(err<delta)num=k;%num为迭代次数break;endendc=p0;第2题：由题意得到算式：计算调用函数：[c,num]=newton(@func2,0.02,1e-8)程序：先用画图法估计出大概零点位置在0.02附近。

解非线性方程的牛顿迭代法及其应用一、本文概述非线性方程是数学领域中的一个重要研究对象，其在实际应用中广泛存在，如物理学、工程学、经济学等领域。

求解非线性方程是一个具有挑战性的问题，因为这类方程往往没有简单的解析解，需要通过数值方法进行求解。

牛顿迭代法作为一种古老而有效的数值求解方法，对于求解非线性方程具有重要的应用价值。

本文旨在介绍牛顿迭代法的基本原理、实现步骤以及在实际问题中的应用。

我们将详细阐述牛顿迭代法的基本思想，包括其历史背景、数学原理以及收敛性分析。

我们将通过具体实例，展示牛顿迭代法的计算步骤和实际操作过程，以便读者能够更好地理解和掌握该方法。

我们将探讨牛顿迭代法在各个领域中的实际应用，包括其在物理学、工程学、经济学等领域中的典型应用案例，以及在实际应用中可能遇到的问题和解决方法。

通过本文的介绍，读者可以深入了解牛顿迭代法的基本原理和应用技巧，掌握其在求解非线性方程中的实际应用方法，为进一步的研究和应用提供有力支持。

二、牛顿迭代法的基本原理牛顿迭代法，又称为牛顿-拉夫森方法，是一种在实数或复数域上近似求解方程的方法。

其基本原理是利用泰勒级数的前几项来寻找方程的根。

如果函数f(x)在x0点的导数f'(x0)不为零，那么函数f(x)在x0点附近可以用一阶泰勒级数来近似表示，即：这就是牛顿迭代法的基本迭代公式。

给定一个初始值x0，我们可以通过不断迭代这个公式来逼近f(x)的根。

每次迭代，我们都用当前的近似值x0来更新x0，即：这个过程一直持续到满足某个停止条件，例如迭代次数达到预设的上限，或者连续两次迭代的结果之间的差小于某个预设的阈值。

牛顿迭代法的收敛速度通常比线性搜索方法快，因为它利用了函数的导数信息。

然而，这种方法也有其局限性。

它要求函数在其迭代点处可导，且导数不为零。

牛顿迭代法可能不收敛，如果初始点选择不当，或者函数有多个根，或者根是重根。

因此，在使用牛顿迭代法时，需要谨慎选择初始点，并对迭代过程进行适当的监控和调整。

熟悉用二分法,迭代法,牛顿法和弦截法求解非线性方程。

（常用版）(可以直接使用，可编辑完整版资料，欢迎下载）实验报告学院（系）名称：计算机与通信工程姓名赵云鹏学号20211931 专业计算机科学与技术班级09-1 实验项目实验一方程求根课程名称数值计算方法课程代码实验时间2011年5月26日实验地点#7-215批改意见：实验目的：熟悉用二分法，迭代法，牛顿法和弦截法求解成绩非线性方程。

实验环境：硬件环境：IBM－PC或兼容机软件环境：Windows操作系统编程语言：C语言实验内容：1、用二分法求方程x2-x-1=0的正根，要求准确到小数点后第一位2用迭代法和牛顿法求解方程x=e-x在x=0.5附近的一个根，要求精确到小数点后三位3用双点弦截法求方程x3+3x2-x-9=0在区间[1,2]内的一个实根，精确到五位有效数字。

教师签字：实验步骤：二分法：迭代法：牛顿法：双点弦截法：用二分法求方程x2-x-1=0的正根，要求准确到小数点后第一位#include <stdio.h>#include <math.h>#define ADJUST1 0.01#define ADJUST2 0.001#define EX 0.000001#define INF 999999999.99double func1(double x)//二分法求的方程{return (x*x-x-1);}double func2_1(double x)//迭代法的方程{return exp(-x);}double res1(double a,double b,double (*fun1)(double x))//二分法{double fa=fun1(a);double fb=fun1(b);double fmid=fun1((a+b)/2);while(fabs(b-a)>=ADJUST1){if(fabs(fmid-0a)<EX)return fmid;else if(fmid*fa<0){b=(a+b)/2;fa=fun1(a);fb=fun1(b);fmid=fun1((a+b)/2);}else if(fmid*fb<0){a=(a+b)/2;fa=fun1(a);fb=fun1(b);fmid=fun1((a+b)/2);}}return (a+b)/2;}int main(){printf("%.2f\n",res1(0,100,func1));printf("%.2f\n",func2_1(-1));return 0;}用迭代法和牛顿法求解方程x=e-x在x=0.5附近的一个根，要求精确到小数点后三位#include <stdio.h>#include <math.h>#define ADJUST1 0.01#define ADJUST2 0.001#define EX 0.000001#define INF 999999999.99double func2_1(double x)//迭代法的方程{return exp(-x);}double res2(double x0,double e,int n,double (*fun)(double x))//迭代法,迭代失败标志，输出Fail!，并返回INF{int k=1;double x1;x1=fun(x0);while(k!=n){if(fabs(x1-x0)<e)return x1;x0=x1;x1=fun(x0);k++;}if(k==n)printf("Fail!\n");return INF;}int main(){printf("%.3f\n",res2(0.5,0.001,100,func2_1));//q2.1printf("%.3f\n",func2_1(0.567));//for testreturn 0;}用双点弦截法求方程x3+3x2-x-9=0在区间[1,2]内的一个实根，精确到五位有效数字#include <stdio.h>#include <math.h>#define ADJUST1 0.01#define ADJUST2 0.001#define EX 0.000001#define INF 999999999.99double dfunc2_2(double x)//牛顿法方程导数{return (0-exp(-x)-1);}double func2_2(double x)//牛顿法方程{return exp(-x)-x;}double res3(double x0,double e,int n,double (*fun)(double x),double (*dfun)(double x)) //牛顿迭代法，奇异标志为返回INF，失败标志为返回INF，并输出Fail!{int k=1;double x1;if(fabs(dfun(x0)-0)<EX)return INF;x1=x0-fun(x0)/dfun(x0);while(k!=n){if(fabs(x1-x0)<e)return x1;x0=x1;x1=x0-fun(x0)/dfun(x0);}if(k==n)printf("Fail!\n");return INF;}int main(){printf("%.3f\n",res3(0.5,0.001,100,func2_2,dfunc2_2));return 0;}微分算子法求解二阶常系数非齐次线性微分方程的特解李绍刚 段复建 徐安农（桂林电子科技大学，计算科学与数学系，广西桂林，541004）摘要：本文主要介绍了二阶微分算子的性质及其它在一些求解二阶常系数非齐次线性微分方程的常见运算公式，并对其中的大部分重要公式给出了详细的较为简单的证明，并通过具体而翔实的例子加以说明它在解题中的具体应用，大大简化了二阶常系数非齐次线性微分方程的特解的求法。

C++实现牛顿迭代解非线性方程组（二元二次为例）求解{0=x*x-2*x-y+0.5;0=x*x+4*y*y-4;}的方程#include<iostream>#include<cmath>#define N 2 // 非线性方程组中方程个数、未知量个数#define Epsilon 0.0001 // 差向量1范数的上限#define Max 100 // 最大迭代次数using namespace std;const int N2=2*N;int main(){void ff(float xx[N],float yy[N]); //计算向量函数的因变量向量yy[N]void ffjacobian(float xx[N],float yy[N][N]); //计算雅克比矩阵yy[N][N]void inv_jacobian(float yy[N][N],float inv[N][N]); //计算雅克比矩阵的逆矩阵invvoid newdundiedai(float x0[N], float inv[N][N],float y0[N],float x1[N]);//由近似解向量x0 计算近似解向量x1float x0[N]={2.0,0.25},y0[N],jacobian[N][N],invjacobian[N][N],x1[N],errornorm;int i,j,iter=0;//如果取消对x0的初始化，撤销下面两行的注释符，就可以由键盘x读入初始近似解向量for( i=0;i<N;i++)cin>>x0[i];cout<<"初始近似解向量："<<endl;for (i=0;i<N;i++)cout<<x0[i]<<" ";cout<<endl;cout<<endl;do{iter=iter+1;cout<<"第"<<iter<<" 次迭代开始"<<endl; //计算向量函数的因变量向量y0ff(x0,y0); //计算雅克比矩阵jacobianffjacobian(x0,jacobian); //计算雅克比矩阵的逆矩阵invjacobian inv_jacobian(jacobian,invjacobian); //由近似解向量x0 计算近似解向量x1 newdundiedai(x0, invjacobian,y0,x1); //计算差向量的1范数errornormerrornorm=0;for (i=0;i<N;i++)errornorm=errornorm+fabs(x1[i]-x0[i]);if (errornorm<Epsilon) break;for (i=0;i<N;i++)x0[i]=x1[i];} while (iter<Max);return 0;}void ff(float xx[N],float yy[N]) //调用函数{float x,y;int i;x=xx[0];y=xx[1];yy[0]=x*x-2*x-y+0.5;yy[1]=x*x+4*y*y-4; //计算初值位置的值cout<<"向量函数的因变量向量是："<<endl;for( i=0;i<N;i++)cout<<yy[i]<<" ";cout<<endl;cout<<endl;}void ffjacobian(float xx[N],float yy[N][N]){float x,y;int i,j;x=xx[0];y=xx[1];//jacobian have n*n element //计算函数雅克比的值yy[0][0]=2*x-2;yy[0][1]=-1;yy[1][0]=2*x;yy[1][1]=8*y;cout<<"雅克比矩阵是："<<endl;for( i=0;i<N;i++){for(j=0;j<N;j++)cout<<yy[i][j]<<" ";cout<<endl;}cout<<endl;}void inv_jacobian(float yy[N][N],float inv[N][N]) {float aug[N][N2],L;int i,j,k;cout<<"开始计算雅克比矩阵的逆矩阵："<<endl; for (i=0;i<N;i++){ for(j=0;j<N;j++)aug[i][j]=yy[i][j];for(j=N;j<N2;j++)if(j==i+N) aug[i][j]=1;else aug[i][j]=0;}for (i=0;i<N;i++){ for(j=0;j<N2;j++)cout<<aug[i][j]<<" ";cout<<endl;}cout<<endl;for (i=0;i<N;i++){for (k=i+1;k<N;k++){L=-aug[k][i]/aug[i][i];for(j=i;j<N2;j++)aug[k][j]=aug[k][j]+L*aug[i][j];}}for (i=0;i<N;i++){ for(j=0;j<N2;j++)cout<<aug[i][j]<<" ";cout<<endl;cout<<endl;for (i=N-1;i>0;i--){for (k=i-1;k>=0;k--){L=-aug[k][i]/aug[i][i];for(j=N2-1;j>=0;j--)aug[k][j]=aug[k][j]+L*aug[i][j];}}for (i=0;i<N;i++){ for(j=0;j<N2;j++)cout<<aug[i][j]<<" ";cout<<endl;}cout<<endl;for (i=N-1;i>=0;i--)for(j=N2-1;j>=0;j--)aug[i][j]=aug[i][j]/aug[i][i];for (i=0;i<N;i++){ for(j=0;j<N2;j++)cout<<aug[i][j]<<" ";cout<<endl;for(j=N;j<N2;j++)inv[i][j-N]=aug[i][j];}cout<<endl;cout<<"雅克比矩阵的逆矩阵："<<endl; for (i=0;i<N;i++){ for(j=0;j<N;j++)cout<<inv[i][j]<<" ";cout<<endl;cout<<endl;}void newdundiedai(float x0[N], float inv[N][N],float y0[N],float x1[N]) {int i,j;float sum=0;for(i=0;i<N;i++){ sum=0;for(j=0;j<N;j++)sum=sum+inv[i][j]*y0[j];x1[i]=x0[i]-sum;}cout<<"近似解向量："<<endl;for (i=0;i<N;i++)cout<<x1[i]<<" ";cout<<endl;cout<<endl;}。

牛顿迭代公式设r 是f(x) = 0的根，选取x0作为r 初始近似值，过点（x0,f(x0)）的切线L ，L 的方程为y = f(x0)+f'(x0)(x-x0)，求出L 与x 轴交点的横坐标 x1 = x0-f(x0)/f'(x0)，称x1为r 的一次近似值。

过点（x1,f(x1)）做曲线y = f(x)的切线，并求该切线与x 轴交点的横坐标 x2 = x1-f(x1)/f'(x1)，称x2为r 的二次近似值。

重复以上过程，得r 的近似值序列，其中x(n+1)=x(n)－f(x(n))/f'(x(n))，称为r 的n+1次近似值，上式称为牛顿迭代公式。

解非线性方程f(x)=0似方法。

把f(x)在x0 f(x) = f(x0)+(x －x0)f'(x0)+(x －x0)^2*f''(x0)/2! +… 取其线性部分，作为非线性方程f(x) = 0的近似方程，即泰勒展开的前两项，则有f(x0)+f'(x0)(x －x0)-f(x)=0 设f'(x0)≠0则其解为x1=x0－f(x0)/f'(x0) 这样，得到牛顿法的一个迭代序列：x(n+1)=x(n)－f(x(n))/f'(x(n))。

牛顿迭代法又称牛顿切线法，它采用以下方法求根：先任意设定一个与真实的根接近的值x 0作为第一个近似根，由x 0求出f(x 0)，过(x 0,f(x 0))点做f(x)的切线，交x 轴于x 1，把它作为第二次近似根，再由x 1求出f(x 1)，再过(x 1,f(x 1))点做f(x)的切线，交x 轴于x 2，再求出f(x 2)，再作切线……如此继续下去，直到足够接近真正的x *为止。

)()()()(0'0010100'x f x f x x x x x f x f -=-=因此， 就是牛顿迭代公式。

例1 用牛顿迭代法求方程2x 3-4x 2+3x-6=0在1.5附近的根。

基于不同方法解决非线性问题的分析摘要: 本文主要研究非线性方程的数值解法中的二分法，迭代法以及牛顿下山法对于解决非线性问题所体现出来的各自不同的特点 .通过实例来比较，分析在求解非线性方程时各自的优缺点。

借以研究这三种方法在求解非线性方程时各自的作用,方便学习及利用以上三种方法快速,准确地解决非线性问题.关键词: 二分法,迭代法,牛顿下山法,优缺点.1.引言: 代数方程求根问题是古老的数学问题,是在16世纪就找到了三次,四次方程的求根公式.但直到19世纪才证明n>=5次的一般代数方程式不能用代数公式求解.因此,需要研究用数值方法求得满足一定精度的代数方程式的近似解. 在工程和科学技术中许多问题常常归结为求解非线性方程式问题,例如在控制系统的设计领域,人口增长的研究等. 在科学研究和工程设计中, 经常会遇到的一大类问题是非线性方程f(x)=0 的求根问题，其中f(x)为非线性函数。

方程f(x)=0的根, 亦称为函数f(x)的零点 如果f(x)可以分解)()(*)(x g m x f x x -=,其中m 为正整数且0)(*≠x g .当m>1时称x *是f(x)的m 重零点,或称方程f(x)=0的m 重根;当m=1时称x*为单根.2.分析比较2．1二分法在非线性方程求解中的应用2．1．1问题的提出在无阻尼强迫震荡的研究中会碰到函数h(x)=xsin(x).寻找在区间[0,2]内的值x,满足h(x)=1(函数sin(x)用弧度计算)。

[1]2．1．2二分法的思路求方程根的一种最直观，最简单的数值方法是二分法（Dichotomy ）.设函数f(x)在区间[a,b]上连续，且[a,b]为有根区间，不妨设f(a)<0，f(b)>0.首先将区间[a,b]二分，即取中点2/)(0b a x+=，若0)(0=x f ,则x x 0=就是方程式f(x)=0的根.否则，若0)(0<x f ,方程的有根区间变为[(a+b)/2,b];若0)(0>x f ，方程的有根区间变为[a,(a+b)/2],将新的有根区间记为[b a 11,],长度2/)(11a b a b -=-为[a,b]的一半.重复上述过程，即取a 2=(b a 11+)/2,将[b a 11,]再二分，又可得到新的有根区间],[22b a ,长度2/)(1122a b a b -=-为[b a 11,]的一半. 通过每次把f(x)的零点所在小区间收缩一半的方法，使区间的两个端点逐步迫近函数的零点，以求得零点的近似值，这种方法叫做二分法。

牛顿迭代法与二分法数学中，有用的方法和技术有很多，其中牛顿迭代法和二分法是两种经典的数值计算方法。

这两种方法都可以用于求解各种类型的方程和问题，在不同场合下往往有不同的适用范围和性质。

在本文中，我们将对这两种方法进行简单介绍和比较，以加深读者对它们的理解和应用。

一. 牛顿迭代法牛顿迭代法，又称牛顿-拉夫逊方法（Newton-Raphson method），是一种用于寻找函数零点的一种迭代算法。

它的基本思想是从一个初始近似值开始，使用函数的导数来逐步改进这个近似值，直到满足所需的精度要求为止。

具体步骤如下：1. 选定一个初始值 $x_0$ ，计算函数 $f(x)$ 在这个点的值和导数 $f'(x)$；2. 计算迭代公式 $x_{n+1} = x_n - \frac{f(x_n)}{f'(x_n)}$，即用当前点的函数值和导数值确定一个切线，并将其与 $x$ 轴交点作为下一个近似值；3. 如果迭代满足要求，则停止，否则返回第二步。

牛顿迭代法的优点是迭代速度较快，可以高效地求解接近函数原始根的方程。

例如，如果要求 $\sqrt{a}$ 的值，可令 $f(x) = x^2 - a$，则零点为 $\sqrt{a}$。

经过一定次数的迭代，可以得到很高精度的近似值。

然而，牛顿迭代法也有一些局限性，如收敛性和迭代次数等问题，需要根据具体问题和条件进行评估和调整。

二. 二分法二分法（bisect method）是一种寻找函数零点的一种简单算法，其基本思想是不断缩小区间，直到找到目标区间的根。

具体步骤如下：1. 选定一个有根区间 $[a, b]$，并计算函数 $f(a)$ 和 $f(b)$ 在两个端点的值；2. 计算区间中点$c = \frac{a+b}{2}$，并计算函数$f(c)$ 的值；3. 判断函数值的符号，并用二分法将 $[a, b]$ 划分为两个子区间，其中一个包含了零点，另一个不包含，即更新区间 $[a, b]$ 为$[a, c]$ 或 $[c, b]$；4. 重复步骤 2-3 直到找到满足误差要求的近似根。

(1)二分法求解非线性方程：#include<stdio.h>#include<math.h>#define f(x)((x*x-1)*x-1)void main(){float a,b,x,eps;int k=0;printf("intput eps\n");/*容许误差*/scanf("%f",&eps);printf("a,b=\n");for(;;){scanf("%f,%f",&a,&b);if(f(a)*f(b)>=0)/*判断是否符合二分法使用的条件*/printf("二分法不可使用,请重新输入:\n");else break;}do{x=(a+b)/2;k++;if(f(a)*f(x)<0)/*如果f(a)*f(x)<0，则根在区间的左半部分*/b=x;else if(f(a)*f(x)>0)/*否则根在区间的右半部分*/a=x;else break;}while(fabs(b-a)>eps);/*判断是否达到精度要求,若没有达到,继续循环*/x=(a+b)/2;/*取最后的小区间中点作为根的近似值*/printf("\n The root is x=%f,k=%d\n",x,k);}运行结果：intput eps0.00001a,b=2,-5The root is x=1.324721,k=20Press any key to continue总结：本题关键在于两个端点的取值和误差的判断，此程序较容易。

二分法收敛速度较快，但缺点是只能求解单根。

(2)牛顿法求解非线性方程：#include<stdio.h>#include<math.h>float f(float x)/*定义函数f(x)*/{return((-3*x+4)*x-5)*x+6;}float f1(float x)/*定义函数f(x)的导数*/{return(-9*x+8)*x-5;}void main(){float eps,x0,x1=1.0;printf("input eps:\n");scanf("%f",&eps);/*输入容许误差*/do{x0=x1;/*准备下一次迭代的初值*/x1=x0-f(x0)/f1(x0);/*牛顿迭代*/}while(fabs(x1-x0)>eps);/*当满足精度,输出近似根*/printf("x=%f\n",x1);}程序运行结果：x=1.265328总结：关键是牛顿迭代的应用，程序中最大缺点是函数及其导数已唯一给出确定不可求的随意函数的根，牛顿法比二分法收敛快，可以求重根。

求解方程的近似根，一般需要解决两个问题：1.根的隔离。

即找出有根区域，使得在一些小区间中方程只有一根（或一对共轭复根）以便获取各根的较粗糙的近似值。

2.近似根的精确化。

即用求根的数值方法，使求得的近似根逐步精确化，直到获得一定精度的近似根。

一、二分法和牛顿迭代法的基本思想1.二分法。

一般地，对于函数f （x ），如果存在实数c ，当x=c 时，若f （c ）=0，那么把x=c 叫做函数f （x ）的零点。

解方程即要求f （x ）的所有零点。

假定f （x ）在区间（x ，y ）上连续，先找到a 、b 属于区间（x ，y ），使f （a ），f （b ）异号，说明在区间（a ，b ）内一定有零点，然后求[f （a+b ）/2]，现在假设f （a ）<0，f （b ）>0，a<b ，①如果[f （a+b ）/2]=0，该点就是零点。

如果[f （a+b ）/2]<0，则在区间（（a+b ）/2，b ）内有零点，注：（a+b ）/2>=a ，从①开始继续使用中点函数值判断。

如果[f （a+b ）/2]>0，则在区间（a ，（a+b ）/2）内有零点，注：（a+b ）/2<=b ，从①开始继续使用中点函数值判断。

这样就可以不断接近零点。

通过每次把f （x ）的零点所在小区间收缩一半的方法，使区间的两个端点逐步迫近函数的零点，以求得零点的近似值，这种方法叫做二分法。

从以上可以看出，每次运算后，区间长度减少一半，是线形收敛。

另外，二分法不能计算复根和重根。

2.牛顿迭代法。

设r 是f （x ）=0的根，选取x0作为r 初始近似值，过点（x0，f （x0））做曲线y=f （x ）的切线L ，L 的方程为y=f （x0）+f'（x0）（x-x0），求出L 与x 轴交点的横坐标x1=x0-f（x0）/f'（x0），称x1为r 的一次近似值。

过点（x1，f （x1））作曲线y=f （x ）的切线，并求该切线与x 轴交点的横坐标x2=x1-f（x1）/f'（x1），称x2为r 的二次近似值。

数值分析求解非线性方程根的二分法、简单迭代法和牛顿迭代法实验报告一：实验题目 一、 实验目的掌握求解非线性方程根的二分法、简单迭代法和牛顿迭代法，并通过数值实验比较两种方法的收敛速度。

二、 实验内容1、编写二分法、牛顿迭代法程序，并使用这两个程序计算02)(=-+=x e x x f 在[0, 1]区间的解，要求误差小于 410- ，比较两种方法收敛速度。

2、在利率问题中，若贷款额为20万元，月还款额为2160元，还期为10年，则年利率为多少？请使用牛顿迭代法求解。

3、由中子迁移理论，燃料棒的临界长度为下面方程的根，用牛顿迭代法求这个方程的最小正根。

4、用牛顿法求方程的根，精确至8位有效数字。

比较牛顿迭代法算单根和重根的收敛速度，并用改进的牛顿迭代法计算重根。

三、 实验程序第1题：02)(=-+=x e x x f 区间[0,1] 函数画图可得函数零点约为0.5。

画图函数：function Test1()% f(x) 示意图, f(x) = x + exp(x) - 2; f(x) = 0r = 0:0.01:1;y = r + exp(r) - 2plot(r, y);grid on 二分法程序：计算调用函数：[c,num]=bisect(0,1,1e-4)function [c,num]=bisect(a,b,delta)%Input –a,b 是取值区间范围% -delta 是允许误差%Output -c 牛顿迭代法最后计算所得零点值% -num 是迭代次数ya = a + exp(a) - 2;yb = b + exp(b) - 2;if ya * yb>0return;endfor k=1:100c=(a+b)/2;yc= c + exp(c) - 2;if abs(yc)<=deltaa=c;b=c;elseif yb*yc>0b=c;yb=yc;elsea=c;ya=yc;endif abs(b-a)<deltanum=k; %num为迭代次数break;endendc=(a+b)/2;err=abs(b-a);yc = c + exp(c) - 2;牛顿迭代法程序：计算调用函数：[c,num]=newton(@func1,0.5,1e-4) 调用函数：function [y] = func1(x)y = x + exp(x) - 2;end迭代算法：function[c,num]=newton(func,p0,delta)%Input -func是运算公式% -p0是零点值% -delta是允许误差%Output -c牛顿迭代法最后计算所得零点值num=-1;for k=1:1000y0=func(p0);dy0=diff(func([p0 p0+1e-8]))/1e-8;p1=p0-y0/dy0;err=abs(p1-p0);p0=p1;if(err<delta)num=k;%num为迭代次数break;endendc=p0;第2题：由题意得到算式：计算调用函数：[c,num]=newton(@func2,0.02,1e-8)程序：先用画图法估计出大概零点位置在0.02附近。

非线性方程求根的常见方法及其应用对于一个非线性方程，其解不一定是唯一的，而且很多情况下解根难以直接求得。

因此，寻找一种可靠、有效的方法来求解非线性方程根是非常重要的。

本文将介绍几种常见的非线性方程求根方法，并且介绍它们的应用场景及求解精度。

一、二分法二分法是一种最基本且易于实现的方法，它能够求解任何单峰函数（函数图像中仅有一个极大值或极小值的函数）的根。

该方法的主要思想是不断缩小根的区间，直到找到根。

具体而言，对于一个单峰函数f(x)，在区间[a,b]上寻找其根。

首先，取中点c=(a+b)/2，计算f(c)。

如果f(c)≈0，则找到了根；否则，根位于[a,c]或[c,b]中的一个区间上，重复上述步骤，直到找到根。

该方法的主要优点是简单易用，适用于大部分单峰函数，并且收敛速度相对较快。

但是，该方法需要区间起点和终点具有异号，否则无法找到根。

二、牛顿迭代法牛顿迭代法是一种高效的方法，可用于求解任何无奇点的连续可微函数的根。

该方法的主要思想是将一个复杂的函数不断逼近于一条直线，然后通过直线和x轴的交点来不断逼近函数的根。

具体而言，对于一个连续可微函数f(x)，在初始点x0处进行求解。

首先，通过f(x)在x=x0处的导数f'(x0)来确定函数的切线。

然后，找到x轴上离该点最近的交点x1处，并将其作为新的起点，迭代上述过程，直到找到根。

该方法的主要优点在于速度快、精度高，并且可适用于大多数函数。

但是，该方法可能会出现迭代过程不稳定的问题，因此需要谨慎选择初值。

三、割线法割线法是一种类似于牛顿迭代法的方法，其主要思想是通过一条割线来逼近函数的根。

相比于牛顿迭代法，割线法更加适用于函数的导数难以求得的情况。

具体而言，对于一个函数f(x)，在初始点x0和x1处进行求解。

首先，通过f(x)在x=x0处和x=x1处的取值来确定割线，找到x轴上与割线交点x2处，并将其作为新的起点，重复上述步骤，直到找到根。

该方法的主要优点在于速度快、精度高，并且可适用于大多数函数。

二分法、不动点迭代法和牛顿迭代法是数值计算中常用的三种求根方法。

它们在不同的数学领域及实际问题中有着广泛的应用。

本文将对这三种方法进行介绍和比较。

一、二分法1. 原理二分法是一种基于区间不断缩小的求根方法。

其原理是通过在函数值的两个不同点处得到异号的情况下缩小区间来逼近实根。

具体过程为：首先确定一个区间[a,b]，使得f(a)和f(b)异号，然后将区间一分为二，取中点c=(a+b)/2，若f(c)为零或在一定误差范围内，则c即为所求的根；否则，根据f(a)和f(c)的符号确定新的区间[a,c]或[c,b]，重复上述步骤，直到满足要求。

2. 特点二分法的优点是简单易实现，对于连续且单调函数一定能收敛。

但其缺点是收敛速度较慢，尤其在根附近时迭代次数较多。

二、不动点迭代法1. 原理不动点迭代法是求解方程f(x)=0的一种迭代方法，通过将方程变换为x=g(x)，其中g(x)为连续函数，然后通过不断地迭代计算得到方程的根。

具体过程为：给定一个初始近似值x0，通过不断迭代计算xn+1=g(xn)来逼近实根。

2. 特点不动点迭代法的优点是迭代过程简单，不需要对函数进行求导。

但其缺点是收敛性有一定要求，不是所有的g(x)函数都能得到收敛结果。

三、牛顿迭代法1. 原理牛顿迭代法是一种通过不断线性化函数来逼近方程根的方法。

其原理是通过对函数f(x)进行泰勒展开，并取展开式的线性部分来进行迭代计算。

具体过程为：给定一个初始近似值x0，通过不断迭代计算xn+1=xn-f(xn)/f'(xn)来逼近实根。

2. 特点牛顿迭代法的优点是收敛速度较快，在根附近有二次收敛性。

但其缺点是需要对函数进行求导，且初始值的选取对迭代结果有一定影响。

二分法、不动点迭代法和牛顿迭代法都是求解方程根的有效方法，各有其优缺点和适用范围。

在实际应用中，根据问题的特性和计算要求来选择适当的方法，以达到准确和高效的求解目的。

4. 比较与应用通过对二分法、不动点迭代法和牛顿迭代法的介绍，我们可以对它们进行比较与应用。

C++牛顿法：快速求解非线性方程的利器！C++牛顿法是一种高效求解非线性方程的方法，通过不断迭代逼近方程的根，达到求解的目的。

本文将详细介绍C++牛顿法的实现原理、优点、缺点及在科学计算中的应用，并给出相应的代码实现和示例。

一、C++牛顿法的实现原理牛顿法是一种迭代算法，通过不断逼近非线性方程的根，达到求解的目的。

具体实现方法如下：选择一个初始值x0，作为迭代起点；计算函数f(x)在x0处的切线，得到切线方程的截距和斜率；通过切线方程求得下一个迭代点x1；重复步骤2和3，直到满足收敛条件为止。

二、C++牛顿法的优点和缺点1、优点：收敛速度快，一般情况下只需几次迭代就能得到精度较高的解；代码实现简单，易于掌握；可以处理具有多个根的情况。

2、缺点：收敛速度受初始值影响较大，若初始值选择不当，可能会导致算法不收敛；对于某些非线性方程，可能存在局部最小值或最大值，导致算法无法找到全局最优解。

三、C++牛顿法在科学计算中的应用牛顿法在科学计算中有着广泛的应用，例如：求解非线性方程组，如牛顿法可以用于求解二元二次方程组；求函数的零点，如牛顿法可以用于求平方根、对数等函数的零点；求函数的极值点，如牛顿法可以用于求函数的最小值或最大值。

四、C++牛顿法的代码实现和示例下面是一个示例的C++代码，用牛顿法求解方程f(x) = 0的根：#include <iostream>#include <cmath>// 定义函数f(x)double f(double x) {return x * x - 4;}// 定义函数f'(x)的导数double f_derivative(double x) {return 2 * x;}// 牛顿法求解方程的根double newton_method(double x0, double epsilon, int max_iterations) {double x = x0;int iterations = 0;while (iterations < max_iterations) {double fx = f(x);double fx_derivative = f_derivative(x);// 判断是否接近根if (std::abs(fx) < epsilon)break;// 更新xx = x - fx / fx_derivative;iterations++;}return x;}int main() {double x0 = 1.0; // 初始近似解double epsilon = 1e-6; // 精度int max_iterations = 1000; // 最大迭代次数// 使用牛顿法求解方程的根double root = newton_method(x0, epsilon, max_iterations);std::cout << "The root is: " << root << std::endl;return 0;}在上面的代码中，定义了函数f(x)和f'(x)的导数，然后使用牛顿法求解方程f(x) = 0的根。

利⽤⽜顿迭代法求解⾮线性⽅程组最近⼀个哥们，是⽤⽜顿迭代法求解⼀个四变量⽅程组的最优解问题，从⽹上找了代码去改进，但是总会有点不如意的地⽅，迭代的次数过多，但是却没有提⾼精度，真是令⼈揪⼼！经分析，发现是这个⽅程组中存在很多局部的极值点，是⽤⽜顿迭代法不能不免进⼊局部极值的问题，更程序的初始值有关！发现⾃⼰好久没有是⽤Matlab了，顺便从⽹上查了查代码，⾃⼰来修改⼀下！先普及⼀下⽜顿迭代法：(来⾃百度百科)⽜顿（Newton's method）⼜称为⽜顿-拉夫逊（拉弗森）⽅法（Newton-Raphson method），它是在17世纪提出的⼀种在域和域上近似求解⽅程的⽅法。

多数⽅程不存在求根公式，因此求精确根⾮常困难，甚⾄不可能，从⽽寻找⽅程的近似根就显得特别重要。

⽅法使⽤函数f(x）的的前⾯⼏项来寻找⽅程f(x) = 0的根。

⽜顿迭代法是求⽅程根的重要⽅法之⼀，其最⼤优点是在⽅程f(x) = 0的单根附近具有平⽅收敛，⽽且该法还可以⽤来求⽅程的重根、复根，此时线性收敛，但是可通过⼀些⽅法变成超线性收敛。

另外该⽅法⼴泛⽤于计算机编程中。

设r是f(x)=0的根。

选取x0作为r的初始近似值，过点(x0,f(x0))做曲线的切线，求出该切线与x轴的交点，并求出该点的横坐标，称作x1是r 的⼀次近似。

如此就可以推导出⽜顿迭代公式。

已经证明，如果是的，并且待求的零点是孤⽴的，那么在零点周围存在⼀个区域，只要初始值位于这个邻近区域内，那么⽜顿法必定收敛。

并且，如果不为0, 那么⽜顿法将具有平⽅收敛的性能. 粗略的说，这意味着每迭代⼀次，⽜顿法结果的有效数字将增加⼀倍。

在⽹上查了⼀些代码，都是能指定某⼏个函数进⾏求导的，⽽且要是改变函数的个数，却⼜要对原始程序⼤动⼲⼽。

真的是揪⼼。

找到了这个程序，貌似在Matlab上不能很好的运⾏，对于数据的返回值为空没有做处理，后来⼜找了⼀个⽹易朋友的博客，将他的代码拿过来跑跑，还可以，但是对于不同的函数⽅程组，以及变量个数就不同了，真的是揪⼼，这个就是程序设计和编码的问题了！⾃⼰就拿来改了改，可以⽀持多⽅程组和多变量了！下⾯附上我的代码！求⼤家指导！[python]1. function [r,n]=mulNewton(x0,funcMat,var,eps)2. % x0为两个变量的起始值,funcMat是两个⽅程,var为两个⽅程的两个变量,eps控制精度3. % ⽜顿迭代法解⼆元⾮线性⽅程组4. if nargin==05. x0 = [0.2,0.6];6. funcMat=[sym('(15*x1+10*x2)-((40-30*x1-10*x2)^2*(15-15*x1))*5e-4')...7. sym('(15*x1+10*x2)-((40-30*x1-10*x2)*(10-10*x2))*4e-2')];8. var=[sym('x1') sym('x2')];9. eps=1.0e-4;10. end11.12. n_Var = size(var,2);%变量的个数13. n_Func = size(funcMat,2);%函数的个数14. n_X = size(x0,2);%变量的个数15.16. if n_X ~= n_Var && n_X ~= n_Func17. fprintf('Expression Error!\n');18. exit(0);19. end20.21. r=x0-myf(x0, funcMat, var)*inv(dmyf(x0, funcMat, var));22. n=0;23. tol=1;24. while tol>=eps25. x0=r;26. r=x0-myf(x0, funcMat, var)*inv(dmyf(x0, funcMat, var));27. tol=norm(r-x0);28. n=n+1;29. if(n>100000)30. disp('迭代步数太多，⽅程可能不收敛');31. return;32. end33. end34. end % end mulNewton[python]1. function f=myf(x,funcMat, varMat)2. % 输⼊参数x为两个数值,func为1*2符号变量矩阵,var为1*2符号变量矩阵中的变量3. % 返回值为1*2矩阵,内容为数值4.5. n_X = size(x,2);%变量的个数6. f_Val = zeros(1,n_X);7. for i=1:n_X8. tmp_Var = cell(1,n_X);9. tmp_X = cell(1,n_X);10. for j=1:n_X11. tmp_Var{j} = varMat(1,j);12. tmp_X{j} = x(1,j);13. end14. f_Val(i) = subs(funcMat(1, i), tmp_Var, tmp_X);15. end16. f=f_Val;17. end % end myf[python]1. function df_val=dmyf(x, funcMat, varMat)2. % 返回值为2*2矩阵,内容为数值3. %df=[df1/x1, df1/x2;4. % df2/x1. df2/x2];5. n_X = size(x,2);%变量的个数6. df =cell(n_X, n_X);7. for i=1:n_X8. for j=1:n_X9. df{i,j} = diff(funcMat(1, i), varMat(1, j));10. end11. end12.13. df_val=zeros(n_X, n_X);14.15. for i=1:n_X16. for j=1:n_X17. tmp_Var = cell(1,n_X);18. tmp_X = cell(1,n_X);19. for k=1:n_X20. tmp_Var{k} = varMat(1,k);21. tmp_X{k} = x(1,k);22. end23. df_val(i,j) = subs(df{i,j}, tmp_Var, tmp_X);24. end25. end26. end % end dmyf。

用c语言实现牛顿拉夫逊迭代法如何用C语言实现牛顿拉弗森迭代法[引言]牛顿拉弗森迭代法（Newton-Raphson method），又称为牛顿迭代法，是一种求解方程根的数值方法。

它是由17世纪英国物理学家伊萨克·牛顿和法国数学家约瑟夫·拉弗森独立提出的。

牛顿拉弗森迭代法通过不断逼近方程根，可以实现高精度的方程求解。

[原理]牛顿拉弗森迭代法的原理很简单，基于方程根附近的切线逼近曲线，通过不断迭代的方式逼近方程的根。

设方程的根为x0，代入方程得到曲线上的一个点(x0, f(x0))。

假设方程在x0附近可导，那么我们可以得到曲线在点(x0, f(x0))处的切线方程，即通过(x0, f(x0))和斜率f'(x0)得到切线的方程。

切线与x轴的交点即为新的近似根x1。

依此类推，我们可以采用迭代的方式不断逼近更精确的解。

具体迭代公式为：x_(n+1) = x_n - f(x_n) / f'(x_n)其中，x_n是第n次迭代得到的近似解，f(x_n)是方程在x_n处的函数值，f'(x_n)是方程在x_n处的导数值。

通过不断迭代，当两次迭代解的差值小于预设的误差范围时，我们可以认为得到了方程的近似根。

[步骤]接下来，让我们一步一步的使用C语言实现牛顿拉弗森迭代法。

步骤1：导入所需的头文件和函数声明c#include <stdio.h>#include <math.h>double f(double x); 定义方程的函数表达式double f_derivative(double x); 定义方程的导数函数表达式步骤2：实现方程和导数函数cdouble f(double x) {实现方程的函数表达式return x * x - 9;}double f_derivative(double x) {实现方程的导数函数表达式return 2 * x;}步骤3：实现牛顿拉弗森迭代法cdouble newton_raphson_method(double x0, double epsilon) { double x = x0;double difference = epsilon + 1; 初始化差值，使其大于预设的误差范围while (difference > epsilon) {double f_x = f(x);double f_derivative_x = f_derivative(x);x = x - f_x / f_derivative_x;difference = fabs(f(x));}return x;}步骤4：调用牛顿拉弗森迭代法求解方程cint main() {double x0 = 4; 初始值double epsilon = 0.0001; 误差范围double root = newton_raphson_method(x0, epsilon);printf("方程的近似根为：%lf\n", root);return 0;}[总结]通过以上步骤，我们可以使用C语言实现牛顿拉弗森迭代法来求解给定方程的根。