[数值算法]求根算法系列小结

最新推荐文章于 2022-04-05 18:38:31 发布
最新推荐文章于 2022-04-05 18:38:31 发布
阅读量3.2k 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： 算法 null float output iterator file
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/EmilMatthew/article/details/473718
本文总结了数值算法中几种常见的求根方法，包括二分法、迭代法、Aitken加速法、牛顿求根法和割线法。通过实例展示了每种方法的实现过程和应用，以求解不同的方程。所有方法均考虑了收敛性和精度要求。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

[数值算法]求根算法系列小结

1二分求根法:

       二分求根法主要用的思想是不断调整并缩小搜索区间的大小，当搜索区间的大小已小于搜索精度要求时，则可说明已找到满足条件的近拟根.

       当然，在这之前，首先是要准确的估计出根所处的区间，否则，是找不到根的。

Type binaryPationMethod(Type x1,Type x2,Type e,Type (*arguF)(Type),FILE* outputFile)

{

       Type x;/*The return answer*/

       Type mid;

       Type down,up;

       int iteratorNum=0;

 

 

       down=x1;

       up=x2;

      

       assertF(x1<=x2,"in twoPation x1>=x2");

       assertF(arguF!=NULL,"in twoPation arguF is NULL");

       assertF(outputFile!=NULL,"in twoPation outputFile is NULL");

       assertF((*arguF)(x1)*(*arguF)(x2)<=0,"in twoPation,f(x1)*f(x2)>0");

      

       fprintf(outputFile,"down/t/tup/t/t/r/n");

       /*two pation is a method that is surely to find root for a formula*/

       while(fabs(up-down)>(float)1/(float)2*e)

       {

              mid=(down+up)/2;

              if ((*arguF)(mid)==0)

                     break;

              else if(((*arguF)(down))*((*arguF)(mid))>0)

                     down=mid;

              else

                     up=mid;

             

              fprintf(outputFile,"% -12f% -12f/r/n",down,up);

              iteratorNum++;

       }

       /*get the answer*/

       x=mid;

      

       /*Output Answer*/

       fprintf(outputFile,"total iterator time is:%d/r/n",iteratorNum);           

       fprintf(outputFile,"a root of equation is :%f/r/n",x);

      

       return x;

}

       测试1：用二分法求:

f(x)=x^3-x^2-2*x+1=0在(0,1)附近的根.

精度:0.001.

Output:

down             up          

0.000000    0.500000   

0.250000    0.500000   

0.375000    0.500000   

0.437500    0.500000   

0.437500    0.468750   

0.437500    0.453125   

0.437500    0.445313   

0.441406    0.445313   

0.443359    0.445313   

0.444336    0.445313   

0.444824    0.445313   

total iterator time is:11

a root of equation is :0.444824

 

 

2迭代法：

迭代法首先要求方程能够化到x=fi(x)的形式，并且还要保证这个式子在所给定的区间范围内满足收敛要求.

主要的迭代过程是简单的，就是:

x_k+1=fi(xk)

当xk+1-xk满足精度要求时，则表示已找到方程的近拟根.

Type iteratorMethod(Type downLimit,Type upLimit,Type precise,Type (*fiArguF)(Type),FILE* outputFile)

{

       Type xk;

       int iteratorNum=0;

      

       assertF(downLimit<=upLimit,"in iteratorMethod x1>=x2");

       assertF(fiArguF!=NULL,"in iteratorMethod arguF is NULL");

       assertF(outputFile!=NULL,"in iteratorMethod outputFile is NULL");

      

       xk=downLimit;

      

       fprintf(outputFile,"k/t/tXk/t/t/r/n");

       fprintf(outputFile,"%-12d% -12f/r/n",iteratorNum,xk);

       iteratorNum++;

      

       while(fabs((*fiArguF)(xk)-xk)>(float)1/(float)2*precise)

       {

              /*in mathematic,reason:*/

              /*

              xk_1=(*fiArguF)(xk);

              */

              xk=(*fiArguF)(xk);

              fprintf(outputFile,"%-12d% -12f/r/n",iteratorNum,xk);

              iteratorNum++;

       }

       fprintf(outputFile,"root finded at x=%f/r/n",xk);

      

       return xk;

}

 

 

测试2：用迭代法求解方程

f(x)=1/(x+1)^2的近似根.

