Integration von multiplizierten Derivatfunktionen

Question

Hier ist mein Code. Es ist eine Funktion, die die Ableitung einer anderen Funktion bei einem x-Wert auswertet. Ich möchte, dass es eine gültige Ausgabe auch für gebrochene Ordnung Derivate (a) zurückgibt.

from scipy.special import gamma 
import scipy.integrate as integrate 
import sympy as sp 
import scipy as sc 
import math 

def f(z): 
    return z**2 

def fracdiff(f,x,a): 
    if a==0: 
     return f(x) 
    else: 
     if math.ceil(a)-a==0: 
      q=sp.diff(f(z),z,a) 
      h=q.subs(z,x) 
      return h 
     else: 
      n=math.ceil(a) 
      g1=(1/(gamma(n-a)))   
      q1=sp.diff(f(z),z,n) 
      print(q1) # showing that q1 equals 2*z 
      h1= lambda z:(x-z)**(n-a-1)*2*z # for z^2 the derivative is 2*z 
      ans=sc.integrate.quad(h1,0,x) 
      r=ans[0]*g1 
      return r 


ss=fracdiff(f,1,0.5) 

Mein Problem ist, dass ich h1 integrieren will, die die Vermehrung von (x-z)**(n-a-1) und q1(the derivative of f(z)) ist. Wenn ich f(z)=z^2 lasse und manuell 2*z für q1 einfüge, funktioniert es gut, aber wenn ich versuche, q1 zu benutzen, sagt es "kann Ausdruck nicht in Hin- und Herbewegung übersetzen". Irgendwelche Ideen warum?

Answer 1

Ich denke, Sie vermischen SymPy mit SciPy. SymPy führt nur symbolische Berechnungen durch. SciPy führt nur numerische Berechnungen durch. Wenn Sie einige Zwischenergebnisse in SymPy berechnen und dann verwenden möchten, wenn Sie für numerische Berechnungen die Funktion lambdify (read more here) verwenden müssen, die wie eine lambda-Funktion für SymPy ist, die numerische Ergebnisse liefert. Im folgenden Code habe ich die Funktion lambdify zweimal verwendet, um Ihre SymPy-Derivatberechnungen in Lambda-Funktionen zu konvertieren, die numerische Ergebnisse liefern, die SciPy erwartet.

import sympy as sp 
import scipy as sc 
import math 
from scipy.special import gamma 

def f(z): 
    return z**2 

def fracdiff(f,x,a): 
    if a==0: 
     return f(x) 
    else: 
     if isinstance(a,int): 
      z = sp.Symbol('z') 
      q = sp.diff(f(z), z, a) 
      qf = sp.lambdify(z, q) #Lambdify used here 1 
      h = qf(x) 
      return h 
     else: 
      n = math.ceil(a) 
      g1 = (1/(gamma(n-a)))   
      z = sp.Symbol('z') 
      q1 = sp.diff(f(z), z, n) 
      q1f = sp.lambdify(z, q1) #Lambdify used here 2 
      h1 = lambda p: q1f(p)*(x-p)**(n-a-1) 
      ans = sc.integrate.quad(h1,0,x) 
      r = ans[0]*g1 
      return r 

ss=fracdiff(f,1,0.5) # returns 1.5045055561272689