牛顿迭代法 线性收敛 平方收敛牛顿迭代法 线性收敛 平方收敛 有什么区别,各自用在什么情况下谢绝粘贴复制!一楼答非所问

Dim a,b
Private Sub Command1_Click()
temp = (Val(a) + Val(b)) / 2
If h(temp) = Abs(h(temp)) And h(a) < 0 Then b = temp
If h(temp) = Abs(h(temp)) And h(b) < 0 Then a = temp
If h(temp) Abs(h(temp)) And h(a) > 0 Then b = temp
If h(temp) Abs(h(temp)) And h(b) > 0 Then a = temp
Print a
Print b
End Sub
Function h(x)
h = Val(x) ^ 6 - 5 * Val(x) ^ 5 + 3 * Val(x) ^ 4 + Val(x) ^ 3 - 7 * Val(x) ^ 2 + 7 * Val(x) - 20
End Function
Private Sub Form_Load()
a = -2
b = 5
End Sub
点一次就再精确一次

牛顿迭代法就是用x-f(x)/f'(x)这个式子来迭代,不断逼近f(x)=0的根.
f'(x)=3x²-2x
令g(x)=x-f(x)/f'(x)=(2x³-x²+1)/(3x²-2x)
因为f(x)在[1.4 ,1.5]上单调,所以最多只有一个根.
所以我们可以任取区间中的一个值为初始值,例如取1.45为初始值,代进g(x)里面去：
g(1.45)≈1.46581
g(1.46581)≈1.46557
g(1.46557)≈1.46557 与上一次的差已经在指定的精确度之内了,
所以这就是答案,f(x)的根精确到小数点后第四位等于1.4656

迭代公式x(k+1)=x(k)－f'(x(k))/f''(x(k))
k=1,2.,直到你要的精度
x(1)=1
当|x(k+1)-x(k)|

先去看看计算方法学习一下“牛顿迭代法”吧,不然就算懂了这个小程序也意义不大,真的

首先要找到解的区间
f(x)=lnx-1/x
f(1) = 0-1=-10
所以在[1,e]之间
写程序的话不知道你用什么语言
x0=1
x1=e
while(x1-x0 >10^-8)
{
double value = f((x0+x1)/2)
if(value >0)
x1=(x0+x1)/2
else
x0 = (x0+x1)/2
}
最后精确度是在10^-8的解

总的来说局部收敛性指的是初值取在根的局部时算法(一般)具有二阶收敛速度,全局收敛性是指初值在定义域内任取时算法是否收敛,若收敛其速度如何,收敛到哪个根.
具体来说
局部收敛性有如下定理
设已知 f(x) = 0 有根 a,f(x) 充分光滑(各阶导数存在且连续).
若 f'(a) != 0(单重零点),则初值取在 a 的某个邻域内时,迭代法 x[n+1] = x[n] - f(x[n])/f'(x[n]) 得到的序列 x[n] 总收敛到 a,且收敛速度至少是二阶的.
若 f'(a) == 0(多重零点),则初值取在 a 的某个邻域内时,收敛速度是一阶的.
记 g(x)=x-f(x)/f'(x),其中"某个邻域"可由 |g'(x)|

#include
#include
#define F(x) 2*x*x*x-4*x*x+3*x-7//The function
#define K(x) 6*x*x-8*x+3//The pitch
void main()
{
double x,xx,f,k;
x=2.5;
f=F(x);//Get the value
k=K(x);//Get the pitch value
xx=x-f/k;
while((fabs(x-xx))>(1*10e-6))//Check the answer
{
x=xx;
f=F(x);//Get the value
k=K(x);//Get the pitch value
xx=x-f/k;
}
printf("x=%2.8f,xx=%2.8fn",x,xx);
}
//该程序经过调试成功的

第一题代码如下，很简单所以没有什么注释：#include
#include
float Fl(float x)
{
float y;
y=cos(x)-x;
return y;
}
float newtoon(float x)
{
float y;
y=x-Fl(x)/(-sin(x)-1);
return y;
}
void main()
{
float x0,x1;
printf("Please input x0:n");
scanf("%f",&x1);
do
{
float z;
x0=x1;
x1=newtoon(x0);
}while(fabs(x1-x0)>=1e-5);
printf("The root of equation is %fn",x1);
}纠正一下上面没看清题目，应该是1e-6第二题代码如下：#include
#include
double eff(double x)
{
double y;
y=log(x)+pow(x,2);
for(;y<=1e-4;){
if(y>0)
{
x=(x+1/exp(1))/2;
eff(x);
}
else
{
x=(x+1)/2;
eff(x);
}
}
return y;
}
void main()
{
double x,z;
printf("Please input x:n");
do
{
scanf("%lf",&x);
}while(x<=1/exp(1)||(x>=1));//输入的数字必须在区间内，因为题目中已经指出在这个区间有一个根！
z=eff(x);
printf("the root of the equation is:%lfn",z);
}
上面的程序我都运行了一下，差不多对了，第二题用double和float其实是一样的，只不过log函数得到的是double型数据，为了使得程序更加精确我擅自修改了下，楼主改回float也可以。

