python SciPy में integrate.odint का उपयोग करते समय Dfunc(gradient) क्यों नहीं कहा जाता है?



odeint (1)

हुड के तहत, scipy.integrate.odeint ODEPACK फोरट्रान पुस्तकालय से एलएसओडीए सॉल्वर का उपयोग करता है। उन परिस्थितियों से निपटने के लिए जहां आप जो समारोह को एकीकृत करने का प्रयास कर रहे हैं, वह कठोर है , एलएसओडीए अभिन्न अभिकलन के लिए दो अलग-अलग तरीकों के बीच अनुकूल रूप से स्विच करता है - एडम्स की विधि , जो तेज है, लेकिन कठोर सिस्टम के लिए अनुपयुक्त है, और बीडीएफ , जो धीमी लेकिन मजबूत है कठोरता के लिए

आप जिस विशेष कार्य को एकीकृत करने की कोशिश कर रहे हैं वह गैर-कठोर है, इसलिए एलएसओडीए प्रत्येक चलन पर एडम्स का उपयोग करेगा। आप infodict ( ...,full_output=True ) लौट कर जांच कर सकते हैं और infodict['mused'] जांच कर infodict['mused']

चूंकि एडम्स की विधि जैकोबियन का उपयोग नहीं करती है, इसलिए आपका ग्रेडिएंट फ़ंक्शन कभी नहीं बुलाया जाता। हालांकि यदि आप odeint को एकीकृत करने के लिए एक कड़ी समारोह देते हैं, जैसे कि वान डेर पोल समीकरण :

def vanderpol(y, t, mu=1000.):
    return [y[1], mu*(1. - y[0]**2)*y[1] - y[0]]

def vanderpol_jac(y, t, mu=1000.):
    return [[0, 1], [-2*y[0]*y[1]*mu - 1, mu*(1 - y[0]**2)]]

y0 = [2, 0]
t = arange(0, 5000, 1)
y,info = odeint(vanderpol, y0, t, Dfun=vanderpol_jac, full_output=True)

print info['mused'] # method used (1=adams, 2=bdf)
print info['nje']   # cumulative number of jacobian evaluations
plot(t, y[:,0])

आपको यह देखना चाहिए कि odeint का उपयोग करने के लिए स्विच करता है, और अब odeint फ़ंक्शन को फोन किया जाता है

यदि आप सॉल्वर पर अधिक नियंत्रण चाहते हैं, तो आपको scipy.integrate.ode पर scipy.integrate.ode करना चाहिए, जो कि कई विभिन्न scipy.integrate.ode अधिक लचीली वस्तु-उन्मुख इंटरफ़ेस है।

क्या किसी वैज्ञानिक को integrate.odeint करने के लिए एक जैकोबियन प्रदान करने का एक उदाहरण प्रदान कर सकता है। मैं इस कोड को SciPy ट्यूटोरियल odeint उदाहरण से चलाने की कोशिश करता हूं, लेकिन ऐसा लगता है कि Dfunc (gradient) कभी भी नहीं कहा जाता है।

from numpy import * # added
from scipy.integrate import odeint
from scipy.special import gamma, airy
y1_0 = 1.0/3**(2.0/3.0)/gamma(2.0/3.0)
y0_0 = -1.0/3**(1.0/3.0)/gamma(1.0/3.0)
y0 = [y0_0, y1_0]


def func(y, t):
    return [t*y[1],y[0]]


def gradient(y,t):
    print 'jacobian'  # added
    return [[0,t],[1,0]]


x = arange(0,4.0, 0.01)
t = x
ychk = airy(x)[0]
y = odeint(func, y0, t)
y2 = odeint(func, y0, t, Dfun=gradient)
print y2 # added




odeint