मैं एक समीकरण लिखने की कोशिश कर रहा हूं जो निम्नलिखित चीजें करता है:

1) एक समीकरण को एकीकृत करता है

2) उस समीकरण को बाद में उपयोग के लिए संग्रहीत करता है

3) पहले को संख्यात्मक रूप से एकीकृत करें और 100 अलग-अलग अंतरालों पर दूसरे समीकरण का मूल्यांकन करें, हर बार एक निश्चित राशि से बढ़ रहा है

import math
from sympy import *
import kvalues
import time
import random
import pandas as pd
import matplotlib.pyplot as plt

पहला कार्य बहुत सरल है, मैंने इसे इस प्रकार पूरा किया:

def integration_gas(number,Fa_0,Fb_0,Fc_0,v_0,a,b,c,d,e):    
  Ca_0 = Fa_0/v_0
  Cb_0 = Fb_0/v_0
  Cc_0 = Fc_0/v_0
  Ft_0 = Fb_0 + Fa_0 + Fc_0
  theta1 = Cb_0/Ca_0
  stoic1 = b/a
  theta2 = Cc_0/Ca_0
  stoic2 = c/a
  stoic3 = d/a
  stoic4 = e/a
  Cd = stoic3*x
  Ce = stoic4*x
  sigma = e+d-c-b-1
  epsilon = (Fa_0/Ft_0)*sigma
  Ca_eq = Ca_0*((1-x)/(1+epsilon*x))
  Cb_eq = Ca_0*((1*theta1-stoic1*x)/(1+epsilon*x))
  Cc_eq = Ca_0*((1*theta2-stoic2*x)/(1+epsilon*x))                 
  ra = 1*(Ca_eq**a)*(Cb_eq**b)*(Cc_eq**c)*final_k[number-1]    
  equation = Fa_0/ra 
  int1 = Integral(equation,x)    
  pprint(int1)
  evaluate = int1.doit()     
  pprint(evaluate)
  return equation

कोड का यह हिस्सा पूरी तरह से ठीक काम करता है, इसलिए दूसरे भाग पर।

def Ra_gas(number,Fa_0,Fb_0,Fc_0,v_0,a,b,c,d,e): 
    Ca_0 = Fa_0/v_0
    Cb_0 = Fb_0/v_0
    Cc_0 = Fc_0/v_0
    Ft_0 = Fb_0 + Fa_0 + Fc_0
    theta1 = Cb_0/Ca_0
    stoic1 = b/a
    theta2 = Cc_0/Ca_0
    stoic2 = c/a    
    sigma = e+d-c-b-1
    epsilon = (Fa_0/Ft_0)*sigma
    Ca_eq = Ca_0*((1-x)/(1+epsilon*x))
    Cb_eq = Ca_0*((1*theta1-stoic1*x)/(1+epsilon*x))
    Cc_eq = Ca_0*((1*theta2-stoic2*x)/(1+epsilon*x))                 
    ra = 1*(Ca_eq**a)*(Cb_eq**b)*(Cc_eq**c)*final_k[number-1]
    pprint(ra)
    return ra

कोड का यह हिस्सा भी पूरी तरह से ठीक काम करता है। तो अंतिम भाग के लिए मेरे पास निम्न कोड है:

Number = 4
FA0 = 10
FB0 = 25
FC0 = 5
V0 = 2
A = 1
B = 2
C = 0.5
D = 1
E = 1

Ra = []
volume = []
Xff = []
eq1 = integration_gas(Number,FA0,FB0,FC0,V0,A,B,C,D,E)
Ra1 = Ra_gas(Number,FA0,FB0,FC0,V0,A,B,C,D,E)
#print(Ra1)
Xf = 0.01

# Calculates the reaction rate and volume for every interval of conversion
while Xf <=1:
    int2 = Integral(eq1,(x,0,Xf))
    volume.append(int2.doit())
    f = lambdify(x,Ra1,"math")
    f(Xf)
    Ra.append(f(Xf))    
    Xff.append(Xf)
    Xf += 0.01

मैं फिर परिणाम लेता हूं और उन्हें प्लॉट करता हूं। मैंने जो कुछ भी लिखा है वह कुछ स्थितियों के लिए बिल्कुल ठीक काम करता है और लगभग 10 ~ 15 सेकंड में पूरा हो जाता है। हालांकि, विशेष रूप से इस तरह की स्थितियों में, मैं इस कोड को बिना किसी समाधान के 5+ घंटे से चला रहा हूं। मैं इस कोड को कैसे अनुकूलित कर सकता हूं?

-1
Travis Czechorski 27 सितंबर 2018, 21:38

1 उत्तर

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

सिम्पी पर एक नज़र डालें, यह प्रतीकात्मक रूप से आपके मूल समीकरण को एकीकृत कर सकता है और फिर आप इसका मूल्यांकन numpy के माध्यम से कर सकते हैं। "असली" गणित के लिए पायथन थोड़ा धीमा है, scipy Stack (numpy, matplotlib, sympy...) बहुत तेज़ है।

हालांकि 5+ घंटे थोड़ा लंबा है, क्या आप सुनिश्चित हैं कि यह वास्तव में निष्पादित होता है?

संपादित करें: कोशिश करने के लिए एक साधारण बात क्षमा करें, अभी आपने देखा है कि आप लैम्ब्डिफाइंग कर रहे हैं, हो सकता है कि आप अपने आयात शामिल करना चाहें ताकि लोग देखें कि आप क्या उपयोग कर रहे हैं।

शुरू में:

import numpy as np

आइए आपके कोड के इस अंश को देखें:

Xf = 0.01
while Xf <=1: 
    int2 = Integral(eq1,(x,0,Xf)) 
    volume.append(int2.doit()) 
    f = lambdify(x,Ra1,"math") #you're lambdifying each iteration that takes time
    f(Xf) # no assignment here, unless you're doing something in place this line does nothing
    Ra.append(f(Xf)) 
    Xff.append(Xf) 
    Xf += 0.01

इस की तर्ज पर कुछ के साथ:

Xf = np.arange(0.01, 1.01, 0.01) #vector with values from 0.01 to 1 in steps of 0.01
f = np.vectorize(lambdify(x,Ra1,"math")) # you anonymous function but able to take np vectors/np arrays
Ra = f(Xf)
#Xff would be Xf
0
SV-97 27 सितंबर 2018, 22:05