根的有效区间在(0.4,0.55).

精度为0.0001.

Output:

k            Xk         

0           0.400000   

1           0.510204   

2           0.438459   

3           0.483287   

4           0.454516   

5           0.472675   

6           0.461090   

7           0.468431   

8           0.463759   

9           0.466724   

10          0.464839   

11          0.466037   

12          0.465276   

13          0.465759   

14          0.465452   

15          0.465647   

16          0.465523   

17          0.465602   

18          0.465552   

root finded at x=0.465552

 

 

3Aitken加速法

       Aitken也是基于迭代法的一种求根方案，所不同的是它在迭代式的选取上做了一些工作，使得迭代的速度变得更快.

       Type AitkenAccMethod(Type startX,Type precise,Type (*fiArguF)(Type),FILE* outputFile)

{

       Type xk;

       int iteratorNum=0;

      

       assertF(fiArguF!=NULL,"in AitkenAccMethod arguF is NULL");

       assertF(outputFile!=NULL,"in AitkenAccMethod outputFile is NULL");

      

       xk=startX;

       fprintf(outputFile,"k/t/tXk/t/t/r/n");

       fprintf(outputFile,"%-12d% -12f/r/n",iteratorNum,xk);

       iteratorNum++;

      

       while(fabs((*fiArguF)(xk)-xk)>(float)1/(float)2*precise)

       {

              xk=(xk*(*fiArguF)((*fiArguF)(xk))-(*fiArguF)(xk)*(*fiArguF)(xk))/((*fiArguF)((*fiArguF)(xk))-2*(*fiArguF)(xk)+xk);

              fprintf(outputFile,"%-12d% -12f/r/n",iteratorNum,xk);

              iteratorNum++;

       }

      

       fprintf(outputFile,"root finded at x=%f/r/n",xk);

       return xk;

}

 

 

测试3:Aitken迭代加速算法的应用

计算的是方程

x=1/(x+1)^2在x=0.4附近的近似根.

精度:0.0001

Ouput:

k            Xk         

0           0.400000   

1           0.466749   

2           0.465570   

root finded at x=0.465570

 

 

 

 

4牛顿求根法:

       牛顿求根法通过对原方程切线方程的变换，保证了迭代结果的收敛性，唯一麻烦的地方是要提供原函数的导数:

       Type NewTownMethod(Type startX,Type precise,Type (*fiArguF)(Type),Type (*fiArguFDao)(Type),FILE* outputFile)

{

      

       Type xk;

       int iteratorNum=0;

      

       assertF(fiArguF!=NULL,"in NewTownMethod,arguF is NULL/n");

       assertF(fiArguFDao!=NULL,"in NewTownMethod,fiArguFDao is NULL/n");

       assertF(outputFile!=NULL,"in NewTownMethod,fiArguFDao is NULL/n");

      

       xk=startX;

       fprintf(outputFile,"k/t/tXk/t/t/r/n");

       fprintf(outputFile,"%-12d% -12f/r/n",iteratorNum,xk);

       iteratorNum++;

      

       while(fabs((*fiArguF)(xk)/(*fiArguFDao)(xk))>(float)1/(float)2*precise)

       {

              /*

              Core Maths Reason

              Xk+1=Xk-f(Xk)/f'(Xk);

              */

              xk=xk-(*fiArguF)(xk)/(*fiArguFDao)(xk);

              fprintf(outputFile,"%-12d% -12f/r/n",iteratorNum,xk);

              iteratorNum++;

       }

      

       fprintf(outputFile,"root finded at x=%f/r/n",xk);

       return xk;

}

 

 

测试4：牛顿求根法的应用:

被求方程为：f(x)=x(x+1)^2-1=0

其导数为：f'(x)=(x+1)(3x+1)

所求其在0.4附近的近似根.

精度为0.00001

Output:

k            Xk         

0           0.400000   

1           0.470130   

2           0.465591   

3           0.465571   

root finded at x=0.465571

 

 

5割线法（快速弦截法）:

       是用差商来代替避免求f’(x)的一种方案,由这种迭代式产生的结果序列一定是收敛的.

Type geXianMethod(Type down,Type up,Type precise,Type (*fiArguF)(Type),FILE* outputFile)

