牛頓法編程
❶ 數值分析課程設計，編制一般迭代法、牛頓法、弦截法求解方程組的計算機程序，並分析它們的特點
C++才是主流語言。。
你是建模用的嗎？那可根據語法稍加修改，這個編程實現的難度不大。
#include <iostream>//弦截法
using namespace std;
static int count=1;
double f(double x)
{
return (x*x*x-x-1);
}
int main()
{
double x0,x1,x2;
double e=0.00001;
cout<<"請輸入兩個初值X0，X1"<<endl;
cin>>x0>>x1;
x2=x1-f(x1)*(x1-x0)/(f(x1)-f(x0));
while(x2-x1>e||x1-x2>e)
{
x0=x1;
x1=x2;
x2=x1-f(x1)*(x1-x0)/(f(x1)-f(x0));
count+=1;
}
cout<<"方程的根為："<<x2<<endl;
cout<<"迭代的次數為："<<count<<endl;
return 0;
}
#include<iostream>//簡單迭代法
#include<math.h>
using namespace std;
double f(double t0)
{ double t=t0+1;
return pow(t,1.0/3);
}
int main()
{
double a,b,x0,x1,e;
static int count=1;
cout<<"請輸入A，B的值"<<endl;
cin>>a>>b;
cout<<"請輸入E的值"<<endl;
cin>>e;
x0=(a+b)/2;
x1=f(x0);
while((x1-x0)>e||(x0-x1)>e)
{
count+=1;
x0=x1;
x1=f(x0);
}
cout<<"方程的根為："<<x1<<endl;
cout<<"迭代次數"<<count<<endl;
return 0;
}
#include <iostream>//牛頓迭代法
using namespace std;
static k=0;
static int count=1;
double newt(double x)
{
return (x*x*x-x-1);
}
int main()
{
double x0,x1,x2;
cout<<"請輸入兩個初值X0，X1"<<endl;
cin>>x0>>x1;
x2=x1-f(x1)*(x1-x0)/(f(x1)-f(x0));
while(x2-x1>e||x1-x2>e)
{
x0=x1;
x1=x2;
x2=x1-f(x1)*(x1-x0)/(f(x1)-f(x0));
count+=1;
}
cout<<"方程的根為："<<x2<<endl;
cout<<"迭代的次數為："<<count<<endl;
return 0;
}
牛頓迭代法是求方程根的重要方法之一，，方法使用函數f(x)的泰勒級數的前面幾項來尋找方程f(x) = 0的根。其最大優點是在方程f(x) = 0的單根附近具有平方收斂，而且該法還可以用來求方程的重根、復根。另外該方法廣泛用於計算機編程中。
簡單迭代法又稱逐次迭代法，基本思想是構造不動點方程，以求得近似根。即由方程f(x)=0變換為x=F(x), 然後建立迭代格式
弦截法計算x(k+1)時需要利用前兩步信息x(k),x(k-1).免去了Newton法中需要求解一階導函數的繁瑣.
但收斂速度比牛頓法要慢
❷ Matlab編程問題：編寫牛頓法程序來求解下面的方程組： (x-2)^2+(y-3+2x)^2=5 2(x-3)^2+(y/3)^2=4
% 用牛頓迭代法解非線性方程組
% F1=(x-2)^2+(y-3+2x)^2-5=0
% F2=2(x-3)^2+(y/3)^2-4=0
% F=[F1;F2]=[5*x^2 + 4*x*y - 16*x + y^2 - 6*y + 8
% 2*x^2 - 12*x + y^2/9 +14 ]
%迭代初值設為：X0=[x,y]=[0,0]'
% X(k+1)=X(k)+delt_X
% Jaco_F(X(k))*delt_X(k)=-F(X(k))
% Jaco_F為Jacobian矩陣
% Jaco_F=[10*x+4*y-16 2*y+4*x-6
% 4*x-12 2*y/9]
%error 為 ||X(k+1)-X(k)||,當error小於0.0001時，迭代停止
x=0;
y=0;
error=10;
while(error>0.0001)
F = [ 5*x^2+4*x*y-16*x+y^2-6*y+8
2*x^2-12*x+y^2/9+14 ];
Jaco_F = [10*x+4*y-16 2*y+4*x-6
4*x-12 2*y/9];
X = [x y]' - (inv(Jaco_F))*F; %迭代後的X值
error=norm(X-[x,y]'); % error=||X(k+1)-X(k)||
x=X(1);
y=X(2);
end
x
y
%%%%%%%%%%%%%到此結束%%%%%%%%%%%%%
程序結果：
x =
1.7362
y =
-2.6929
望採納！
❸ 用matlab做，牛頓迭代法
function [ A ] = cal( a,b,v )%a,b表示區間，v是精度
i=1;
x = (a+b)/2;
A=[i x];
t = x-(x^3-x-1)/(3*x^2-1);%迭代函數
while(abs(t-x)>v)
i=i+1;
x = t;
A = [A;i x];
t = x-(x^3-x-1)/(3*x^2-1);%迭代函數
end
A = [A;i+1 t];
end
運行結果：
>> format long;
>> cal(1,2,0.00001)
ans =
1.000000000000000 1.500000000000000
2.000000000000000 1.347826086956522
3.000000000000000 1.325200398950907
4.000000000000000 1.324718173999054
5.000000000000000 1.324717957244790
❹ matlab編寫 牛頓法解非線性方程的程序
這個牛頓法程序對嗎？給你一個可用的：function main()
clc; clear all;
f = @(x)log(x+sin(x));
df = @(x)(1+cos(x))/(x+sin(x));
x0 = 0.1;
x = TestNewton(f, df, x0)function x = TestNewton(fname, dfname, x0, e, N)
% 用途：Newton迭代法解非線性方程f(x)=0
% fname和dfname分別表示f(x)及其導函數的M函數句柄或內嵌函數表達式
% x0為迭代初值，e為精度（默認值1e-7）
% x為返回數值解，並顯示計算過程，設置迭代次數上限N以防發散（默認500次）if nargin < 5
N = 500;
end
if nargin < 4
e = 1e-7;
end
x = x0;
x0 = x+2*e;
k = 0;
fprintf('x[%d]=%12.9f\n', k, x)
while abs(x0-x)>e && k<N
k = k+1;
x0 = x;
x = x0 - feval(fname,x0)/feval(dfname,x0);
fprintf('x[%d]=%12.9f\n', k, x)
end
if k == N
fprintf('已達到迭代次數上限');
end
結果：x[0]= 0.100000000
x[1]= 0.261295899
x[2]= 0.434317505
x[3]= 0.504499011
x[4]= 0.510928606
x[5]= 0.510973427
x[6]= 0.510973429x = 0.5110>>
❺ matlab中牛頓法程序
採用第一個。
首先你的兩個代碼的計算過程和方法以及步驟是一致的。
只不過第二個將k==N放在循環內部判斷是沒有必要的。
放在while外面，可以節省點計算量。
如果你要求結果精度高一些的話，你調用：
x=nanewton1(fname,dfname,x0,e,N)
時e要小一些，比如說取1e-6這樣。
另外：
if nargin<4
e=1e-4; %這個值也下調幾個量級，作為預設的精度。
end
❻ matlab中牛頓法編程
這樣吧，你不要直接通過solve求解啊，可以畫一個圖像啊，以x的值為橫坐標，行列式值為縱坐標，或者縱坐標取一下對數（如果變化范圍太大），然後可以得出大致得到解的范圍；最後可以通過其他方法計算更加精確的解。
希望能幫到你，我算程序就是這樣實現的
❼ 牛頓迭代法求解非線性方程的c++編程
牛頓法是牛頓在17世紀提出的一種求解方程f(x)=0.多數方程不存在求根公式，從而求精確根非常困難，甚至不可能，從而尋找方程的近似根就顯得特別重要。 設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的二次近似值，重復以上過程，得r的近似值序列{Xn},其中Xn 1=Xn-f(Xn)/f'(Xn),稱為r的n 1次近似值
❽ 求 C語言 牛頓迭代法 程序~~~~~~~~~~~~
給你一點提示。
牛頓迭代法要計算
(1)
y1=f(x)
在
x
的函數值
(2)
d1=f(x)
的一階導數
在
x
的值
你可以寫兩個函數，分別計算y1,d1
如果一階導數有解析解，則可用賦值語句，否則要寫數值解子程序。
步驟：
設解的精度,例
float
eps=0.000001;
設x初值，x1;
算y1=f(x1);
迭代循環開始
算一階導數
在
x1
的值
d1
用牛頓公式
算出
x2;
[x2
=
x1
-
y1
/
d1]
如果
fabs(x2-x1)
>
eps
則從新迭代
--
用新的函數值和一階導數值推下一個
新x.
❾ 用MATLAB編出牛頓迭代法的程序
function newton(x0,e,N)
%輸入xo為估計的迭代初值,e為規定的誤差,N為最大迭代次數.
%輸出x,y為最後迭代的兩個近似根,k為迭代次數.
clc
format long;
disp('迭代次數 近似根')
k=0;
x1=0;
x2=x0;
while (abs(x2-x1))>e
x1=x2;
x2=x1-f(x1)./df(x1);
k=k+1;
if k>N
return;
end
%%%%%%記錄並輸出%%%%%%%%%
o1=sprintf('%3d',k);
o2=sprintf('%3.8f',x2);
OL=[o1,' ' o2];
disp(OL);
y(k)=x2;
end
%%%%畫圖%%%%%%%
i=1:k;
figure(2)
plot(i,y,'rD-')
grid on
xlabel('迭代次數')
ylabel('近似根')
title(['牛頓法求出的該方程的近似根 x^*=', num2str(x2,9)])
function y=f(x)
y=x^2/2-sin(x)-1;
function y=df(x)
y=x-cos(x);
❿ 牛頓法解非線性方程組c++程序
#include<iostream>
#include<cstdlib>
#include<cmath>
using
namespace
std;
#define
N
2
//用來設置方程組的行數
#define
eps
2.2204e-16
double*
MatrixMultiply(double*
J,double
Y[]);
double*
Inv(double
*J);
double
norm(double
Q[]);
double*
F(double
X[]);
double*
JF(double
X[]);
int
method(double*
Y,double
epsilon);
int
newdim(double
P[],double
delta,double
epsilon,int
max1,double
*err)
{
double
*Y=NULL,*J=NULL,Q[2]={0},*Z=NULL,*temp=NULL;
double
relerr=0.0;
int
k=0,i=0,iter=0;
Y=F(P);
for(k=1;k<max1;k++)
{
J=JF(P);
temp=MatrixMultiply(Inv(J),Y);
for(i=0;i<N;i++)
Q[i]=P[i]-temp[i];
Z=F(Q);
for(i=0;i<N;i++)
temp[i]=Q[i]-P[i];
*err=norm(temp);
relerr=*err/(norm(Q)+eps);
for(i=0;i<N;i++)
P[i]=Q[i];
for(i=0;i<N;i++)
Y[i]=Z[i];
iter=k;
if((*err<delta)||(relerr<delta)||method(Y,epsilon))
break;
}
return
iter;
}
int
method(double*
Y,double
epsilon)
{
if(fabs(Y[0])<epsilon&&fabs(Y[1])<epsilon)
return
1;
else
return
0;
}
//矩陣乘法，要求，J為方陣，Y為與J維數相同的列向量
double
*MatrixMultiply(double*
J,double
Y[])
{
double
*X=NULL;
int
i=0,j=0;
X=(double*)malloc(N*sizeof(double));
for(i=0;i<N;i++)
X[i]=0;
for(i=0;i<N;i++)
for(j=0;j<N;j++)
X[i]+=J[i*N+j]*Y[j];
return
X;
}
//二階矩陣的求逆（在M次多項式曲線擬合演算法文件中給出了對任意可逆矩陣的求逆演算法）
double
*Inv(double
*J)
{
double
X[4]={0},temp=0.0;
int
i=0;
temp=1/(J[0]*J[3]-J[1]*J[2]);
X[0]=J[3];
X[1]=-J[1];
X[2]=-J[2];
X[3]=J[0];
for(i=0;i<4;i++)
J[i]=temp*X[i];
return
J;
}
double
norm(double
Q[])
{
double
max=0.0;
int
i=0;
for(i=0;i<N;i++)
{
if(Q[i]>max)
max=Q[i];
}
return
max;
}
double*
F(double
X[])
{
double
x=X[0];
double
y=X[1];
double
*Z=NULL;
Z=(double*)malloc(2*sizeof(double));
Z[0]=x*x-2*x-y+0.5;
Z[1]=x*x+4*y*y-4;
return
Z;
}
double*
JF(double
X[])
{
double
x=X[0];
double
y=X[1];
double
*W=NULL;
W=(double*)malloc(4*sizeof(double));
W[0]=2*x-2;
W[1]=-1;
W[2]=2*x;
W[3]=8*y;
return
W;
}
main()
{
double
P[2]={0};
double
delta=0.0,epsilon=0.0,err=0.0;
int
max1=0,iter=0,i=0;
cout<<"牛頓法解非線性方程組:\nx^2-4-y+2=0\nx^2+4*y^2-2=0\n";
cout<<"\n輸入的初始近似值x0,y0\n";
for(i=0;i<2;i++)
cin>>P[i];
cout<<"請依次輸入P的誤差限，F(P)的誤差限，最大迭代次數\n";
cin>>delta;
cin>>epsilon;
cin>>err;
iter=newdim(P,delta,epsilon,max1,&err);
cout<<"收斂到P的解為:\n";
for(i=0;i<2;i++)
cout<<"X("<<i+1<<")="<<P[i]<<endl;
cout<<"\n迭代次數為:
"<<iter;
cout<<"\n."<<err<<endl;
getchar();
}