牛顿法编程
❶ 数值分析课程设计，编制一般迭代法、牛顿法、弦截法求解方程组的计算机程序，并分析它们的特点
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();
}