4.3    SymPy

Mit dem Modul SymPy können Sie symbolische Berechnungen durchführen. Hinweise zur Installation, ein einführendes Tutorial, eine ausführliche Dokumentation und eine umfangreiche Sammlung von Beispielen finden Sie im Internet unter https://sympy.org/.

Tabelle 4.6 zeigt eine Übersicht über wichtige SymPy-Funktionen.

Funktion	Beschreibung
apart(p)	Zerlegt das Polynom p in seine Partialbrüche.
cancel(p)	Erzeugt aus Partialbrüchen p eine ganzrationale Funktion.
diff(f,x,k)	Berechnet die k-te Ableitung einer Funktion ƒ.
dsolve(eq,f(x))	Löst eine gewöhnliche Differenzialgleichung eq für die Funktion ƒ(x).
expand(T)	Berechnet den Term T.
integrate(f,x)	Berechnet die Stammfunktion F(x) der Funktion ƒ(x).
limit(y,x,g)	Berechnet den Grenzwert g einer Folge oder Funktion. Als Grenze g kann 0 oder oo für unendlich eingegeben werden.
simplify(term)	Vereinfacht einen Term.
solve(...,...)	Löst ein lineares oder nichtlineares Gleichungssystem.
N(x,n) oder x.evalf(n)	Konvertiert den genauen Wert von x in einen numerischen Wert mit n Ziffern.

Tabelle 4.6     Ausgewählte SymPy-Funktionen

Wichtige mathematische Konstanten sind pi (Kreiszahl π) und E (die eulersche Zahl e). Die imaginäre Einheit wird mit I gekennzeichnet. Diese Konstanten dürfen Sie nicht als Bezeichner für Variablen verwenden.

Importieren können Sie alle Funktionen/Methoden und Konstanten von SymPy mit der Anweisung from sympy import *. Wenn Sie anstelle des Asterisk-Symbols * die Namen der Funktionen, die Sie verwenden wollen, einsetzen, wird das Programm beim ersten Programmstart schneller ausgeführt.

Folgender Konsolendialog zeigt, dass einige SymPy-Funktionen auch als Methoden benutzt werden können:

>>> from sympy import *
>>> x=symbols('x')
>>> y=x**2
>>> type(diff)
<class 'function'>
>>> type(integrate)
<class 'function'>
>>> type(y.diff)
<class 'method'>
>>> type(y.integrate)
<class 'method'>

Hinweis

Um SymPy-Funktionen besser von mathematischen Funktionen unterscheiden zu können, werden alle SymPy-Funktionen als Methoden bezeichnet.

4.3.1    Symbolische Operationen mit Matrizen

Für die Addition und Multiplikation verwendet SymPy die Operatoren + und *. Die SymPy-Methode Matrix([[...], [...], ...]) erzeugt eine Matrix. Als Einträge sind Zahlen oder symbolische Variablen erlaubt. Welche symbolischen Variablen verwendet werden sollen, muss mithilfe der SymPy-Methode symbols(...) im Quelltext vereinbart werden.

Listing 4.7 berechnet die symbolischen Werte der Summe A+B und des Matrizenprodukts A*B aus den beiden 2×2-Matrizen:

Für die symbolischen Variablen können Sie beliebige Bezeichner verwenden, sofern Sie die vorgeschriebene Python-Notation beachten.

01  #07_sympy_matrix.py
02  from sympy import *
03  a11,a12,a21,a22 = symbols('a11,a12,a21,a22')
04  b11,b12,b21,b22 = symbols('b11,b12,b21,b22')
05  A=Matrix([[a11,a12],
06            [a21,a22]])
07  B=Matrix([[b11,b12],
08            [b21,b22]])
09  S=A + B
10  P=A*B 
11  #Ausgabe
12  print("A:",A)
13  print("B:",B)
14  print("Summe\n",S)
15  print("Matrixprodukt\n",P)

Listing 4.7     Operationen auf Matrizen

Ausgabe

A: Matrix([[a11, a12], [a21, a22]])
B: Matrix([[b11, b12], [b21, b22]])
Summe
 Matrix([[a11 + b11, a12 + b12], [a21 + b21, a22 + b22]])
Matrixprodukt
 Matrix([[a11*b11 + a12*b21, a11*b12 + a12*b22],
         [a21*b11 + a22*b21, a21*b12 + a22*b22]])

Analyse

In der Zeile 02 werden alle verfügbaren SymPy-Methoden importiert. Mit print (type(symbols)) und print(type(Matrix)) können Sie den jeweiligen Typ ermitteln. Die Methode symbols ist vom Typ <class 'function'>, und für die Klasse Matrix lautet die Typbestimmung <class 'type'>.

In den Zeilen 03 und 04 generiert die Methode symbols() die symbolischen Variablen.

In den Zeilen 05 bis 08 erzeugt der Konstruktor Matrix([[...]]) der SymPy-Klasse Matrix die 2×2-Matrizen A und B für die symbolischen Variablen a_ij und b_ij.

In Zeile 09 werden beide Matrizen addiert. Das Ergebnis wird in dem Objekt S gespeichert. Die Anweisung in Zeile 10 berechnet das Matrixprodukt mit dem Infix-Operator *. Das Ergebnis wird in dem Objekt P gespeichert.

Die Ausgaben der Zeilen 14 und 15 bestätigen die erwarteten Ergebnisse.

4.3.2    Symbolisches Differenzieren und Integrieren

Für das Polynom 2. Grades

sollen die 1. Ableitung ƒ', die Stammfunktion F, die Nullstellen und der Flächeninhalt A zwischen den Nullstellen und der x-Achse berechnet werden. Listing 4.8 zeigt die Umsetzung:

01  #08_sympy_analysis.py
02  from sympy import *
03  x = symbols('x')
04  f=-x**2+5*x-3
05  df=diff(f,x,1)
06  F=integrate(f,x)
07  L=solve(f,x)
08  A=integrate(f,(x,L[0],L[1]))
09  print("Polynom       f(x) =",f)
10  print("1. Ableitung f'(x) =",df)
11  print("Stammfunktion F(x) =",F)
12  print("Nullstellen:  ",L)
13  print("Flächeninhalt:",N(A,16))

Listing 4.8     Differenzieren und Integrieren mit SymPy

Ausgabe

Polynom       f(x) = -x**2 + 5*x - 3
1. Ableitung f'(x) = 5 - 2*x
Stammfunktion F(x) = -x**3/3 + 5*x**2/2 - 3*x
Nullstellen:   [5/2 - sqrt(13)/2, sqrt(13)/2 + 5/2]
Flächeninhalt: 7.812027763505310

Analyse

In Zeile 04 wird die Funktion f=-x**2+5*x-3 definiert. In Zeile 05 berechnet die Methode diff() die 1. Ableitung des Polynoms f, und in Zeile 06 berechnet die Methode integrate() die Stammfunktion F des Polynoms f.

In Zeile 07 berechnet die Methode solve() die Nullstellen des Polynoms f. Das Ergebnis wird in dem Objekt L gespeichert. Das Objekt L ist vom Typ <class 'list'>. Mit L[0] und L[1] können Sie auf die Elemente der Liste lesend zugreifen. In Zeile 08 berechnet die Methode integrate(f,(x,L[0],L[1])) das bestimmte Integral, also den Flächeninhalt unter der Kurve.