簡化牛頓法python

❶ 用簡化牛頓法求非線性方程組的一組解

function [r,n]=mulNewton(F,x0,eps)
if nargin==2
eps=1.0e-4;
end
x0 = transpose(x0);
Fx = subs(F,findsym(F),x0);
var = sym(symvar(findsym(F)));%var is string 要變換下
dF = jacobian(F,var);
dFx = subs(dF,findsym(dF),x0);
r=x0-inv(dFx)*Fx;
n=1;
tol=1;
while tol>eps
x0=r;
Fx = subs(F,findsym(F),x0);
dFx = subs(dF,findsym(dF),x0);
r=x0-inv(dFx)*Fx; %核心迭代公式
tol=norm(r-x0);
n=n+1;
if(n>1000) %迭代步數控制
disp('迭代步數太多，可能不收斂！');
return;
end
end

=======================
syms x y;
z=[0.5*sin(x)+0.1*cos(x*y)-x;0.5*cos(x)-0.1*cos(y)-y];
[r,n]=mulNewton(z,[0 0])

r =

0.1981
0.3980

n =

3

❷ 牛頓迭代法的python代碼

Python代碼以實例展示求解f(x) = (x-3）**3，f(x) = 0 的根。def f(x):
return (x-3）**3 』''定義f(x) = (x-3）**3'''
def fd(x):
return 3*((x-3）**2） 』''定義f'(x) = 3*((x-3）**2）
def newtonMethod(n,assum):
time = n
x = assum
Next = 0
A = f(x)
B = fd(x)
print('A = ' + str(A) + ',B = ' + str(B) + ',time = ' + str(time))
if f(x) == 0.0:
return time,x
else:
Next = x - A/B
print('Next x = '+ str(Next))
if A == f(Next): print('Meet f(x) = 0,x = ' + str(Next)) 』''設置迭代跳出條件，同時輸出滿足f(x) = 0的x值'''
else:
returnnewtonMethod(n+1,Next)
newtonMethod(0,4.0) 』''設置從0開始計數，x0 = 4.0'''

❸ Python怎麼做最優化

一、概觀
scipy中的optimize子包中提供了常用的最優化演算法函數實現。我們可以直接調用這些函數完成我們的優化問題。optimize中函數最典型的特點就是能夠從函數名稱上看出是使用了什麼演算法。下面optimize包中函數的概覽：
1.非線性最優化
fmin -- 簡單Nelder-Mead演算法
fmin_powell -- 改進型Powell法
fmin_bfgs -- 擬Newton法
fmin_cg -- 非線性共軛梯度法
fmin_ncg -- 線性搜索Newton共軛梯度法
leastsq -- 最小二乘
2.有約束的多元函數問題
fmin_l_bfgs_b ---使用L-BFGS-B演算法
fmin_tnc ---梯度信息
fmin_cobyla ---線性逼近
fmin_slsqp ---序列最小二乘法
nnls ---解|| Ax - b ||_2 for x>=0
3.全局優化
anneal ---模擬退火演算法
brute --強力法
4.標量函數
fminbound
brent
golden
bracket
5.擬合
curve_fit-- 使用非線性最小二乘法擬合
6.標量函數求根
brentq ---classic Brent (1973)
brenth ---A variation on the classic Brent（1980）ridder ---Ridder是提出這個演算法的人名
bisect ---二分法
newton ---牛頓法
fixed_point
7.多維函數求根
fsolve ---通用
broyden1 ---Broyden』s first Jacobian approximation.
broyden2 ---Broyden』s second Jacobian approximationnewton_krylov ---Krylov approximation for inverse Jacobiananderson ---extended Anderson mixing
excitingmixing ---tuned diagonal Jacobian approximationlinearmixing ---scalar Jacobian approximationdiagbroyden ---diagonal Broyden Jacobian approximation8.實用函數
line_search ---找到滿足強Wolfe的alpha值
check_grad ---通過和前向有限差分逼近比較檢查梯度函數的正確性二、實戰非線性最優化
fmin完整的調用形式是：
fmin(func, x0, args=(), xtol=0.0001, ftol=0.0001, maxiter=None, maxfun=None, full_output=0, disp=1, retall=0, callback=None)不過我們最常使用的就是前兩個參數。一個描述優化問題的函數以及初值。後面的那些參數我們也很容易理解。如果您能用到，請自己研究。下面研究一個最簡單的問題，來感受這個函數的使用方法：f(x)=x**2-4*x+8，我們知道，這個函數的最小值是4，在x=2的時候取到。
from scipy.optimize import fmin #引入優化包def myfunc(x):
return x**2-4*x+8 #定義函數
x0 = [1.3] #猜一個初值
xopt = fmin(myfunc, x0) #求解
print xopt #列印結果
運行之後，給出的結果是：
Optimization terminated successfully.
Current function value: 4.000000
Iterations: 16
Function evaluations: 32
[ 2.00001953]
程序准確的計算得出了最小值，不過最小值點並不是嚴格的2，這應該是由二進制機器編碼誤差造成的。
除了fmin_ncg必須提供梯度信息外，其他幾個函數的調用大同小異，完全類似。我們不妨做一個對比：
from scipy.optimize import fmin,fmin_powell,fmin_bfgs,fmin_cgdef myfunc(x):
return x**2-4*x+8
x0 = [1.3]
xopt1 = fmin(myfunc, x0)
print xopt1
print
xopt2 = fmin_powell(myfunc, x0)
print xopt2
print
xopt3 = fmin_bfgs(myfunc, x0)
print xopt3
print
xopt4 = fmin_cg(myfunc,x0)
print xopt4
給出的結果是：
Optimization terminated successfully.
Current function value: 4.000000
Iterations: 16
Function evaluations: 32
[ 2.00001953]
Optimization terminated successfully.
Current function value: 4.000000
Iterations: 2
Function evaluations: 53
1.99999999997
Optimization terminated successfully.
Current function value: 4.000000
Iterations: 2
Function evaluations: 12
Gradient evaluations: 4
[ 2.00000001]
Optimization terminated successfully.
Current function value: 4.000000
Iterations: 2
Function evaluations: 15
Gradient evaluations: 5
[ 2.]
我們可以根據給出的消息直觀的判斷演算法的執行情況。每一種演算法數學上的問題，請自己看書學習。個人感覺，如果不是純研究數學的工作，沒必要搞清楚那些推導以及定理雲雲。不過，必須了解每一種演算法的優劣以及能力所及。在使用的時候，不妨多種演算法都使用一下，看看效果分別如何，同時，還可以互相印證演算法失效的問題。
在from scipy.optimize import fmin之後，就可以使用help(fmin)來查看fmin的幫助信息了。幫助信息中沒有例子，但是給出了每一個參數的含義說明，這是調用函數時候的最有價值參考。
有源碼研究癖好的，或者當你需要改進這些已經實現的演算法的時候，可能需要查看optimize中的每種演算法的源代碼。在這里：https:/ / github. com/scipy/scipy/blob/master/scipy/optimize/optimize.py聰明的你肯定發現了，順著這個鏈接往上一級、再往上一級，你會找到scipy的幾乎所有源碼！

❹ 為什麼我在Python中做了一個牛頓迭代法求一個數的算數平方根的程序，但輸出只有幾位小數，求解。

迭代類
牛頓迭代二迭代等~~
給簡單迭代
求x=根號a（沒打數符號）
求平根公式x〈n+1〉（用〈〉括起標）=1/2（x〈n〉+a/x〈n〉）
精度要求10負5
c代碼
#include
main()
{
float a,x0,x1;
scanf("%f",&a);
x0=a/2;
x1=(x0+a/x0)/2;
do
{x0=x1;
x1=(x0+a/x0)/2;
}while(fabs(x0-x1)>=le-5);
printf("The squme foot of %5.2f is %8.5f\n",a,x1);
}
建議潭浩強c習題作做

❺ python牛頓法求多項式的根

#include<iostream.h>
#include<math.h>
#include<conio.h>
const int N=200;
//帶入原函數後所得的值
double f(float x)
{
return (x*x*x-1.8*x*x+0.15*x+0.65);
}
//帶入一階導函數後所得的值
double f1(double x)
{
return (3*x*x-3.6*x+0.15);
}
//牛頓迭代函數
double F(double x)
{
double x1;
x1=x-1.0*f(x)/f1(x);
return (x1);
}
void main()
{
double x0,D_value,x1,y[4];
int k=0,count=0;
for(;;)
{
if(count==3)break;
cout<<"輸入初始值:";
cin>>x0;
do
{
k++;
x1=F(x0);
D_value=fabs(x1-x0);
x0=x1;
}
while((D_value>0.000005)&&(k<=N));
for(int j=0,flag=0;j<count;j++)

{
if(fabs(y[j]-x1)<0.000005)
{ flag=1;
cout<<"該數值附近的根已經求出，請重新換近似值"<<endl;
break;
}
}
if(flag==1)
continue;
else
{
cout<<"方程的一個根："<<x1<<","<<" 迭代次數為："<<k<<endl;
y[count]=x1;
count++;
}
//else

//cout<<"計算失敗!"<<endl;
}
}
//你的程序其實沒問題，牛頓迭代法本身循環一次只能找到一個答案，只要再建一個循環控制使
//用迭代法的次數和判斷根的個數就行。我又加了一個判斷是否有重復的根的循環。
//希望能對你有所幫助。

❻ 如何用python化簡方程組

用牛頓迭代法 + 多項式除法化簡。

1）針對方程組 f(x)，首先用牛頓迭代法得到方程的第一個根（a），那麼 f（x） = (x-a)g(x)
2）用多項式除法，計算 g(x) = f(x)/(x-a)
重復第一步，得到 g(x) 的根，然後再重復第二步，進一步對方程降冪。
最終就可以化簡整個方程。

❼ 牛頓迭代法python程序求平方根和立方根

import math
def sqrt(x):
y = x
while abs(y * y - x) > 1e-6:
y = (y + x / y) / 2
return y

print(sqrt(5))
print(math.sqrt(5))

❽ 如何用Python 和牛頓法解四元一次方程組

比較弱的問一下，你確定不是
'''
theta22=spy.Symbol('theta22')
theta33=spy.Symbol('theta33')
theta44=spy.Symbol('theta44')
theta55=spy.Symbol('theta55')
'''
這段有問題？
多了引號？或者。。

❾ 用python解答數學的牛頓迭代法問題

導數f′(x0)=lim(f(x0+Δx)-f(x0))/Δx的變換應用，求滿足f(x0+Δx)=0的x0+Δx

❿ 想用python來求解牛頓插值問題，編了一段程序，其中有些錯誤看不出來，懇請大佬指出錯誤，代碼如下

importmatplotlib.pyplotasplt
frompylabimportmpl
importmath
"""
牛頓插值法
插值的函數表為
xi-28.9,-12.2,4.4,21.1,37.8
f(xi)2.2,3.9,6.6,10.3,15.4
"""
x=[-28.9,-12.2,4.4,21.1,37.8]
y=[2.2,3.9,6.6,10.3,15.4]

"""計算4次差商的值"""
defFour_time_difference_quotient(x,y):
i=0#i記錄計算差商的次數
quotient=[0,0,0,0,0,]
whilei<4:
j=4
whilej>i:
ifi==0:
quotient[j]=((y[j]-y[j-1])/(x[j]-x[j-1]))
else:
quotient[j]=(quotient[j]-quotient[j-1])/(x[j]-x[j-1-i])
j-=1
i+=1
returnquotient;

deffunction(data):
returnx[0]+parameters[1]*(data-0.4)+parameters[2]*(data-0.4)*(data-0.55)+
parameters[3]*(data-0.4)*(data-0.55)*(data-0.65)
+parameters[4]*(data-0.4)*(data-0.55)*(data-0.80)

"""計算插值多項式的值和相應的誤差"""
defcalculate_data(x,parameters):
returnData=[];
fordatainx:
returnData.append(function(data))
returnreturnData

"""畫函數的圖像
newData為曲線擬合後的曲線
"""

defdraw(newData):
plt.scatter(x,y,label="離散數據",color="red")
plt.plot(x,newData,label="牛頓插值擬合曲線",color="black")
plt.scatter(0.596,function(0.596),label="預測函數點",color="blue")
plt.title("牛頓插值法")
mpl.rcParams['font.sans-serif']=['SimHei']
mpl.rcParams['axes.unicode_minus']=False
plt.legend(loc="upperleft")
plt.show()

parameters=Four_time_difference_quotient(x,y)
yuanzu=calculate_data(x,parameters)
draw(yuanzu)