数值分析-迭代算法

本文转自http://blog.csdn.net/xiaowei_cqu/article/details/8585703

牛顿迭代公式

设已知方程f(x)=0的近似根x0 ,则在x0附近f(x)可用一阶泰勒多项式 近似代替.因此, 方程f(x)=0可近似地表示为p(x)=0。用x1表示p(x)=0的根,它与f(x)=0的根差异不大. 

设 ,由于x1满足解得

重复这一过程,得到迭代公式：

 

这就是著名的牛顿迭代公式,它相应的不动点方程为

Jacobi迭代公式解线性方程组

线性方程组基本解法：

若 方程组可同解变形为

Jacobi迭代法的计算公式：

即 

算法代码

[cpp]  view plain copy

1. /*简单迭代法的代码实现*/  
2. #include<iostream>  
3. #include<string>  
4. #include<cmath>  
5. using namespace std;  
6. double e=2.718281818284;  
7. double f(double x){  
8.     return pow(e,-1*x);  
9. }  
10. void SimpleDiedai(double x,double d){  
11.     double a=x;  
12.     double b=f(a);  
13.     int k=0;//记录循环的次数  
14.     while(((a-b)>d) || ((a-b)<-1*d)){  
15.         cout<<a<<endl;  
16.         a=b;  
17.         b=f(a);  
18.         k++;  
19.         if(k>100){  
20.             cout<<"迭代失败！（可能是函数不收敛）"<<endl;  
21.             return ;  
22.         }  
23.     }  
24.     cout<<b<<endl;  
25.     return;  
26. }  
27. int main(){  
28.     cout<<"请输入初始值x0和要求得结果的精度：";  
29.     double x,d;  
30.     cin>>x>>d;  
31.     SimpleDiedai (x,d);  
32.     return 0;  
33. }  
34.   
35. /*牛顿迭代法的代码实现*/  
36. #include<iostream>  
37. #include<string>  
38. #include<cmath>  
39. using namespace std;  
40. double e=2.718281818284;  
41. double f(double x){  
42.     double a=pow(e,-1*x);  
43.     return x-(x-a)/(1+a);  
44. }  
45. void NewtonDiedai(double x,double d){  
46.     double a=x;  
47.     double b=f(a);  
48.     int k=0; //记录循环的次数  
49.     while(((a-b)>d) || ((a-b)<-1*d)){  
50.         cout<<a<<endl;  
51.         a=b;  
52.         b=f(a);  
53.         k++;  
54.         if(k>100){  
55.             cout<<"迭代失败！（可能是函数不收敛）"<<endl;  
56.             return ;  
57.         }  
58.     }  
59.     cout<<b<<endl;  
60.     return;  
61. }  
62.   
63. int main(){  
64.     cout<<"请输入初始值x0和要求得结果的精度：";  
65.     double x,d;  
66.     cin>>x>>d;  
67.     NewtonDiedai(x,d);  
68.     return 0;  
69. }  
70.   
71. /*雅可比算法的代码实现*/  
72. #include<iostream>  
73. #include<iomanip>  
74. #include<string>  
75. #include<vector>  
76. using namespace std;        
77.   
78. //函数求数组中的最大值  
79. double MaxOfList(vector<double>x){  
80.     double max=x[0];  
81.     int n=x.size();  
82.     for(int i=0;i<n;i++)  
83.         if(x[i]>max) max=x[i];  
84.     return max;  
85. }  
86.   
87. //雅可比迭代公式  
88. void Jacobi(vector<vector<double> > A,vector<double> B,int n){  
89.     vector<double> X(n,0);  
90.     vector<double> Y(n,0);  
91.     vector<double> D(n,0);  
92.     int k=0; //记录循环次数  
93.     do{   
94.         X=Y;  
95.         for(int i=0;i<n;i++){  
96.             double tem=0;  
97.             for(int j=0;j<n;j++){  
98.                 if(i!=j) tem += A[i][j]*X[j];  
99.             }  
100.             Y[i]=(B[i]-tem)/A[i][i];  
101.             cout<<left<<setw(8)<<Y[i]<<" ";  
102.         }  
103.         cout<<endl;  
104.         k++;  
105.         if(k>100){  
106.             cout<<"迭代失败！（可能是函数不收敛）"<<endl;  
107.             return ;  
108.         }  
109.           
110.         for(int a=0;a<n;a++){  
111.             D[a]=X[a]-Y[a];  
112.         }  
113.     }while( MaxOfList(D)>0.00001 || MaxOfList(D)<-0.00001);  
114.       
115.     return ;  
116. }  
117.   
118. int main(){  
119.   
120.     int n;  
121.     cout<<"请输入方程组未知数的个数n：";  
122.     cin>>n;  
123.     cout<<endl;  
124.   
125.     vector<vector<double> >A(n,vector<double>(n,0));  
126.     vector<double>B(n,0);  
127.       
128.     cout<<"请输入方程组的系数矩阵："<<endl;  
129.     for(int i=0;i<n;i++){  
130.         for(int j=0;j<n;j++){  
131.             cin>>A[i][j];  
132.         }  
133.     }  
134.     cout<<endl;  
135.       
136.     cout<<"请输入方程组的值向量："<<endl;  
137.     for(int k=0;k<n;k++){  
138.         cin>>B[k];  
139.     }  
140.     cout<<endl;  
141.       
142.     cout<<"您输入的方程组为："<<endl;  
143.     for(int a=0;a<n;a++){  
144.         for(int b=0;b<n;b++){  
145.             cout<<A[a][b]<<" ";  
146.         }  
147.         cout<<"    "<<B[a]<<endl;  
148.     }  
149.     cout<<endl;  
150.     cout<<"由雅可比迭代公式求的方程组的解为："<<endl;  
151.     Jacobi(A,B,n);  
152.     return 0;  
153. }  

