Unter Differenzieren (oder Ableiten) versteht man die Berechnung der Steigung einer Tangente an der Stelle x einer Funktion y = f(x). Die Ableitung wird mit y' = f'(x) bezeichnet. Die Ableitung einer mathematischen Funktion ist selbst wieder eine Funktion. Will man die Steigung an der Stelle x0 berechnen, so muss man in die Ableitungsfunktion diesen Wert einsetzen: f'(x0). Man erhält so den Funktionswert der Ableitungsfunktion.
Für die Berechnung der Ableitung gilt:
\[ \frac{dy}{dx} =\lim_{x\rightarrow \Delta x} \frac{f(x+\Delta x)-f(x)}{\Delta x} =f^{\prime}(x)\]
Mit der SymPy-Methode diff() können mathematische Funktionen symbolisch differenziert werden.
Mit dem Terminalbefehl
pip3 install sympy
wird das Modul SymPy installiert.
Mit dem Sympy-Programm können Sie (fast) alle gültigen mathematischen Funktionen ableiten. Außerdem können Sie die Produkt- und die Quotientenregel testen.
#sym_differenzieren.py
from sympy import *
x,a = symbols('x,a') #1
y = sin(a*x) #2
dy = diff(y,x,1) #3
print("%s' = %s" %(y,dy))
sin(a*x)' = a*cos(a*x)
In #1 werden die symbolischen Variablen vereinbart. In #2 können Sie den Term einer gültigen mathematischen Funktion eintragen. In #3 wird die die erste Ableitung berechnet. Sie können auch höhere Ableitungen berechnen lassen, indem Sie als drittes Argument eine 2, 3 oder eine andere positive Ganzzahl eintragen. Testen Sie das Programm auch mit dy = y.diff(x,1).
Die Julia-Funktion expand_derivatives() berechnet die erste Ableitung einer mathematischen Funktion symbolisch. Damit Sie diese Funktion benutzen können müssen Sie die Pakete Calculus und Symbolics mit
using Pkg
Pkg.add("Calculus")
Pkg.add("Symbolics")
im Julia-Terminal installieren.
In #3 können Sie andere mathematischen Funktionen eintragen.
#sym_differenzieren.jl
using Calculus,Symbolics
@variables x a #1
Df = Differential(x) #2
y=sin(a*x) #3
dy=expand_derivatives(Df(y)) #4
println(y,"' = ",dy)
sin(a*x)' = a*cos(a*x)
expand_derivatives(Df(y)) die erste Ableitung. Testen Sie das Programm mit anderen mathematischen Funktionen. Überprüfen Sie dabei auch die Produkt- und Quotientenregel.
Einen ersten Zugang zur numerischen Differentiation verschafft uns die Analyse des zentralen Differenzenquotienten.
Aus dem Bild kann die Berechnungsvorschrift für den zentalen Differenzenquotienten abgelesen werden:
\[ \ f^{\prime}\left( x \right) \approx \frac{f(x+\Delta x)-f(x-\Delta x)}{2\Delta x} \]
Anhand eines Beispiels aus der Kinnematik soll gezeigt werden, wie mathematische Funktionen numerisch differenziert werden können. Gegeben ist die Weg-Zeit-Funktion s=f(t) einer Bewegung mit konstanter Beschleunigung a:
\[s=\frac{1}{2} a\cdot t^{2} \]
Es sollen der Geschwindigkeitsverlauf v=f(t) und die Beschleunigung a=f(t) berechnet und grafisch dargestellt werden.
Die SciPy-Dokumentation empfiehlt für die numerische Differentation das Modul Numdifftools zu verwenden.
Als erstes müssen Sie das Python-Modul Numdifftools installieren:
pip3 install numdifftools
Die Ableitungen werden mit der Numdifftools-Methode Derivative() berechnet. In #1 können Sie den Wert für die Beschleunigung ändern.
#diff_weg_zeit_gesetz.py
import numpy as np
import matplotlib.pyplot as plt
from numdifftools import Derivative
a=10 #1
#Weg
def weg(t):
return a*t**2/2
#Geschwindigkeit
def geschwindigkeit(t):
df=Derivative(weg,n=1) #2
return df(t)
#Beschleunigung
def beschleunigung(t):
df=Derivative(geschwindigkeit,n=1) #3
return df(t)
#Grafikbereich
t = np.linspace(0,10,100) #Sekunden
fig,ax =plt.subplots(3,1)
#Weg
ax[0].plot(t, weg(t), 'b-', lw=1)
ax[0].set(ylabel='s')
#Geschwindigkeit
ax[1].plot(t, geschwindigkeit(t), 'g-', lw=1)
ax[1].set(ylabel='v')
#Beschleunigung
ax[2].plot(t, beschleunigung(t), 'r-', lw=1)
ax[2].set(xlabel='t in s',ylabel='a')
ax[2].set_ylim(0,12)
[ax[i].grid(True) for i in range(len(ax))]
fig.tight_layout()
plt.show()
Die Beschleunigung hat die Einheit m/s2 (#1). In #2 berechnet die Numdifftools-Methode Derivative(weg,n=1) die Ableitung der Wegfunktion. Der Parameter n=1 muss nicht angeben werden, wenn die erste Ableitung berechnet werden soll. In #3 wird die Ableitung der Geschwindigkeitspunktion berechnet.
Julia berechnet die erste Ableitung mit der Funktion derivative(). Um diese Funktion nutzen zu können müssen Sie das Paket ForwardDiff mit
using Pkg;Pkg.add("ForwardDiff")
installieren.
In #1 können Sie den Wert für die Beschleunigung ändern.
#diff_weg_zeit_gesetz.jl
using Plots, ForwardDiff
#die Beschleunigung ist konstant
a=10 #1
#Wegfunktion s=f(t)
function weg(t)
return 1/2*a*t^2
end
#Geschwindigkeitsfunktion v=f(t)
function geschwindigkeit(t)
return ForwardDiff.derivative(weg,t) #2
end
#Beschleunigungsfunktion a=f(t)
function beschleunigung(t)
return ForwardDiff.derivative(geschwindigkeit,t) #3
end
#Grafikbereich
t=0:1e-2:10
p1=plot(t,weg,ylabel="s")
p2=plot(t,geschwindigkeit,ylabel="v")
p3=plot(t,beschleunigung,ylim=(0,1.1*a),xlabel="t in s",ylabel="a")
plot(p1,p2,p3,layout=(3,1),legend=false,lc=["blue" "green" "red"])
Die Beschleunigung hat die Einheit m/s2 (#1). In #2 berechnet die Julia-Funktion derivative(weg,t) die Ableitung der Wegfunktion. In #3 wird die Ableitung der Geschwindigkeitspunktion berechnet.
Besuchen Sie die Seite von SciPy.
Besuchen Sie die Seite von Julia.
Startseite | Funktionsplots | Matrizen | Integrieren | Differenzialgleichungen | Animationen