#include
#include
void main()
{
double x0,x,y1,y2;
printf("input xn");
scanf("%lf",&x);
do{
x0=x;
y1=x*(x*(x+2)+3)+4;
y2=x*(3*x+4)+3;
x=x0-y1/y2;}
while(fabs(x-x0)>=1e-5);
printf("%lf",x);
}

迭代次数.

#include
#include
void main()
{
float x,x0,f,f1;
x0=0.5;
do
{
f=x0*x0*x0-x0*x0-1;
f1=3*x0*x0-2*x0;
x=x0-f/f1;
x0=x;
}while((fabs(x-x0)

第一题
Private Sub Command1_Click()
'Print Log(x)-0.59*sqr(x)-0.5*log(ks)=0,ks=0.047
Dim x0 As Single, x1 As Single
Dim z As Single
Dim n As Integer
x0 = 0.1
Do
x1 = x0 - (Log(x0) - 0.59 * Sqr(x0) - 0.5 * Log(0.047)) / (1 / x0 - 0.295 / Sqr(x0))
z = Abs(x1 - x0)
Print x0, x1, z
x0 = x1
n = n + 1
If n > 5 Then Exit Do
Loop Until z < 0.00001
Print x0, x1, z, n
End Sub 从函数图象上看,只有一个根在0.3附近.最后求得0.2994014.
初始值设为,0.1,也可以设为,更小,但不能为零,在除数中.也可适当增大n,来满足精度.精度为0.00001.说明n是为了防止死循环,一般20即可.

x1= 0
Do
x0 = X1
f1 = x0 ^ 5 - 3 * x0 ^ 2 + 2 * x0 + 1
f2 = 5 * x0 ^ 4 - 6 * x0 + 2
X1 = x0 - f1 / f2
Loop While Abs(X1 - x0) > 0.000001
Print X1

牛顿迭代法（Newton's method）又称为牛顿-拉夫逊方法（Newton-Raphson method）,它是牛顿在17世纪提出的一种在实数域和复数域上近似求解方程的方法.多数方程不存在求根公式,因此求精确根非常困难,甚至不可能,从而寻...

#include
#include
#define eps 1e-8
void main()
{
double a=1,b=2;
double t,t0,f0,f00,m,n;
t0=(a+b)/2;
m=pow(t0,5);
n=pow(t0,4);
f0=6*m-1;
f00=30*n;
t=t0-f0/f00;
while(fabs(t-t0)>eps)
{
t0=t;
m=pow(t0,5);
n=pow(t0,4);
f0=6*m-1;
f00=30*n;
t=t0-f0/f00;
printf("t0=%12.10lf,t=%12.10lfn",t0,t);
}
printf("用Newton切线法得：%12.10lfn",t);
}
结果为：
t0=1.2065843621,t=0.9809945654
t0=0.9809945654,t=0.8207881793
t0=0.8207881793,t=0.7300742137
t0=0.7300742137,t=0.7013898132
t0=0.7013898132,t=0.6988457773
t0=0.6988457773,t=0.6988271198
t0=0.6988271198,t=0.6988271188
用Newton切线法得：0.6988271188
Press any key to continue

f(x)=2x^3-4x^2+3x-6
f'(x)=6x^2-8x+3
x(n+1)=xn-(2xn^3-4xn^2+3xn-6)/(6xn^2-8xn+3)
x1=1.5
x2=2.3333
x3=2.0610
x4=2.0026
x5=2.0000
x6=2.0000
所以x=2

f(x)=x^3+x^2-3x-3
f'(x)=3x^2+2x-3
x(n+1)=xn-f(xn)/f'(xn)
令x1=1.5
x2=1.777778
x3=1.733361
x4=1.732052
x5=1.732051
x6=1.732051
如果精确到0.000001,则x=1.732051
准确值=根号3

牛顿迭代法计算矩阵近似逆
一 问题
设A为主对角占优矩阵,用牛顿迭代法求矩阵A的近似逆.
二 实验目的：
熟悉MATLAB的编程环境,掌握MATLAB的程序设计方法,会运用数值分析课程中的牛顿迭代法求解矩阵的近似逆.

三 实验原理：
迭代公式为：Xn+1 = Xn(2I – AXn ),迭代计算的收敛要求为：||I –AX0|| < 1.本次实验中的对角占优矩阵A= ,根据迭代收敛的条件,取A的对角元组成的矩阵X0=diag([1/10,1/20,1/30,1/40,1/50]),可以保证迭代收敛.采用循环语句实现迭代过程.
四 MATLAB程序及注释：
A=[10,1,2,0,1;2,20,1,0,1;1,3,30,2,0;2,3,0,40,1;5,6,1,0,50];%输入 主对角占优的五阶矩阵
X0=diag([1/10,1/20,1/30,1/40,1/50]); %用对角元构造近似逆
E=eye(5); %生成5*5阶单位矩阵
format short e； %五位浮点数表示
for k=1:6
Xn=X0*(2*E-A*X0);
er=norm(E-A*X0,inf)
X0=Xn; %牛顿迭代计算
end
format %五位定点数表示
Xn %显示A的近似逆
Y=inv(A) %显示A的逆矩阵
五 实验数据结果及分析：
程序运行后,显示如下：
er =
0.8333
er =
0.1543
er =
0.0104
er =
3.9879e-005
er =
5.8016e-010
er =
2.2833e-016
Xn =
0.1023 -0.0036 -0.0066 0.0003 -0.0020
-0.0097 0.0509 -0.0010 0.0001 -0.0008
-0.0022 -0.0047 0.0336 -0.0017 0.0002
-0.0042 -0.0035 0.0004 0.0250 -0.0003
-0.0090 -0.0057 0.0001 -0.0000 0.0203
Y =
0.1023 -0.0036 -0.0066 0.0003 -0.0020
-0.0097 0.0509 -0.0010 0.0001 -0.0008
-0.0022 -0.0047 0.0336 -0.0017 0.0002
-0.0042 -0.0035 0.0004 0.0250 -0.0003
-0.0090 -0.0057 0.0001 -0.0000 0.0203
观察实验数据,A矩阵的近似逆在经过六次的迭代后求得的近似逆与MATLAB中的inv(A)所求得的逆矩阵在四位有效数字时完全一致.
六 实验结论：
实验数据的有效数位增长很快,经过六次迭代误差的数量级就达到10-16,收敛速度很快,第四次与第五次迭代符合二阶收敛速度.本实验中计算出的矩阵近似逆与与MATLAB中的inv(A)所求得的逆矩阵在四位有效数字时完全相同的原因估计是①A矩阵是严格主对角占优矩阵；②MATLAB中inv(A)就是运用的牛顿迭代法.
七 标记：
①迭代解法用于解大型稀疏（此矩阵中0元素较多）方程组或矩阵.②A矩阵主对角元均不为0,且主对角元的值大于该行其他所有元素的绝对值之和.
牛顿迭代法计算矩阵近似逆
一 问题
设A为主对角占优矩阵,用牛顿迭代法求矩阵A的近似逆.
二 实验目的：
熟悉MATLAB的编程环境,掌握MATLAB的程序设计方法,会运用数值分析课程中的牛顿迭代法求解矩阵的近似逆.

三 实验原理：
迭代公式为：Xn+1 = Xn(2I – AXn ),迭代计算的收敛要求为：||I –AX0|| < 1.本次实验中的对角占优矩阵A= ,根据迭代收敛的条件,取A的对角元组成的矩阵X0=diag([1/10,1/20,1/30,1/40,1/50]),可以保证迭代收敛.采用循环语句实现迭代过程.
四 MATLAB程序及注释：
A=[10,1,2,0,1;2,20,1,0,1;1,3,30,2,0;2,3,0,40,1;5,6,1,0,50];%输入 主对角占优的五阶矩阵
X0=diag([1/10,1/20,1/30,1/40,1/50]); %用对角元构造近似逆
E=eye(5); %生成5*5阶单位矩阵
format short e； %五位浮点数表示
for k=1:6
Xn=X0*(2*E-A*X0);
er=norm(E-A*X0,inf)
X0=Xn; %牛顿迭代计算
end
format %五位定点数表示
Xn %显示A的近似逆
Y=inv(A) %显示A的逆矩阵
五 实验数据结果及分析：
程序运行后,显示如下：
er =
0.8333
er =
0.1543
er =
0.0104
er =
3.9879e-005
er =
5.8016e-010
er =
2.2833e-016
Xn =
0.1023 -0.0036 -0.0066 0.0003 -0.0020
-0.0097 0.0509 -0.0010 0.0001 -0.0008
-0.0022 -0.0047 0.0336 -0.0017 0.0002
-0.0042 -0.0035 0.0004 0.0250 -0.0003
-0.0090 -0.0057 0.0001 -0.0000 0.0203
Y =
0.1023 -0.0036 -0.0066 0.0003 -0.0020
-0.0097 0.0509 -0.0010 0.0001 -0.0008
-0.0022 -0.0047 0.0336 -0.0017 0.0002
-0.0042 -0.0035 0.0004 0.0250 -0.0003
-0.0090 -0.0057 0.0001 -0.0000 0.0203
观察实验数据,A矩阵的近似逆在经过六次的迭代后求得的近似逆与MATLAB中的inv(A)所求得的逆矩阵在四位有效数字时完全一致.
六 实验结论：
实验数据的有效数位增长很快,经过六次迭代误差的数量级就达到10-16,收敛速度很快,第四次与第五次迭代符合二阶收敛速度.本实验中计算出的矩阵近似逆与与MATLAB中的inv(A)所求得的逆矩阵在四位有效数字时完全相同的原因估计是①A矩阵是严格主对角占优矩阵；②MATLAB中inv(A)就是运用的牛顿迭代法.
七 标记：
①迭代解法用于解大型稀疏（此矩阵中0元素较多）方程组或矩阵.②A矩阵主对角元均不为0,且主对角元的值大于该行其他所有元素的绝对值之和.

function [r,n]=mulNewton(x0,eps)
if nargin==1
eps=1.0e-4;
end
r=x0-myf(x0)*inv(dmyf(x0));
n=1;
tol=1;
while tol>eps
x0=r;
r=x0-myf(x0)*inv(dmyf(x0));
tol=norm(r-x0);
n=n+1;
if(n>100000)
disp('迭代步数太多,方程可能不收');
return;
end
end
function f=myf(x)
x1=x(1);
x2=x(2);
f1=(15*x1+10*x2)-((40-30*x1-10*x2)^2*(15-15*x1))*5e-4;
f2=(15*x1+10*x2)-((40-30*x1-10*x2)*(10-10*x2))*4e-2;
f=[f1 f2];
function df=dmyf(x)
x1=x(1);
x2=x(2);
df=[ (3*(27*x1^2 + 12*x1*x2 - 66*x1 + x2^2 - 14*x2 + 60))/4,...
(3*x1*x2 - 3*x2 - 21*x1 + 9*x1^2 + 32)/2;(-3)*(4*x2 - 9),(-2)*(6*x1 + 4*x2 - 15)]
----------------------------------------------------------------------------------------------------------
[r,n]=mulNewton([0.2 0.6],0.001)
df =
30.9600 13.3600
19.8000 22.8000
df =
33.1741 13.7408
22.0443 24.5260
df =
35.4490 14.2583
21.4349 24.9400
df =
35.2223 14.2212
21.1843 24.7600
df =
34.9859 14.1678
21.2334 24.7120
df =
34.9828 14.1660
21.2601 24.7231
r =
0.1203 0.4785
n =
6

实数A开5次方是方程f(x)=x^5-A=0的根,
迭代公式为：
x(k+1)= x(k)- f(x(k))/ f′(x(k))
x(k+1)= x(k)- (x^5(k)-A)/ (5x^4(k)),

二分法,迭代法是用切线来做的.

很简单,你自己写,给你提示如下:
头文件加:
#include
函数:
f(x) = x*x - 3.0 * x - exp(x) + 2.0;
一阶导数:
f2(x) = 2.0 * x - 3.0 -exp(x);
迭代公式:
x1 = x0 - f(x0) / f2(x0);
初值:
x0 = 0.0;
收敛条件:
if (fabs(x1-x0) < 0.5E-05) { 成功;}
else {
x0 = x1;
返回去再迭代.
}

用牛顿迭代法,求导x=0.29644
>> x0=0;tol=1e-6;x1=newton(x0,tol)
n =
6
x1 =
0.29644
>>syms x,ezplot(sin(4*x^2-4*x+1)-(3/4)*x-1/(10*x+3)+9/40),grid on
>>hold on,plot(double(x1),0,'p'),text(0.5,1,'Zeros Point')
代码见附件
图形见下图

老大 我知道 但不太好写 内容很多 推荐你本书 ：
数值计算方法 科学出版社（不一定是这个出版社的 别的也差不多）
见29页 牛顿法Xn+1=Xn-F(Xn)/F'(Xn)

f(x)=x^2-3
f'(x)=2x
Newton Iteration:x

牛顿迭代法：
x(n+1)=x(n)-[9(x(n))^2-sinx(n)-1]/[18x(n)-cosx(n)].
取x(0)=0.5,
x(1)=0.405129911,
x(2)=0.392101462,
x(3)=0.391847004,
x(4)=0.391846907,
3次迭代已经得到四位近似值x=0.3918.
二分法:f(x)=9x^2-sinx-1.
f(0)=-1,f(1)=7.15853,f(0.5)=0.770577.
f(0.25)=-0.68490,
f[(0.25+0.5)/2]=f(0.375)=-0.10065,
f[(0.375+0.5)/2]=f(0.4375)=0.29898,
f[(0.375+0.4375)/2]=f(0.40625)=0.09018,
.
要13次左右才能得到四位近似值.

建立m文件：
function [result ,k] = newton(fun,x0,e)
% 调用形式：
% [x k] = newton(fun,x0,e)
% 功能：
% 用差商求导的牛顿法求解一元非线性方程的根
% 输入：
% -- fun 字符串,f(x)的表达式,以x作为自变量,以字符串形式输入
% -- x0 标量,求解的起始点
% -- e 标量,精度要求
% 输出：
% -- x 标量,所求得的解
% -- k 标量,
% 袁怡圃,2003/4/3
m = x0;
h=0.000001;
f=inline(fun,'x');
k=0;
f0=feval(f,m);
f2=feval(f,m+h);
f1=feval(f,m-h);
n=m-2*h*f0/(f2-f1);
while abs(1-m/n)>e
m=n;
f0=feval(f,m);
f2=feval(f,m+h);
f1=feval(f,m-h);
n=m-2*h*f0/(f2-f1);
k=k+1;
if k>999
break
end
end
if k==1000
disp('没找到方程的根!');
result = 'zero';
else
result = n;
end
在命令窗口输入：
fun = '2*x^3+x^2-3*x+4=0';
x0 = 1;
[result ,k] = newton(fun,x0,0.00001)

牛顿迭代法是以微分为基础的,微分就是用直线来代替曲线,由于曲线不规则,那么我们来研究直线代替曲线后,剩下的差值是不是高阶无穷小,如果是高阶无穷小,那么这个差值就可以扔到不管了,只用直线就可以了,这就是微分的意义.
牛顿法是牛顿在17世纪提出的一种求解方程f(x)=0.多数方程不存在求根公式,从而求精确根非常困难,甚至不可能,从而寻找方程的近似根就显得特别重要.
牛顿迭代法是取x0之后,在这个基础上,找到比x0更接近的方程的跟,一步一步迭代,从而找到更接近方程根的近似跟.方法使用函数f(x)的泰勒级数的前面几项来寻找方程f(x) = 0的根.牛顿迭代法是求方程根的重要方法之一,其最大优点是在方程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次近似值.上式称为牛顿迭代公式.

m=0;%起始点
e=0.00001;%精度
h=0.000001;%步长
f=inline('1-y-2*sin(y+3)','y'); %x=1,c=2,k=3代入具体数值
t=0;
f0=feval(f,m);
f2=feval(f,m+h);
f1=feval(f,m-h);
n=m-2*h*f0/(f2-f1);
while abs(1-m/n)>e
m=n;
f0=feval(f,m);
f2=feval(f,m+h);
f1=feval(f,m-h);
n=m-2*h*f0/(f2-f1);
t=t+1;
if t>999
break
end
end
if t==1000
disp('没找到方程的根!')
else
disp(m);%方程的解
end

程序流程分析：
① 赋值x0＝1.5,即迭代初值；
② 用初值x0代入方程中计算此时的f(x0)及f’(x0),程序中用变量f描述方程的值,用fd描述方程求导之后的值；
③ 计算增量d=f/fd；
④ 计算下一个x,x=x0-d;
⑤ 把新产生的x替换x0,为下一次迭代做好准备;
⑥ 若d绝对值大于1e-3,则重复②③④⑤步.
源程序代码：
#include
main()
{
float x,x0,d,f,fd;
x0=0;
do {
f=2*x0*x0*x0-4*x0*x0+3*x0-6;
fd=6*x0*x0-8*x0+3;
d=f/fd;
x=x0-d;
x0=x;
}while(fabs(d)>1e-3);
printf("x=%fn",x);
}

但是牛顿法可能解不出来
function [r,n]=mulNewton(x0,eps)
if nargin==1
eps=1.0e-4;
end
r=x0-myf(x0)*inv(dmyf(x0));
n=1;
tol=1;
while tol>eps
x0=r;
r=x0-myf(x0)*inv(dmyf(x0));
tol=norm(r-x0);
n=n+1;
if(n>100000)
disp('迭代步数太多,方程可能不收');
return;
end
end
function f=myf(x)
x1=x(1);
x2=x(2);
f1=(15*x1+10*x2)/((40-30*x1-10*x2)^2*(15-15*x1))-5e-4;
f2=(15*x1+10*x2)/((40-30*x1-10*x2)*(10-10*x2))-4e-2;
f=[f1 f2];
function df=dmyf(x)
x1=x(1);
x2=x(2);
df=[ (60*(15*x1 + 10*x2))/((15*x1 - 15)*(30*x1 + 10*x2 - 40)^3) - 15/((15*x1 - 15)*(30*x1 + 10*x2 - 40)^2) + (15*(15*x1 + 10*x2))/((15*x1 - 15)^2*(30*x1 + 10*x2 - 40)^2),(20*(15*x1 + 10*x2))/((15*x1 - 15)*(30*x1 + 10*x2 - 40)^3) - 10/((15*x1 - 15)*(30*x1 + 10*x2 - 40)^2);...
15/((10*x2 - 10)*(30*x1 + 10*x2 - 40)) - (30*(15*x1 + 10*x2))/((10*x2 - 10)*(30*x1 + 10*x2 - 40)^2), 10/((10*x2 - 10)*(30*x1 + 10*x2 - 40)) - (10*(15*x1 + 10*x2))/((10*x2 - 10)*(30*x1 + 10*x2 - 40)^2) - (10*(15*x1 + 10*x2))/((10*x2 - 10)^2*(30*x1 + 10*x2 - 40))];
-----------------------------------------------
[r,n]=mulNewton([0.5 0.1],0.0001)
Warning: Matrix is close to singular or badly scaled.
Results may be inaccurate. RCOND = 1.148287e-034.
> In mulNewton at 10
Warning: Matrix is close to singular or badly scaled.
Results may be inaccurate. RCOND = 1.195848e-089.
> In mulNewton at 10
Warning: Matrix is close to singular or badly scaled.
Results may be inaccurate. RCOND = 5.295160e-267.
> In mulNewton at 10
Warning: Matrix is singular to working precision.
> In mulNewton at 10
Warning: Matrix is singular, close to singular or badly scaled.
Results may be inaccurate. RCOND = NaN.
> In mulNewton at 10
r =
NaN NaN
n =
9

(1).
由题意得
a,b为方程
x^2+x-1=0的两根
根据求根公式得
a=(-1+根号5)/2
b=(-1-根号5)/2
(2)
因为
a(n+1)=a(n)-[f(an)/f'(an)]=(a(n)^2+1)/(2a(n)+1)
且
b^2=1-b
a^2=1-a
所以
[a(n+1)-b]/[a(n+1)-a]
=(an^2-2ban+b^2)/(an^2-2aan+a^2)
=(an-b)^2/(an-a)^2
=[(an-b)/(an-a)]^2
所以
b(n+1)=ln[(an-b)/(an-a)]^2=2ln[(an-b)/(an-a)]=2bn
所以{bn)为等比数列
所以
Sn=b1（2^n-1)=[(7+3根5)/2]*(2^n-1)

第一个问题：
f[x_] := 2 x^2;
xlist = NestList[# - f[#]/f'[#] &,0.5,4]; ylist = f[xlist]; list1 = Transpose[{xlist,ylist}]; list2 =
Transpose[{Drop[xlist,1],Table[0,{Length[xlist] - 1}]}];
list = Riffle[list1,list2];
iterplot = ListLinePlot[list]; funplot = Plot[f[x],{x,0,1},PlotRange -> {0,1},PlotStyle -> {Black}]; Show[{funplot,iterplot}]
第二个问题：
singleTest := Module[{data,dataSorted,exist,howmanysame = 2},
data = RandomInteger[{1,365},90]; dataSorted = Sort[data];
If[Or @@ (Map[dataSorted[[#]] == dataSorted[[# + howmanysame]] &,
Range[Length[data] - howmanysame]]),exist = 1,exist = 0];
exist];
result = Table[singleTest,{200}];
In[203]:= Total[result]/200 // N
Out[203]= 0.505
第三个问题：
x[t_] := t; y[t_] := Sin[t]; r = 0.5;
Manipulate[
Show[
{ParametricPlot[{x[t],y[t]},{t,0,2 [Pi]},
PlotRange -> {{0,2 [Pi]},{-2,2}}],
Graphics[{
Circle[{x[a],y[a]} + r*{- y'[a],x'[a]}/Norm[{x'[a],y'[a]}],r],
Point[{x[a],y[a]} + r*{- y'[a],x'[a]}/Norm[{x'[a],y'[a]}]]}]}
],
{a,0,2 [Pi]}]
第二个和第三个粘贴反了.一些意见,1里面方程似乎没有根；3里面到底是三个还是三个以上说的不清楚.这个让人很不爽.
2里面我只做了圆心,算是hint吧,其他可以自己搞定的
那么1,3解决了
关于2你说的无摩擦滚动=滑动+绕圆心一定速率的转动.依我看只有用弧长参数代码才容易写.不过就是x,y各增加一项,琢磨琢磨吧:)

你好
很高兴为你解答
答案是：证明它在0,1区间单调,再验证0,1处的值,正负相反即可.
满意请采纳,谢谢

#include
#include
//原函数
double Func(double x)
{
return x*x*x*x*x+35*x*x*x*x-25*x*x*x+10*x*x+x+9;
}
//导函数
double DerivedFunc(double x)
{
return 5*x*x*x*x+140*x*x*x-75*x*x+20*x+1;
}
//与0的比较
BOOL IsZero(double x)
{
return (x = -0.000001);
}
BOOL newton(double *x,double precision,int maxcyc)
{
double x1,x0;
int k;
x0=*x;
for(k=0;k

1)迭代法设计思想最简单：x=f(x) 但这种方法初值很主要,不然容易发散.
2)二分法设计思想是先给定区间[a,b],要求f(a)与f(b)是异号,保证区间内与x轴有交点,求x=(a+b)/2,求f(x),检查f(x)与f(a)是否同号,如果是同号,把x当成新的a,否则把x当成新的b,得到新的区间,重复求a和b的中点的值,判断与f(a)是否同号,不断循环下去,直到达到精度为止.
3)牛顿迭代法设计思想是对f(x0)某点求切线,与x轴交x1点后,把x1当成x0,再求出其相应新的f(x0),再对其求切线,找到与x轴的新交点,不断循环下去,直到达到精度为止.这种方法要求先对函数求一阶导数,然后再迭代：x1=x0-f(x0)/f‘(x0)
4)弦截法设计思想利用插值原理,避免上面的求导,要求在f(x)上取二点x0,x1,做过f(x0),f(x1)的直线交x轴一点为x,把原来的x1当成x0,把x当成x1,再重复上面的做直线的过程,不断循环下去,直到达到精度为止.迭代公式：x=x1-(x1-x0)*f(x1)/(f(x1)-f(x0))

自己添一个计数器就可以了.
double x0,x1;
double EPS=1e-14;
int js=0;
x0=2.0
while(1){
x1 = 你的迭代函数;
js = js +1;
if (fabs(x-x0) < EPS) break;
x0=x1;
};
printf("iteration times:%dn",js); // 打出次数
==
10的负16次方 -- double型 也许精度还不够!负14次方还勉强.

你没有重新计算你定义的 a
循环最后加一条语句
while(a>10e-6)
{
.
.
a=fabs(x0-x1);
}

x n+1=(xn+a/x)/2

|xn-x0|单调减.在根x0附近,有f(x)=f'(x0)(x-x0)+O((x-x0)^2),f(xn)/f'(xn)=O(xn-x0)

牛顿迭代法
牛顿迭代法又称牛顿切线法,它采用以下方法求根：先任意设定一个与真实的根接近的值x0作为第一个近似根,由x0求出f(x0),过(x0,f(x0))点做f(x)的切线,交x轴于x1,把它作为第二次近似根,再由x1求出f(x1),再过(x1,f(x1))点做f(x)的切线,交x轴于x2,再求出f(x2),再作切线……如此继续下去,直到足够接近真正的x为止.
其中f'(X0)是函数在X0处的斜率,也就是在X0处的导数.
代码如下：
#include
#include
float f(float a,float b,float c,float d,float x)
{
float f;
f=((a*x+b)*x+c)*x+d;
return f;
}
float f1(float a,float b,float c,float x)
{
float f;
f=(x*3*a+2*b)*x+c;
return f;
}
float root(float a,float b,float c,float d)
{
float x0,x1=1;
do
{
x0=x1;
x1=x0-f(a,b,c,d,x0)/f1(a,b,c,x0);
}while(fabs(x1-x0)>=1e-6);
return x0;
}
void main()
{
float a,b,c,d,x;
printf("input four float numbers:n");
scanf("%f%f%f%f",&a,&b,&c,&d);
x=root(a,b,c,d);
printf("%.1fX^3+%.1fX^2+%.1fX+%.1f=0 its root near x=1.5 is :%.4fn",a,b,c,d,x);
getch();
}

提洛尔的雪,维也纳的清啤酒
那里他将发现我们所丧失、所遗忘的一切宝藏：
胡子*预告
你再度开始——或者,你在说什么?
有一回,我确信里面没什么动静,
已驻足在他的记忆中哈哈

用^即可表示上标,10^(-5)可以表示10的-5次方.
#include
#include
double f( double x )
{
return x * x * x + 9.2 * x * x + 16.7 * x + 4;
}
double fdx( double x )
{
return 3 * x * x + 18.4 * x + 16.7;
}
int main( )
{
int t1 = 0, t2 = 1;
double x[ 2 ], ep = 1e-5;
x[ 0 ] = 0;
do
{
t1 = 1 - t1;
t2 = 1 - t2;
x[ t1 ] = x[ t2 ] - f( x[ t2 ] ) / fdx( x[ t2 ] );
} while( fabs( x[ t1 ] - x[ t2 ] ) > ep );
printf("%lfn", x[ t1 ]);
return 0;
}

#include
#include
double value(double a,double b,double c,double d,double x)
{
return (a*x*x*x+b*x*x+c*x+d);
}
double daovalue(double a,double b,double c,double d,double x)
{
return (3*a*x*x+2*b*x+c);
}
int main()
{
double x1=0,x2,a,b,c,d;
printf("Please insert the value of a,b,c,d:");//a,b,c,d赋值

scanf("%lf%lf%lf%lf",&a,&b,&c,&d);
printf("Please insert the intial value of x:"); //输入X的初值(你输入的是1).
scanf("%lf",&x2);
x1=x2-value(a,b,c,d,x2)/daovalue(a,b,c,d,x2);
while(fabs(x1-x2)>=10e-6)
{
x2=x1;
x1=x2-value(a,b,c,d,x2)/daovalue(a,b,c,d,x2);
}
printf("%lfn",x1);
return 0;
}
你看看这个程序合你的意不?

用牛顿迭代法求方程'a * x ^ 3 + b * x ^ 2 + c * x + d = 0,系数a = 1,b = 2,c = 3,d = 4,x在0附近的一个实数根为1.33333333333.算法代码如下：
Private Sub Command1_Click() '牛顿迭代法
Dim a As Double,b As Double,c As Double,d As Double,xx1 As Double
Dim n As Long
a = 1
b = 2
c = 3
d = 4
xx1 = 0 '初始值为0,x在0附近
Print Nim(a,b,c,d,xx1,n) '方程在XX1附近的根
Print n '迭代次数
End Sub
'牛顿迭代法Newton iteration method
Function Nim(ByVal a As Double,ByVal b As Double,ByVal c As Double,ByVal d As Double,ByVal x0 As Double,ByRef n As Long) As Double
Dim x As Double,y As Double,dy As Double,ydy As Double,i As Long
n = -1 '迭代次数
x = x0
For i = 0 To 1000
y = a * x ^ 3 + b * x ^ 2 + c * x + d
dy = 3 * a * x ^ 2 + 2 * b * x + c
If Abs(x - x0) 1000 Then n = -2 '该方程无解解
End Function

对于求平方根,变成方程模式为f(x)=x^2-a,即求此方程的实根；
下面编写了两个function函数,可以直接调用.
二分法：
function x=sqrt_bisect(a)
f=@(x)x^2-a;
if a0
xb=x;
elseif f(xa)*f(x)>0
xa=x;
else
break
end
end
end
x;
牛顿迭代法：
function x=sqrt_newton(a)
f=@(x)x^2-a;
df=diff(sym('x^2-a'));
if a1e-6
x0=x1;
x1=x0-f(x0)/subs(df,x0);
end
end
x=x1;
调用格式为：
sqrt_bisect(3)
ans =
1.7321
或者
sqrt_newton(2)
ans =
1.4142

二分法简单,你就先把（-10,10）分成（-10,0)(0,10),然后分别用x=-10 x=0 x=10代入,看哪2个接近0,肯定是(0,10),那么再分为（0,5）（5,10）,重复上面操作牛顿迭代法解非线性方程f(x)=0的牛顿法是把非线性方程线性化的...

#include #include float f(float x){ float a=pow(x,5)+2*pow(x,3)-pow(x,2)+x-1; return(a);}float f1(float x){ float&nbs...

该收敛域有多大是不能一概而论的,要根据具体的迭代公式进行分析.确定方法可以参看《数值分析》,里面讲得很详细