{

       Type xk,xk_1,tmpData;

       int iteratorNum=0;

      

       assertF(fiArguF!=NULL,"in geXian method,fiArguF is null/n");

       assertF(outputFile!=NULL,"in geXian method,outputFile is null/n");

       assertF(down<=up,"in geXian method,down>up/n");

      

       xk_1=down;

       xk=up;

      

       fprintf(outputFile,"k/t/tXk_1/t/tXk/t/t/r/n");

       fprintf(outputFile,"%-12d%-12f%-12f/r/n",iteratorNum,xk_1,xk);

       iteratorNum++;

      

       while(fabs(xk-xk_1)>(float)1/(float)2*precise)

       {

              tmpData=xk;

              xk=xk-(*fiArguF)(xk)*(xk-xk_1)/((*fiArguF)(xk)-(*fiArguF)(xk_1));

              xk_1=tmpData;

              fprintf(outputFile,"%-12d%-12f%-12f/r/n",iteratorNum,xk_1,xk);

              iteratorNum++;

       }

       fprintf(outputFile,"root finded at x=%f/r/n",xk);

      

       return xk;

}

       测试5:割线法的应用:

       所求的方程为:

f(x)=x*(x+1)^2-1=0

寻根范围:[0.4,0.6]

精度:0.00001

Output:L

k                 Xk_1            Xk       

0           0.400000    0.600000   

1           0.600000    0.457447   

2           0.457447    0.464599   

3           0.464599    0.465579   

4           0.465579    0.465571   

5           0.465571    0.465571   

root finded at x=0.465571

我的演示程序的源码下载:

http://free3.e-168.cn/as2forward/downloads/feature_FindRoot.rar

//如果上面这个链接无法响应下载（有可能是被网站给屏蔽掉了），则可使用下载工具（如迅雷等）下载。

