मुझे कॉल से ओडिंट तक आंतरिक गणना पास करने की आवश्यकता है। एकीकरण के साथ समाप्त होने के बाद मैं आम तौर पर मूल्यों को फिर से पुनर्गणना करता हूं, लेकिन मैं odeint के लिए बुलाए गए फ़ंक्शन में सभी गणना करना पसंद करूंगा।

मेरी समस्याएं कम्प्यूटेशनल रूप से भारी नहीं हैं, इसलिए ओड सॉल्वर के अंदर गणना करने में थोड़ा अतिरिक्त प्रदर्शन हिट करना स्वीकार्य है।

from scipy.integrate import odeint
import numpy as np

def eom(y, t):
    internal_calc = y/(t+1)
    xdot = y

    return xdot, internal_calc

if __name__ == '__main__':

    t = np.linspace(0, 5, 100)
    y0 = 1.0  # the initial condition

    output, internal_calc = odeint(eom, y0, t)

यह कोड नहीं चलता है, लेकिन उम्मीद है कि दिखाता है कि मैं क्या कर रहा हूं। मैं इंटीग्रेटर के माध्यम से प्रत्येक पास के लिए ईओएम फ़ंक्शन से 'internal_calc' मान प्राप्त करना चाहता हूं।

मैंने विकल्पों के लिए चारों ओर देखा है, लेकिन मुझे पता है कि सबसे अच्छे पायथन प्रोग्रामर में से एक ने मुझे अपना खुद का इंटीग्रेटर लिखने के लिए कहा है ताकि मैं जो चाहता हूं वह कर सकूं।

इससे पहले कि मैं ऐसा करता, मैंने सोचा कि मैं पूछूंगा कि क्या किसी और के पास ओडिंट सॉल्वर से मूल्य प्राप्त करने का कोई तरीका है।

1
Chris 10 पद 2018, 06:05

1 उत्तर

सबसे बढ़िया उत्तर

यह संभव है, आप अपने eom फ़ंक्शन के रिटर्न वैल्यू का उपयोग नहीं कर सकते। इसलिए आपको eom से डेटा की तस्करी के किसी अन्य तरीके की आवश्यकता है। ऐसा करने के कई, कई अलग-अलग तरीके हैं। शायद वैश्विक चर का उपयोग करना सबसे आसान है:

import scipy.integrate as spi

count = 0

def pend(t, y):
    global count

    theta, omega = y
    dydt = [omega, -.25*omega - 5*np.sin(theta)]

    count += 1
    return dydt

sol = spi.solve_ivp(pend, [0, 10], [np.pi - 0.1, 0.0])
print(count)

आउटपुट:

182

साथ ही, ध्यान दें कि मैंने उपरोक्त कोड में odeint के बजाय solve_ivp का उपयोग किया है। odeint डॉक्स कहते हैं कि नया कोड लिखते समय, अब आपको पुराने odeint के बजाय solve_ivp का उपयोग करना चाहिए।

यदि यह मेरा अपना कोड होता, तो शायद मैं अपने फ़ंक्शन के आंशिक संस्करण में एक संचायक ऑब्जेक्ट पास करके कार्य पूरा करता:

class Acc:
    def __init__(self):
        self.x = 0

    def __str__(self):
        return str(self.x)

def pend_partial(acc):
    def pend(t, y):
        theta, omega = y
        dydt = [omega, -.25*omega - 5*np.sin(theta)]

        acc.x += 1
        return dydt
    return pend

count = Acc()
sol = spi.solve_ivp(pend_partial(count), [0, 10], [np.pi - 0.1, 0.0])
print(count)

आउटपुट:

182

हालाँकि, यदि आप केवल एक छोटी स्क्रिप्ट या कुछ और लिख रहे हैं, तो आपको शायद सरल global दृष्टिकोण का उपयोग करना चाहिए। यह इसके लिए एक बहुत अच्छा उपयोग मामला है।

0
tel 10 पद 2018, 18:11