Mit dem unbestimmten Integral wird die Stammfunktion F einer mathematischen Funktion f berechnet:
\[\int f\left( x \right)dx = F\left( x \right) + C \]
Wenn man die Stammfunktion ableitet, erhält man wieder die Funktion f.
Mit dem bestimmten Integral wird der Flächeninhalt unter einer Kurve berechnet:
\[\int_{a}^{b} f\left( x \right)dx = F\left( b \right) -F\left( a \right) \]
Die folgenden Integrale sollten Sie auswendig lernern:
\[\ \int x^{n}dx\ =\ \frac{1}{n+1} x^{n+1}+C \]
\[\ \int \frac{1}{x} dx\ =\ ln\left| x \right| +C \]
\[\ \int e^{ax}dx\ =\ \frac{1}{a} e^{ax}+C \]
\[\ \int \cos axdx\ =\ \frac{1}{a} \sin ax+C \]
\[\ \int \sin axdx\ =\ -\frac{1}{a} \cos ax+C \]
\[\ \int \cosh axdx\ =\ \frac{1}{a} \sinh ax+C \]
\[\ \int \sinh axdx\ =\ \frac{1}{a} \cosh ax+C \]
Mit den Programmen sym_integrieren.py und sym_integrieren.jl können Sie überprüfen, ob die obigen Integrale richtig berechnet werden. In #2 können Sie die mathematischen Funktionen eintragen, deren Stammfunktion Sie berechnen lassen wollen.
Die SymPy-Methode integrate(func,x, ...) berechnet unbestimmte, bestimmte und Mehrfachintegrale.
#sym_integrieren.py
from sympy import *
x,a=symbols('x,a') #1
y=sin(a*x) #2
F=integrate(y,x) #3
print("∫%sdx = %s + C" %(y,F.args[0][0]))
∫sin(a*x)dx = -cos(a*x)/a + C
In #1 werden die symbolischen Variablen vereinbart. In #2 steht die mathematische Funktion, die symbolisch integriert werden soll. In #3 berechnet die SymPy-Methode das unbestimmte Integral. Testen Sie das Programm auch mit y.integrate(x).
Die Julia-Funktion integrate(y,x,detailed = false,symbolic = true) berechnet unbestimmte Integrale.
#sym_integrieren.jl
using Symbolics,SymbolicNumericIntegration
@variables x a #1
y=sin(a*x) #2
F=integrate(y,x,detailed = false,symbolic = true) #3
println("∫",y, "dx = " ,F," + C")
∫sin(a*x)dx = (-cos(a*x)) / a + C
In #1 werden die symbolischen Variablen vereinbart. In #2 steht die mathematische Funktion, die symbolisch integriert werden soll. In #3 berechnet die Julia-Funktion integrate(y,x, ...) das unbestimmte Integral.
Die einfachste Methode der numerischen Integration besteht darin die Fläche unter einer Kurve durch Rechtecke anzunähern.
Wenn man den Flächeninhalt mit den Untersummen berechnet, erhält man einen zu kleinen Wert. Wenn man den Flächeninhalt mit Obersummen berechnet, erhält man einen zu großen Wert. Ein genaueres Ergebnis erhält man mit den Mittelsummen. Durch Verkleinerung des Abschnitts Δx werden die Ergebnisse genauer. Wird Δx zu klein gewählt, werden die Ergebnisse wegen der Rundungsfehler ungenauer. Die SciPy-Funktion quad() und die Julia-Funktion quadgk() benutzen ausgefeilte Algorithmen für die numerische Integration.
Am Beispiel des Weg-Zeit-Gesetzes soll gezeigt werden, wie die numerische Integration mit Python und Julia implementiert werden kann. Die Beschleunigung a ist gegeben. Sie wird als konstant angenommen. Durch Integration der Beschleunigung erhält man die Geschwindigkeit v. Durch Integration der Geschwindigkeit erhält man den Wert für den zurückgelegten Weg s.
Die SciPy-Methode quad(func,a,b,...) berechnet ein bestimmtes Integral der mathematischen Funktion func im Intervall [a,b]. Diese Funktion gibt ein Tupel mit zwei Einträgen zurück. Das erste Element repräsentiert den Zahlenwert des bestimmten Integrals, der zweite Wert steht für eine Fehlerabschätzung.
#int_weg_zeit_gesetz.py
import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import quad
a=10 #m/s^2
#Beschleunigung
@np.vectorize #1
def beschleunigung(t):
return a
#Geschwindigkeit
@np.vectorize
def geschwindigkeit(t):
return quad(beschleunigung, 0, t)[0] #2
#Weg
@np.vectorize
def weg(t):
return quad(geschwindigkeit, 0, t)[0]
#Grafikbereich
fig, ax=plt.subplots(3,1,figsize=(8,8))
t = np.linspace(0,10,100)
ax[0].plot(t, beschleunigung(t), 'r-', lw=1.5)
ax[0].set(ylabel='a')
ax[0].set_ylim(0,12)
ax[1].plot(t, geschwindigkeit(t), 'g-',lw=1.5)
ax[1].set(ylabel='v')
ax[2].plot(t, weg(t), 'b-', lw=1.5)
ax[2].set(xlabel='t in s',ylabel='s')
[ax[i].grid(True) for i in range(len(ax))]
fig.tight_layout()
plt.show()
In #1 wird die Konstante a mit @np.vectorize vektorisiert. In #2 wird der Geschwindigkeitsverlauf durch Integration der Beschleunigung berechnet. Der Zusatz [0] unterdrückt die Ausgabe der Fehlerabschätzung. Wenn Sie [0] auskommentieren erhalten Sie eine Fehlermeldung.
Die Julia-Funktion quadgk(func,a,b, ...) berechnet das bestimmte Integral der mathematischen Funktion func im Intervall [a,b]. Diese Funktion gibt ein Tupel mit zwei Einträgen zurück. Das erste Element repräsentiert den Zahlenwert des bestimmten Integrals, der zweite Wert steht für eine Fehlerabschätzung.
using QuadGK,Plots
#konstante Beschleunigung
a=10 #m/s^2
#Beschleunigungsfunktion a=f(t)
function beschleunigung(t)
return a
end
#Geschwindigkeitsfunktion v=f(t)
function geschwindigkeit(t)
return quadgk(beschleunigung,0,t)[1] #1
end
#Wegfunktion s=f(t)
function weg(t)
return quadgk(geschwindigkeit,0,t)[1]
end
#Grafikbereich
t=0:1e-2:10
p1=plot(t,beschleunigung,ylim=(0,1.1*a),ylabel="a",label=false)
p2=plot(t,geschwindigkeit,ylabel="v",label=false)
p3=plot(t,weg,xlabel="t in s",ylabel="s",label=false)
plot(p1,p2,p3,layout=(3,1),lc=["red" "green" "blue"],lw=1.5)
In #1 wird die Geschwindigkeit durch Integration der Beschleunigung berechnet. Zu beachten ist, das in Julia die Indizierung eines Vektors oder Tupels mit 1 beginnt.
Das Python-Modul SciyPy und die Julia Paket MultiQuad stellen auch Funktionen zur Verfügung mit denen Zweifach- und Dreifachintegrale numerisch berechnet werden können.
Das Zweifachintegral mit variablen Grenzen
\[\int^{2}_{1} \int^{3y}_{y} \left( x+y\right) dxdy=14 \]
soll mit Python und Julia berechnet werden.
Zweifachintegrale werden mit der SciPy-Funktion dblquad(func, ...) berechnet.
#zweifachintegral.py
from scipy.integrate import dblquad
def f(x,y):
return x+y
V= dblquad(f,1,2,lambda y:y,lambda y:3*y)[0]
print("V =",V)
V = 14.0
Zweifachintegrale werden mit der Julia-Funktion dblquad(func, ...) berechnet.
#zweifachintegral.jl
using MultiQuad
f(y,x) = x+y
integral, error = dblquad(f, 1, 2, y->y, y->3*y)
(14.000000000000002, 8.577383370543382e-14)
Das Dreifachfachintegral mit variablen Grenzen
\[\int^{1}_{0} \int^{1-x}_{0} \int^{2-x}_{0} x \cdot y\cdot zdzdydx=\frac{13}{240} \]
soll mit Python und Julia berechnet werden
Dreifachintegrale werden mit der SciPy-Funktion tplquad(func, ...) berechnet.
#dreifachintegral.py
from scipy.integrate import tplquad
def f(z,y,x):
return x*y*z
I = tplquad(f,0,1,0,lambda x:1-x,0,lambda x,y:2-x)[0]
print("I =",I)
I = 0.054166666666666675
Dreifachintegrale werden mit der Julia-Funktion tplquad(func, ...) berechnet.
#dreifachintegral.jl
using MultiQuad
f(x,y,z) = x*y*z
integral, error = tplquad(f, 0, 1, x->0, x->1-x, (x,y)->0, (x,y)->2-x)
(0.054166666666666655, 1.5700924586837752e-16)
Besuchen Sie die Seite von SciPy.
Besuchen Sie die Seite von Julia.
Startseite | Funktionsplots | Matrizen | Differenzieren | Differenzialgleichungen | Animationen