मैंने अजगर 3 (सुन्न का उपयोग करके) में एक पिछड़े-यूलर सॉल्वर को लागू किया है। अपनी सुविधा के लिए और एक अभ्यास के रूप में, मैंने एक छोटा सा कार्य भी लिखा, जो कि ढाल के परिमित अंतर की गणना करता है ताकि मुझे हमेशा जेकबिएन को विश्लेषणात्मक रूप से निर्धारित न करना पड़े (यदि यह संभव भी हो तो!)।
Ascher और पेटज़ोल्ड 1998 में दिए गए विवरणों का उपयोग करते हुए , मैंने यह फ़ंक्शन लिखा है जो किसी दिए गए बिंदु x पर ग्रेडिएंट निर्धारित करता है:
def jacobian(f,x,d=4):
'''computes the gradient (Jacobian) at a point for a multivariate function.
f: function for which the gradient is to be computed
x: position vector of the point for which the gradient is to be computed
d: parameter to determine perturbation value eps, where eps = 10^(-d).
See Ascher und Petzold 1998 p.54'''
x = x.astype(np.float64,copy=False)
n = np.size(x)
t = 1 # Placeholder for the time step
jac = np.zeros([n,n])
eps = 10**(-d)
for j in np.arange(0,n):
yhat = x.copy()
ytilde = x.copy()
yhat[j] = yhat[j]+eps
ytilde[j] = ytilde[j]-eps
jac[:,j] = 1/(2*eps)*(f(t,yhat)-f(t,ytilde))
return jac
मैंने पेंडुलम के लिए एक बहुभिन्नरूपी फ़ंक्शन लेकर और प्रतीकात्मक जैकबियन की तुलना में अंकों की एक सीमा के लिए संख्यात्मक रूप से निर्धारित ढाल की तुलना करके इस फ़ंक्शन का परीक्षण किया। मैं परीक्षण के परिणामों से प्रसन्न था, त्रुटि 1e-10 के आसपास थी। जब मैंने अनुमानित जैकबियन का उपयोग करके पेंडुलम के लिए ओडीई को हल किया, तो यह भी बहुत अच्छी तरह से काम करता था; मैं दोनों के बीच किसी भी अंतर का पता नहीं लगा सका।
फिर मैंने निम्नलिखित पीडीई (1 डी में फिशर के समीकरण) के साथ इसका परीक्षण करने की कोशिश की:
एक परिमित अंतर विवेक का उपयोग करना।
अब न्यूटन की विधि पहले टाइमस्टेप में चल रही है:
/home/sfbosch/Fisher-Equation.py:40: RuntimeWarning: overflow encountered in multiply
du = (k/(h**2))*np.dot(K,u) + lmbda*(u*(C-u))
./newton.py:31: RuntimeWarning: invalid value encountered in subtract
jac[:,j] = 1/(2*eps)*(f(t,yhut)-f(t,yschlange))
Traceback (most recent call last):
File "/home/sfbosch/Fisher-Equation.py", line 104, in <module>
fisher1d(ts,dt,h,L,k,C,lmbda)
File "/home/sfbosch/Fisher-Equation.py", line 64, in fisher1d
t,xl = euler.implizit(fisherode,ts,u0,dt)
File "./euler.py", line 47, in implizit
yi = nt.newton(g,y,maxiter,tol,Jg)
File "./newton.py", line 54, in newton
dx = la.solve(A,b)
File "/usr/lib64/python3.3/site-packages/scipy/linalg/basic.py", line 73, in solve
a1, b1 = map(np.asarray_chkfinite,(a,b))
File "/usr/lib64/python3.3/site-packages/numpy/lib/function_base.py", line 613, in asarray_chkfinite
"array must not contain infs or NaNs")
ValueError: array must not contain infs or NaNs
यह ईपीएस मूल्यों की एक किस्म के लिए होता है, लेकिन अजीब बात है, केवल जब पीडीई स्थानिक चरण आकार और समय कदम आकार निर्धारित किया जाता है ताकि कर्टेंट-फ्रेडरिक-लेवी स्थिति पूरी न हो। अन्यथा यह काम करता है। (यह वह व्यवहार है जो आप आगे के यूलर से हल करने की अपेक्षा करेंगे!)
पूर्णता के लिए, यहां न्यूटन विधि का कार्य है:
def newton(f,x0,maxiter=160,tol=1e-4,jac=jacobian):
'''Newton's Method.
f: function to be evaluated
x0: initial value for the iteration
maxiter: maximum number of iterations (default 160)
tol: error tolerance (default 1e-4)
jac: the gradient function (Jacobian) where jac(fun,x)'''
x = x0
err = tol + 1
k = 0
t = 1 # Placeholder for the time step
while err > tol and k < maxiter:
A = jac(f,x)
b = -f(t,x)
dx = la.solve(A,b)
x = x + dx
k = k + 1
err = np.linalg.norm(dx)
if k >= maxiter:
print("Maxiter reached. Result may be inaccurate.")
print("k = %d" % k)
return x
(फ़ंक्शन la.solve scipy.linalg.solve है।)
मुझे विश्वास है कि मेरा पिछड़ा यूलर कार्यान्वयन क्रम में है, क्योंकि मैंने जैकबियन के लिए एक फ़ंक्शन का उपयोग करके इसका परीक्षण किया है और स्थिर परिणाम प्राप्त किया है।
मैं डिबगर में देख सकता हूं कि त्रुटि होने से पहले न्यूटन () 35 पुनरावृत्तियों का प्रबंधन करता है। यह संख्या मेरे द्वारा आजमाए गए प्रत्येक ईपीएस के लिए समान है।
एक अतिरिक्त अवलोकन: जब मैं एफडीए के साथ ढाल की गणना करता हूं और एक इनपुट के रूप में प्रारंभिक स्थिति का उपयोग करते हुए एक फ़ंक्शन और एप्सिलॉन के आकार को अलग करते हुए दोनों की तुलना करता है, तो त्रुटि एप्सिलॉन सिकुड़ती है। मुझे उम्मीद है कि यह पहले बड़ा होगा, फिर छोटा होगा, फिर एप्सिलॉन सिकुड़ जाएगा। इसलिए, याकूब के मेरे कार्यान्वयन में एक त्रुटि एक उचित धारणा है, लेकिन यदि हां, तो यह इतना सूक्ष्म है कि मैं इसे देखने में असमर्थ हूं। संपादित करें: मैंने केंद्रीय मतभेदों के बजाय जकोबियन () को आगे बढ़ाने के लिए संशोधित किया, और अब मैं त्रुटि के अपेक्षित विकास का निरीक्षण करता हूं। हालाँकि, न्यूटन () अभी भी अभिसरण करने में विफल रहता है। न्यूटन पुनरावृत्ति में dx का अवलोकन करते हुए, मैं देखता हूं कि यह केवल बढ़ता है, इसमें उतार-चढ़ाव भी नहीं होता है: यह प्रत्येक चरण के साथ लगभग दोगुना (कारक 1.9) है, जिसमें कारक उत्तरोत्तर बड़ा होता है।
एस्केर और पेटज़ोल्ड उल्लेख करते हैं कि जैकबियन के लिए अंतर सन्निकटन हमेशा अच्छी तरह से काम नहीं करते हैं। क्या परिमित अंतर के साथ एक अनुमानित जैकबियन न्यूटन की विधि में अस्थिरता पैदा कर सकता है? या कारण कहीं और है? मैं इस समस्या से कैसे निपट सकता हूं?