实验过程原始记录

（1）分别用简单迭代法和牛顿迭代法求方程 在x=0.5附近的一个根x*，要求精度为0.00001

（输入0.5 0.000001）简单迭代法得到结果：

（输入0.5 0.000001）牛顿迭代法得到结果：
X0=0.5  x1=0.566311 x2=0.567143

（2）用雅可比迭代法求解方程组  

运行程序，根据提示输入 （3） （10 -1 -2 -1 10 -2 -1 -2 5）    （7.2  8.3  4.2）

实验结果及分析

1、迭代法是一种逐次逼近法，这种方法使用某个固定公式－所谓迭代公式反复校正根的近似值，使之逐步精确化，直至满足精度要求的结果。迭代法是一种求解函数方程f（x）=0的解的方法，他解决了二分法无法求解复根级偶重根的问题，而其提高了收敛速度。迭代的思想是计算方法中基础的求解问题的思想。
2、简单迭代法的求根过程分成两步，第一步先提供根的某个猜测值，即所谓迭代初值，然后将迭代初值逐步加工成满足精度要求的根。迭代法的设计思想是：f (x) = 0等价变换成 然后由迭代公式 逐步球的满足精度的解。实际迭代中不同迭代函数的求解可能影响求的精确解的运算量，甚至可能因为函数发散而无法求解。解题时可通过对导函数的判断而判断函数是否发散，而编写代码时可以通过判断循环次数——即循环过多次而不能从循环中出来时就判断为死循环，无法求得正解
3、简单迭代法往往只是线性收敛，为得出超线性收敛的迭代格式，通常采用近似替代法 ， 即牛顿公式 。迭代函数为  - / 牛顿法是一种逐步线性化方法。由实验结果可以看到，虽然选取近似公式，但牛顿迭代法仍能得到精度很高的解，而且牛顿迭代法大大提高了收敛速度。
4、由迭代法求解线性方程组的基本思想是将联立方程组的求解归结为重复计算一组彼此独立的线性表达式，这就使问题得到了简化，类似简单迭代法转换方程组中每个方程式可得到雅可比迭代式

迭代法求解方程组有一定的局限性，例如要求方程组的系数矩阵具有某种特殊性质，以保证迭代过程的收敛性，但迭代法同时有十分明显的优点——算法简单，因而编制程序比较容易，所以在实际求解问题中仍有非常大利用价值。