Differenzieren

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 x₀ berechnen, so muss man in die Ableitungsfunktion diesen Wert einsetzen: f'(x₀). Man erhält so den Funktionswert der Ableitungsfunktion.

Symbolisches Differenzieren

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)\]

Lösung mit Python

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))  

Ausgabe

sin(a*x)' = a*cos(a*x)    

Analyse

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).

Lösung mit Julia

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)

Ausgabe

sin(a*x)' = a*cos(a*x)

Analyse

Numerischisches Differenzieren

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} \]

In der Literatur wird häufig für Δx die Variable h eingesetzt. Die Tabelle zeigt die Implementierung des Algorithmus für den zentralen Differenzenquotieneten in Python und Julia.

#zentralerdifferenzenquotient.py
def f(x):
    return x**2
def diff(f,x,h=1e-6):
    return (f(x+h)-f(x-h))/(2*h)
diff(f,2)

#zentralerdifferenzenquotient.jl
f(x)=x^2
function diff(f,x,h=1e-6)
    return (f(x+h)-f(x-h))/(2*h)
end
diff(f,2)

Anhand eines Beispiels aus der Kinematik 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.

Lösung mit Python

Die Ableitungen werden mit der SciPy-Funktion derivative() berechnet (ab Version 1.15.0).

Der Dialog in der Python-Shell zeigt, wie die Funktion derivative() arbeitet. Berechnet wird die Steigung einer Normalparabel an der Stelle x = 2.

>>> from scipy.differentiate import derivative
>>> derivative(lambda x:x**2,2)
     success: True
      status: 0
          df: 4.0
       error: 7.105427357601002e-15
         nit: 2
        nfev: 11
           x: 2.0
>>> 

Die Ausgabe df = 4.0 zeigt das richtige Ergebnis.

Das Python-Programm diff_weg_zeit_gesetz.py berechnet aus der Weg-Zeit-Funktion mit Hilfe der ersten Ableitung die Geschwindigkeits-Zeit-Funktion und durch Ableitung der Geschwindigkeits-Zeit-Funktion die Beschleunigungsfunktion. 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 scipy.differentiate import derivative
a=10                                   #1
#Weg
def weg(t):
    return a*t**2/2
#Geschwindigkeit
def geschwindigkeit(t):
    res=derivative(weg,t)              #2
    return res.df
#Beschleunigung
@np.vectorize                          #3
def beschleunigung(t):
    res=derivative(geschwindigkeit,t)  #4
    return res.df
#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()

Ausgabe

Analyse

Die Beschleunigung hat die Einheit m/s² (#1). In #2 berechnet die SciPy-Funktion derivative(weg,t) die Ableitung der Wegfunktion. Kommentieren Sie #3 aus und interpretieren Sie Warnung. In #4 wird die Ableitung der Geschwindigkeitsfunktion berechnet.

Lösung mit Julia

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.

Der folgende Julia-Konsolendialog soll die Arbeitsweise der Julia-Funktion derivative() zeigen:

julia> using ForwardDiff
julia> ForwardDiff.derivative(x->x^2,2)
4

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"])

Ausgabe

Analyse

Die Beschleunigung hat die Einheit m/s² (#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