EmilMatthew
关注
遗传算法（Genetic Algorithm）详解与实现
盼小辉丶的博客
12-25 22万+
遗传算法（Genetic Algorithm, GA）是受自然进化原理启发的一系列搜索算法。通过模仿自然选择和繁殖的过程，遗传算法可以为涉及搜索、优化和学习的各种问题提供高质量的解决方案。同时，它们类似于自然进化，因此遗传算法可以克服传统搜索和优化算法遇到的一些障碍，尤其是对于具有大量参数和复杂数学表示形式的问题。
蚁群算法小结及算法实例（附Matlab代码）
热门推荐
LXzerorb的博客
04-21 5万+
目录 1、基本蚁群算法 2、基本蚁群算法的流程 3、关键参数说明 3.1信息素启发式因子 α 3.2期望启发因子 β 3.3信息素蒸发系数 ρ 3.4蚂蚁数目 m 3.5信息素强度 Q 对算法性能的影响 3.6最大进化代数 G 4、MATLAB仿真实例 4.1 蚁群算法求解旅行商问题（TSP） 蚁群算法求解旅行商问题MATLAB源程序： 4.2 蚁群算法求解二元函数极值 蚁群算法求解二元函数极值MATLAB源程序： 5、蚁群算法的特点 6、改进的蚁群算法 6.1...
muller:求方程根的数学穆勒方法-matlab开发
05-30
专为我的家庭作业而建； 输入方程，第一点，第二点，敏感性和跑步乐趣:)
求数根的简单算法
scanferror的博客
11-28 2644
#include  using namespace std; int n; int main() { cin>>n; cout }
快速求根算法
alss1923的博客
03-16 1262
//---Algorithm float(IEEE754)用------ inline float t_sqrtF( const float& x ) { float xHalf = 0.5f * x; int tmp = 0x5F3759DF - ( *(int*)&x >> 1 ); //initial guess float xRes = *(float...
一元非线性方程求根的算法——二分法/牛顿迭代法
qq_53369920的博客
04-05 3797
二分与迭代
数值分析函数 1：二分法、定点法、Newton-Raphson 和 Muller 方法的函数。-matlab开发
06-01
采用二分法、定点法、牛顿-拉夫森法和穆勒法的数值分析函数。 每个返回给定函数的根，以及可选的迭代表。 *** 不需要符号工具箱 ***
JavaScript累加、迭代、穷举、递归等常用算法实例小结
12-10
累加是指将一系列数值相加，得到一个总和。例如，计算1到100的数的累加和可以通过循环实现，如下所示： ```javascript var sum = 0; for (var i = 1; i ; i++) { sum += i; } ``` 累积累加则是将数值逐次相乘，如...
算法初步知识小结.pptx
最新发布
06-29
在数学和计算机科学中，算法是一系列明确定义的指令，用于完成特定的任务或解决问题。一个算法必须具有明确性和有限性，即它必须以清晰的步骤顺序进行，且在有限的步骤后必须能结束。算法可以用程序框图来表示，程序...
iOS中排列组合算法的使用小结
08-26
总的来说，iOS中的排列组合算法实现需考虑到数值溢出、效率和正确性。在实际开发中，可以根据具体场景选择合适的方法，如递归或循环，并注意优化算法以提高性能。此外，持续学习和交流可以发现更多高效解法，为项目...
方程求根的计算方法
07-19
方程求根的数值计算方法
求根的JAVA程序
09-25
求根的JAVA程序
算法面试题之求根运算
白首码农的博客
10-29 276
求根运算主要有两种方法： 一种是二分法，这个是比较好理解的 一种是牛顿迭代法，这个有点晦涩，迭代的公式是这样的 其中 /** * 求根运算 */ public class CalRootTest { public static void main(String[] args) { System.out.println(byBinarySearch(81,2)); System.out.println(byNewtonIterator(.
《数值分析（原书第2版）》—— 0.4　有效数字缺失
weixin_33729196的博客
07-04 1876
本节书摘来自华章出版社《数值分析（原书第2版）》一 书中的第0章，第0.4节，作者：（美）Timothy Sauer，更多章节内容可以访问云栖社区“华章计算机”公众号查看。 0.4　有效数字缺失 了解计算机算术的细节的好处在于我们在一个相对好的位置上理解计算机计算中可能出现的陷阱.有一个主要问题以多种形式出现，该问题是由于对近似相等的两个数字相减造成有效...
使用弦截法解方程通用方法
worldy的专栏
11-11 3972
奉献一个使用线截法解方程的方法，不足之处欢迎大家提出宝贵意见； #include double Fun(double x) { //计算f(x）=//求x^3-5x^2+16x-80的值 return x*(x*x-5*x+16)-80;//求解的的函数(一元函数) } double Fun2(double x) { //计算f(x）=1-cos(x)cosh(x
弦截法计算一元多次方程的根
m0_61892085的博客
02-07 952
Description 下面程序的功能是采用弦截法求方程 x^3- 11.1x^2+38.8x-41.77=0 的根。其中函数root用来求区间（x1,x2）的实根。​ 请将程序补充完整。 #include<stdio.h> double root(double,double); int main() { double x1,x2,ans; scanf("%lf%lf",&x1,&x2); ans=root(x1,x2); printf("%lf\n",ans); return
弦截求根_试探逼近_斜率计算_函数嵌套_迭代运算
qq_26079279的博客
03-19 1151
一、弦截法（解一元三次方程）通常，一元三次方程可以通过因式分解来得到根，如：x^3 + 3x^2 -3x - 5 = 0    等价于(x+1)(x^2 + 2x -5) = 0然而多数一元高次方程很难进行因式分解。试探法：  先估计大致的根，然后按照某种规则进行迭代、试探与修正，逐步逼近根，直到得出的根满足一定的精度要求为止。根据逼近方式不同，有 弦截法，切线法（牛顿迭代法）等。弦截法（解一元三...
记录|二分法求根及其代码
馨霏儿的博客
04-29 1158
最近学习matlab及其相关的数学内容，正好老师留了用二分法进行求根，在寻找过程中，代码需要记录循环k次及其每一次的结果，我问了些人，最后求出结果，将代码及其结果呈现如下，由于二分法原理很简单，故而这里就不进行赘述，有问题随时交流哦
[转]快速计算平方根倒数的一个算法
looongson的专栏
03-09 3541
 在3D图形编程中，经常要求平方根或平方根的倒数，例如：求向量的长度或将向量归一化。C数学函数库中的sqrt具有理想的精度，但对于3D游戏程式来说速度太慢。我们希望能够在保证足够的精度的同时，进一步提高速度。Carmack在QUAKE3中使用了下面的算法，它第一次在公众场合出现的时候，几乎震住了所有的人。据说该算法其实并不是Carmack发明的，它真正的作者是Nvidia的Gary Tar
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值