SymPy - Kurzanleitung
SymPy ist eine Python-Bibliothek zur Durchführung symbolischer Berechnungen. Es ist eincomputer algebra system(CAS), die entweder als eigenständige Anwendung oder als Bibliothek für andere Anwendungen verwendet werden kann. Die Live-Session ist auch unter verfügbarhttps://live.sympy.org/. Da es sich um eine reine Python-Bibliothek handelt, kann sie als interaktiver Modus und als programmatische Anwendung verwendet werden. SymPy ist mittlerweile eine beliebte symbolische Bibliothek für das wissenschaftliche Python-Ökosystem.
SymPy verfügt über eine breite Palette von Funktionen, die im Bereich der grundlegenden symbolischen Arithmetik, der Analysis, der Algebra, der diskreten Mathematik, der Quantenphysik usw. anwendbar sind. SymPy kann die Ergebnisse in verschiedenen Formaten formatieren, einschließlich LaTeX, MathML usw. SymPy wird unter vertrieben Neue BSD-Lizenz. Ein Entwicklerteam unter der Leitung vonOndřej Čertík und Aaron Meurer veröffentlichte die erste Version von SymPy im Jahr 2007. Die aktuelle Version ist 1.5.1.
Einige der Anwendungsbereiche von SymPy sind -
- Polynomials
- Calculus
- Diskrete Mathematik
- Matrices
- Geometry
- Plotting
- Physics
- Statistics
- Combinatorics
SymPy hat eine wichtige vorausgesetzte Bibliothek namens mpmath. Es ist eine Python-Bibliothek für reale und komplexe Gleitkomma-Arithmetik mit beliebiger Genauigkeit. Das Python-Paketinstallationsprogramm PIP installiert es jedoch automatisch, wenn SymPy wie folgt installiert wird:
pip install sympyIn anderen Python-Distributionen wie Anaconda, Enthought Canopy usw. ist SymPy möglicherweise bereits enthalten. Zur Überprüfung können Sie Folgendes in die Python-Eingabeaufforderung eingeben:
>>> import sympy
>>> sympy.__version__Und Sie erhalten die folgende Ausgabe als aktuelle Version von Sympy -
'1.5.1'
Der Quellcode des SymPy-Pakets ist unter verfügbar https://github.com/sympy/sympy.
Die symbolische Berechnung bezieht sich auf die Entwicklung von Algorithmen zur Manipulation mathematischer Ausdrücke und anderer mathematischer Objekte. Die symbolische Berechnung integriert Mathematik mit Informatik, um mathematische Ausdrücke mithilfe mathematischer Symbole zu lösen. Ein Computer Algebra System (CAS) wie SymPy wertet algebraische Ausdrücke genau (nicht ungefähr) mit denselben Symbolen aus, die bei herkömmlichen manuellen Methoden verwendet werden. Zum Beispiel berechnen wir die Quadratwurzel einer Zahl mit dem unten angegebenen Python-Mathematikmodul -
>>> import math
>>> print (math.sqrt(25), math.sqrt(7))Die Ausgabe für das obige Code-Snippet lautet wie folgt:
5.0 2.6457513110645907
Wie Sie sehen können, wird die Quadratwurzel von 7 ungefähr berechnet. In SymPy werden Quadratwurzeln von Zahlen, die keine perfekten Quadrate sind, standardmäßig nicht bewertet, wie unten angegeben -
>>> import sympy
>>> print (sympy.sqrt(7))Die Ausgabe für das obige Code-Snippet lautet wie folgt:
sqrt(7)
Es ist möglich, das Ergebnis des Ausdrucks mit dem folgenden Codeausschnitt symbolisch zu vereinfachen und anzuzeigen -
>>> import math
>>> print (math.sqrt(12))Die Ausgabe für das obige Code-Snippet lautet wie folgt:
3.4641016151377544
Sie müssen das folgende Codefragment verwenden, um dasselbe mit sympy auszuführen -
##sympy output
>>> print (sympy.sqrt(12))Und die Ausgabe dafür ist wie folgt -
2*sqrt(3)
Wenn SymPy-Code in einem Jupyter-Notizbuch ausgeführt wird, verwendet er die MathJax-Bibliothek, um mathematische Symbole in LatEx-Form zu rendern. Es wird im folgenden Code-Snippet gezeigt -
>>> from sympy import *
>>> x=Symbol ('x')
>>> expr = integrate(x**x, x)
>>> exprBei Ausführung des obigen Befehls in der Python-Shell wird die folgende Ausgabe generiert:
Integral(x**x, x)Welches ist gleichbedeutend mit
$\int \mathrm{x}^{x}\,\mathrm{d}x$
Die Quadratwurzel eines nicht perfekten Quadrats kann durch Latex wie folgt dargestellt werden, wobei das traditionelle Symbol verwendet wird:
>>> from sympy import *
>>> x=7
>>> sqrt(x)Die Ausgabe für das obige Code-Snippet lautet wie folgt:
$\sqrt7$
Ein symbolisches Berechnungssystem wie SymPy führt alle Arten von Berechnungen (wie Ableitungen, Integrale und Grenzen, Lösen von Gleichungen, Arbeiten mit Matrizen) symbolisch durch. Das SymPy-Paket enthält verschiedene Module, die Plotten, Drucken (wie LATEX), Physik, Statistik, Kombinatorik, Zahlentheorie, Geometrie, Logik usw. unterstützen.
Das Kernmodul im SymPy-Paket enthält die Zahlenklasse, die Ordnungszahlen darstellt. Diese Klasse hat zwei Unterklassen: Float- und Rational-Klasse. Die Rational-Klasse wird um die Integer-Klasse erweitert.
Die Gleitkommaklasse repräsentiert eine Gleitkommazahl mit beliebiger Genauigkeit.
>>> from sympy import Float
>>> Float(6.32)Die Ausgabe für das obige Code-Snippet lautet wie folgt:
6.32
SymPy kann eine Ganzzahl oder eine Zeichenfolge in float konvertieren.
>>> Float(10)10.0
Float('1.33E5')# scientific notation133000.0
Bei der Konvertierung in Float ist es auch möglich, die Anzahl der Stellen für die Genauigkeit wie unten angegeben anzugeben.
>>> Float(1.33333,2)Die Ausgabe für das obige Code-Snippet lautet wie folgt:
1.3
Eine Darstellung einer Zahl (p / q) wird als Objekt der Rational-Klasse dargestellt, wobei q eine Zahl ungleich Null ist.
>>> Rational(3/4)Die Ausgabe für das obige Code-Snippet lautet wie folgt:
$\frac{3}{4}$
Wenn eine Gleitkommazahl an den Konstruktor Rational () übergeben wird, gibt sie den zugrunde liegenden Wert ihrer Binärdarstellung zurück
>>> Rational(0.2)Die Ausgabe für das obige Code-Snippet lautet wie folgt:
$\frac{3602879701896397}{18014398509481984}$
Geben Sie zur einfacheren Darstellung die Nennerbegrenzung an.
>>> Rational(0.2).limit_denominator(100)Die Ausgabe für das obige Code-Snippet lautet wie folgt:
$\frac{1}{5}$
Wenn eine Zeichenfolge an den Konstruktor Rational () übergeben wird, wird eine rationale Anzahl beliebiger Genauigkeit zurückgegeben.
>>> Rational("3.65")Die Ausgabe für das obige Code-Snippet lautet wie folgt:
$\frac{73}{20}$
Ein rationales Objekt kann auch erhalten werden, wenn zwei Zahlenargumente übergeben werden. Zähler- und Nennerteile sind als Eigenschaften verfügbar.
>>> a=Rational(3,5)
>>> print (a)
>>> print ("numerator:{}, denominator:{}".format(a.p, a.q))Die Ausgabe für das obige Code-Snippet lautet wie folgt:
3/5
numerator:3, denominator:5
>>> aDie Ausgabe für das obige Code-Snippet lautet wie folgt:
$\frac{3}{5}$
Die Ganzzahlklasse in SymPy repräsentiert eine Ganzzahl beliebiger Größe. Der Konstruktor kann eine Float- oder Rational-Zahl akzeptieren, der Bruchteil wird jedoch verworfen
>>> Integer(10)Die Ausgabe für das obige Code-Snippet lautet wie folgt:
10
>>> Integer(3.4)Die Ausgabe für das obige Code-Snippet lautet wie folgt:
3
>>> Integer(2/7)Die Ausgabe für das obige Code-Snippet lautet wie folgt:
0
SymPy hat eine RealNumberKlasse, die als Alias für Float fungiert. SymPy definiert Zero und One auch als Singleton-Klassen, auf die mit S.Zero bzw. S.One zugegriffen werden kann (siehe unten).
>>> S.ZeroDie Ausgabe ist wie folgt -
0
>>> S.OneDie Ausgabe ist wie folgt -
1
Andere vordefinierte Singleton-Zahlenobjekte sind Half, NaN, Infinity und ImaginaryUnit
>>> from sympy import S
>>> print (S.Half)Die Ausgabe ist wie folgt -
½
>>> print (S.NaN)Die Ausgabe ist wie folgt -
nan
Infinity ist als oo-Symbolobjekt oder S.Infinity verfügbar
>>> from sympy import oo
>>> ooDie Ausgabe für das obige Code-Snippet lautet wie folgt:
$\infty$
>>> S.InfinityDie Ausgabe für das obige Code-Snippet lautet wie folgt:
$\infty$
Die ImaginaryUnit-Nummer kann als I-Symbol importiert oder als S.ImaginaryUnit aufgerufen werden und repräsentiert die Quadratwurzel von -1
>>> from sympy import I
>>> IWenn Sie das obige Code-Snippet ausführen, erhalten Sie die folgende Ausgabe:
i
>>> S.ImaginaryUnitDie Ausgabe des obigen Snippets ist wie folgt:
i
>>> from sympy import sqrt
>>> i=sqrt(-1)
>>> i*iWenn Sie das obige Code-Snippet ausführen, erhalten Sie die folgende Ausgabe:
-1
Symbolist die wichtigste Klasse in der symPy-Bibliothek. Wie bereits erwähnt, werden symbolische Berechnungen mit Symbolen durchgeführt. SymPy-Variablen sind Objekte der Symbols-Klasse.
Das Argument der Funktion Symbol () ist eine Zeichenfolge mit einem Symbol, das einer Variablen zugewiesen werden kann.
>>> from sympy import Symbol
>>> x=Symbol('x')
>>> y=Symbol('y')
>>> expr=x**2+y**2
>>> exprDas obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$x^2 + y^2$
Ein Symbol kann aus mehr als einem Alphabet bestehen.
>>> s=Symbol('side')
>>> s**3Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$side^3$
SymPy hat auch eine Symbols()Funktion, die mehrere Symbole gleichzeitig definieren kann. String enthält Namen von Variablen, die durch Komma oder Leerzeichen getrennt sind.
>>> from sympy import symbols
>>> x,y,z=symbols("x,y,z")Im abc-Modul von SymPy werden alle lateinischen und griechischen Alphabete als Symbole definiert. Daher ist diese Methode praktisch, anstatt ein Symbolobjekt zu instanziieren.
>>> from sympy.abc import x,y,zAllerdings die Namen C, O, S, I, N, E und Qsind vordefinierte Symbole. Außerdem werden im abc-Modul keine Symbole mit mehr als einem Alphabet definiert, für die Sie das Symbolobjekt wie oben verwenden sollten. Das abc-Modul definiert spezielle Namen, die Definitionen im Standard-SymPy-Namespace erkennen können. clash1 enthält einzelne Buchstaben und clash2 enthält Kollisionssymbole mit mehreren Buchstaben
>>> from sympy.abc import _clash1, _clash2
>>> _clash1Die Ausgabe des obigen Snippets ist wie folgt:
{'C': C, 'O': O, 'Q': Q, 'N': N, 'I': I, 'E': E, 'S': S}
>>> _clash2Die Ausgabe des obigen Snippets ist wie folgt:
{'beta': beta, 'zeta': zeta, 'gamma': gamma, 'pi': pi}
Indizierte Symbole können mit einer Syntax definiert werden, die der Funktion range () ähnelt. Bereiche werden durch einen Doppelpunkt angezeigt. Die Art des Bereichs wird durch das Zeichen rechts vom Doppelpunkt bestimmt. Wenn es sich um eine Ziffer handelt, werden alle zusammenhängenden Ziffern links als nicht negativer Startwert verwendet. Alle zusammenhängenden Ziffern rechts werden als 1 größer als der Endwert angenommen.
>>> from sympy import symbols
>>> symbols('a:5')Die Ausgabe des obigen Snippets ist wie folgt:
(a0, a1, a2, a3, a4)
>>> symbols('mark(1:4)')Die Ausgabe des obigen Snippets ist wie folgt:
(mark1, mark2, mark3)
Eine der grundlegendsten Operationen, die an einem mathematischen Ausdruck ausgeführt werden müssen, ist die Substitution. Die subs () - Funktion in SymPy ersetzt alle Vorkommen des ersten Parameters durch den zweiten.
>>> from sympy.abc import x,a
>>> expr=sin(x)*sin(x)+cos(x)*cos(x)
>>> exprDas obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$\sin^2(x)+\cos^2(x)$
>>> expr.subs(x,a)Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$\sin^2(a)+\cos^2(a)$
Diese Funktion ist nützlich, wenn wir einen bestimmten Ausdruck auswerten möchten. Zum Beispiel möchten wir die Werte des folgenden Ausdrucks berechnen, indem wir a durch 5 ersetzen.
>>> expr=a*a+2*a+5
>>> exprDas obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$a^2 + 2a + 5$
expr.subs(a,5)Das obige Code-Snippet liefert die folgende Ausgabe:
40
>>> from sympy.abc import x
>>> from sympy import sin, pi
>>> expr=sin(x)
>>> expr1=expr.subs(x,pi)
>>> expr1Das obige Code-Snippet liefert die folgende Ausgabe:
0
Diese Funktion wird auch verwendet, um einen Unterausdruck durch einen anderen Unterausdruck zu ersetzen. Im folgenden Beispiel wird b durch a + b ersetzt.
>>> from sympy.abc import a,b
>>> expr=(a+b)**2
>>> expr1=expr.subs(b,a+b)
>>> expr1Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$(2a + b)^2$
Die Funktion sympify () wird verwendet, um einen beliebigen Ausdruck so zu konvertieren, dass er als SymPy-Ausdruck verwendet werden kann. Normale Python-Objekte wie Ganzzahlobjekte werden in SymPy konvertiert. Ganzzahlige Zeichenfolgen usw. werden ebenfalls in SymPy-Ausdrücke konvertiert.
>>> expr="x**2+3*x+2"
>>> expr1=sympify(expr)
>>> expr1
>>> expr1.subs(x,2)Das obige Code-Snippet liefert die folgende Ausgabe:
12
Jedes Python-Objekt kann in ein SymPy-Objekt konvertiert werden. Da die Konvertierung jedoch intern die Funktion eval () verwendet, sollte kein nicht bereinigter Ausdruck verwendet werden, da sonst SympifyError ausgelöst wird.
>>> sympify("x***2")
---------------------------------------------------------------------------SympifyError: Sympify des Ausdrucks 'konnte' x *** 2 '' konnte nicht analysiert werden, da eine Ausnahme ausgelöst wurde.
Die Funktion sympify () akzeptiert folgende Argumente: * strict: Standard ist False. Bei der Einstellung True werden nur die Typen konvertiert, für die eine explizite Konvertierung definiert wurde. Andernfalls wird SympifyError ausgelöst. * evaluieren: Wenn auf False gesetzt, werden Arithmetik und Operatoren ohne Auswertung des Ausdrucks in ihre SymPy-Äquivalente konvertiert.
>>> sympify("10/5+4/2")Das obige Code-Snippet liefert die folgende Ausgabe:
4
>>> sympify("10/5+4/2", evaluate=False)Das obige Code-Snippet liefert die folgende Ausgabe:
$\frac{10}{5}+\frac{4}{2}$
Diese Funktion wertet einen bestimmten numerischen Ausdruck bis zu einer bestimmten Gleitkommagenauigkeit von bis zu 100 Stellen aus. Die Funktion verwendet auch den Parameter subs, ein Wörterbuchobjekt mit numerischen Werten für Symbole. Betrachten Sie den folgenden Ausdruck
>>> from sympy.abc import r
>>> expr=pi*r**2
>>> exprDas obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$\Pi{r^2}$
Bewertung des obigen Ausdrucks unter Verwendung der Funktion evalf () durch Ersetzen von r durch 5
>>> expr.evalf(subs={r:5})Das obige Code-Snippet liefert die folgende Ausgabe:
78.5398163397448
Standardmäßig beträgt die Gleitkomma-Genauigkeit bis zu 15 Stellen, die durch eine beliebige Zahl bis zu 100 überschrieben werden können. Der folgende Ausdruck wird mit bis zu 20 Stellen bewertet.
>>> expr=a/b
>>> expr.evalf(20, subs={a:100, b:3})Das obige Code-Snippet liefert die folgende Ausgabe:
33.333333333333333333
Die Funktion lambdify übersetzt SymPy-Ausdrücke in Python-Funktionen. Wenn ein Ausdruck über einen großen Wertebereich ausgewertet werden soll, ist die Funktion evalf () nicht effizient. lambdify verhält sich wie eine Lambda-Funktion, konvertiert jedoch die SymPy-Namen in die Namen der angegebenen numerischen Bibliothek, normalerweise NumPy. Standardmäßig lambdifizieren Sie Implementierungen in der Mathe-Standardbibliothek.
>>> expr=1/sin(x)
>>> f=lambdify(x, expr)
>>> f(3.14)Das obige Code-Snippet liefert die folgende Ausgabe:
627.8831939138764
Der Ausdruck kann mehr als eine Variable haben. In diesem Fall ist das erste Argument für die Funktion lambdify () eine Liste von Variablen, gefolgt von dem auszuwertenden Ausdruck.
>>> expr=a**2+b**2
>>> f=lambdify([a,b],expr)
>>> f(2,3)Das obige Code-Snippet liefert die folgende Ausgabe:
13
Um die Numpy-Bibliothek als numerisches Backend zu nutzen, müssen wir dasselbe als Argument für die Funktion lambdify () definieren.
>>> f=lambdify([a,b],expr, "numpy")Wir verwenden zwei Numpy-Arrays für zwei Argumente a und b in der obigen Funktion. Die Ausführungszeit ist bei Numpy-Arrays sehr schnell.
>>> import numpy
>>> l1=numpy.arange(1,6)
>>> l2=numpy.arange(6,11)
>>> f(l1,l2)Das obige Code-Snippet liefert die folgende Ausgabe:
array([ 37, 53, 73, 97, 125], dtype=int32)
Boolesche Funktionen sind in definiert sympy.basic.booleanarg module. Es ist möglich, boolesche Ausdrücke mit den Standard-Python-Operatoren & (And), | zu erstellen (Oder), ~ (Nicht) sowie mit >> und <<. Boolesche Ausdrücke erben von der im SymPy-Kernmodul definierten Basisklasse.
BooleanTrue-Funktion
Diese Funktion entspricht True wie in Kern-Python. Es gibt einen Singleton zurück, der von S.true abgerufen werden kann.
>>> from sympy import *
>>> x=sympify(true)
>>> x, S.trueDas obige Code-Snippet liefert die folgende Ausgabe:
(Wahr, wahr)
BooleanFalse-Funktion
In ähnlicher Weise entspricht diese Funktion Boolean False in Python und kann von S.false aufgerufen werden
>>> from sympy import *
>>> x=sympify(false)
>>> x, S.falseDas obige Code-Snippet liefert die folgende Ausgabe:
(Falsch, Falsch)
Und funktionieren
Eine logische AND-Funktion wertet ihre beiden Argumente aus und gibt False zurück, wenn eines von beiden False ist. Die Funktion emuliert & operator.
>>> from sympy import *
>>> from sympy.logic.boolalg import And
>>> x,y=symbols('x y')
>>> x=True
>>> y=True
>>> And(x,y), x"&"yDas obige Code-Snippet liefert die folgende Ausgabe:
(Wahr, wahr)
>>> y=False
>>> And(x,y), x"&"yDas obige Code-Snippet liefert die folgende Ausgabe:
(Falsch, Falsch)
Oder funktionieren
Diese Funktion wertet zwei boolesche Argumente aus und gibt True zurück, wenn eines von beiden True ist. Die | Der Bediener emuliert bequem sein Verhalten.
>>> from sympy import *
>>> from sympy.logic.boolalg import Or
>>> x,y=symbols('x y')
>>> x=True
>>> y=False
>>> Or(x,y), x|yDas obige Code-Snippet liefert die folgende Ausgabe:
(Wahr, wahr)
>>> x=False
>>> y=False
>>> Or(x,y), x|yDas obige Code-Snippet liefert die folgende Ausgabe:
(Falsch, Falsch)
Keine Funktion
Eine logische Not-Funktion führt zur Negation des Booleschen Arguments. Es gibt True zurück, wenn das Argument False ist, und False, wenn True. Der Operator ~ führt die Operation ähnlich der Funktion Not aus. Es wird im folgenden Beispiel gezeigt -
>>> from sympy import *
>>> from sympy.logic.boolalg import Or, And, Not
>>> x,y=symbols('x y')
>>> x=True
>>> y=False
>>> Not(x), Not(y)Das obige Code-Snippet liefert die folgende Ausgabe:
(Falsch Richtig)
>>> Not(And(x,y)), Not(Or(x,y))Das obige Code-Snippet liefert die folgende Ausgabe:
(Wahr falsch)
Xoder Funktion
Die Funktion Logisches XOR (exklusives ODER) gibt True zurück, wenn eine ungerade Anzahl der Argumente True und der Rest False ist, und False, wenn eine gerade Anzahl der Argumente True und der Rest False ist. Eine ähnliche Operation wird vom Operator ^ ausgeführt.
>>> from sympy import *
>>> from sympy.logic.boolalg import Xor
>>> x,y=symbols('x y')
>>> x=True
>>> y=False
>>> Xor(x,y), x^yDas obige Code-Snippet liefert die folgende Ausgabe:
(Wahr, wahr)
>>> a,b,c,d,e=symbols('a b c d e')
>>> a,b,c,d,e=(True, False, True, True, False)
>>> Xor(a,b,c,d,e)Das obige Code-Snippet liefert die folgende Ausgabe:
Wahr
Im obigen Fall sind drei Argumente (ungerade Zahl) True, daher gibt Xor true zurück. Wenn die Anzahl der True-Argumente jedoch gerade ist, führt dies zu False (siehe unten).
>>> a,b,c,d,e=(True, False, False, True, False)
>>> Xor(a,b,c,d,e)Das obige Code-Snippet liefert die folgende Ausgabe:
Falsch
Nand Funktion
Diese Funktion führt eine logische NAND-Operation aus. Es wertet seine Argumente aus und gibt True zurück, wenn eines von ihnen False ist, und False, wenn alle True sind.
>>> from sympy import *
>>> from sympy.logic.boolalg import Nand
>>> a,b,c=symbols('a b c')
>>> a,b,c=(True, False, True)
>>> Nand(a,b,c), Nand(a,c)Das obige Code-Snippet liefert die folgende Ausgabe:
(Wahr falsch)
Noch Funktion
Diese Funktion führt eine logische NOR-Operation aus. Es wertet seine Argumente aus und gibt False zurück, wenn eines von ihnen True ist, und True, wenn alle False sind.
>>> from sympy import *
>>> from sympy.logic.boolalg import Nor
>>> a,b,c=symbols('a b c')
>>> a,b,c=(True, False, True)
>>> Nor(a,b,c), Nor(a,c)Das obige Code-Snippet liefert die folgende Ausgabe:
(Falsch, Falsch)
Beachten Sie, dass SymPy den Operator ^ für Xor, ~ für Not, | bereitstellt Für Or und & für And fungiert als Bequemlichkeit, ihre normale Verwendung in Python ist als bitweise Operator. Wenn Operanden ganze Zahlen sind, sind die Ergebnisse daher unterschiedlich.
Äquivalente Funktion
Diese Funktion gibt die Äquivalenzbeziehung zurück. Äquivalent (A, B) ist genau dann wahr, wenn A und B beide wahr oder beide falsch sind. Die Funktion gibt True zurück, wenn alle Argumente logisch äquivalent sind. Gibt sonst False zurück.
>>> from sympy import *
>>> from sympy.logic.boolalg import Equivalent
>>> a,b,c=symbols('a b c')
>>> a,b,c=(True, False, True)
>>> Equivalent(a,b), Equivalent(a,c)Das obige Code-Snippet liefert die folgende Ausgabe:
(Falsch Richtig)
ITE-Funktion
Diese Funktion fungiert als If then else-Klausel in einer Programmiersprache .ITE (A, B, C) wertet das Ergebnis von B aus und gibt es zurück. Wenn A wahr ist, gibt es das Ergebnis von C zurück. Alle Argumente müssen Boolesche Werte sein.
>>> from sympy import * >>> from sympy.logic.boolalg import ITE >>> a,b,c=symbols('a b c') >>> a,b,c=(True, False, True)
>>> ITE(a,b,c), ITE(a,c,b)Das obige Code-Snippet liefert die folgende Ausgabe:
(Falsch Richtig)
Das Annahmenmodul im SymPy-Paket enthält Tools zum Extrahieren von Informationen zu Ausdrücken. Das Modul definiert zu diesem Zweck die Funktion ask ().
sympy.assumptions.ask(property)Die folgenden Eigenschaften bieten nützliche Informationen zu einem Ausdruck:
algebraic(x)
Um algebraisch zu sein, muss eine Zahl eine Wurzel einer Nicht-Null-Polynomgleichung mit rationalen Koeffizienten sein. √2 weil √2 eine Lösung für x2 - 2 = 0 ist, also algebraisch.
complex(x)
Prädikat für komplexe Zahlen. Es ist genau dann wahr, wenn x zur Menge der komplexen Zahlen gehört.
composite(x)
Das von ask (Q.composite (x)) zurückgegebene Prädikat für zusammengesetzte Zahlen ist genau dann wahr, wenn x eine positive ganze Zahl ist und mindestens einen anderen positiven Divisor als 1 und die Zahl selbst hat.
even, odd
Die Rückgabe ask () von true für x befindet sich in der Menge der geraden Zahlen bzw. der Menge der ungeraden Zahlen.
imaginary
Diese Eigenschaft repräsentiert ein Prädikat für eine imaginäre Zahl. Es ist wahr, wenn x als reelle Zahl multipliziert mit der imaginären Einheit I geschrieben werden kann.
integer
Diese von Q.integer (x) zurückgegebene Eigenschaft gibt true von x zurück und gehört zu einer Menge gerader Zahlen.
rational, irrational
Q.irrational (x) ist genau dann wahr, wenn x eine reelle Zahl ist, die nicht als Verhältnis von ganzen Zahlen ausgedrückt werden kann. Zum Beispiel ist pi eine irrationale Zahl.
positive, negative
Prädikate, um zu überprüfen, ob die Zahl positiv oder negativ ist
zero, nonzero
Prädikate zum Teufel, ob eine Zahl Null ist oder nicht
>>> from sympy import *
>>> x=Symbol('x')
>>> x=10
>>> ask(Q.algebraic(pi))
False
>>> ask(Q.complex(5-4*I)), ask( Q.complex(100))
(True, True)
>>> x,y=symbols("x y")
>>> x,y=5,10
>>> ask(Q.composite(x)), ask(Q.composite(y))
(False, True)
>>> ask(Q.even(x)), ask(Q.even(y))
(False, True)
>>> x,y= 2*I, 4+5*I
>>> ask(Q.imaginary(x)), ask(Q.imaginary(y))
(True, False)
>>> x,y=5,10
>>> ask(Q.even(x)), ask(Q.even(y)), ask(Q.odd(x)), ask(Q.odd(y))
(False, True, True, False)
>>> x,y=5,-5
>>> ask(Q.positive(x)), ask(Q.negative(y)), ask(Q.positive(x)), ask(Q.negative(y))
(True, True, True, True)
>>> ask(Q.rational(pi)), ask(Q.irrational(S(2)/3))
(False, False)
>>> ask(Q.zero(oo)), ask(Q.nonzero(I))
(False, False)Sympy hat die mächtige Fähigkeit, mathematische Ausdrücke zu vereinfachen. Es gibt viele Funktionen in SymPy, um verschiedene Arten der Vereinfachung durchzuführen. Dort gibt es eine allgemeine Funktion namens simplify (), die versucht, zur einfachsten Form eines Ausdrucks zu gelangen.
vereinfachen
Diese Funktion ist im Modul sympy.simplify definiert. simplify () versucht, intelligente Heuristiken anzuwenden, um den Eingabeausdruck „einfacher“ zu machen. Der folgende Code vereinfacht den Ausdruck$sin^2(x)+cos^2(x)$.
>>> from sympy import *
>>> x=Symbol('x')
>>> expr=sin(x)**2 + cos(x)**2
>>> simplify(expr)Das obige Code-Snippet liefert die folgende Ausgabe:
1
erweitern
Das expand () ist eine der häufigsten Vereinfachungsfunktionen in SymPy, die zum Erweitern von Polynomausdrücken verwendet wird. Zum Beispiel -
>>> a,b=symbols('a b')
>>> expand((a+b)**2)Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$a^2 + 2ab + b^2$
>>> expand((a+b)*(a-b))Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$a^2 - b^2$
Die Funktion expand () macht Ausdrücke größer und nicht kleiner. Normalerweise ist dies der Fall, aber häufig wird ein Ausdruck kleiner, wenn Sie expand () aufrufen.
>>> expand((x + 1)*(x - 2) - (x - 1)*x)Das obige Code-Snippet liefert die folgende Ausgabe:
-2
Faktor
Diese Funktion nimmt ein Polynom und zerlegt es in irreduzible Faktoren über die rationalen Zahlen.
>>> x,y,z=symbols('x y z')
>>> expr=(x**2*z + 4*x*y*z + 4*y**2*z)
>>> factor(expr)Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$z(x + 2y)^2$
>>> factor(x**2+2*x+1)Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$(x + 1)^2$
Die Funktion factor () ist das Gegenteil von expand (). Jeder der von factor () zurückgegebenen Faktoren ist garantiert nicht reduzierbar. Die Funktion factor_list () gibt eine strukturiertere Ausgabe zurück.
>>> expr=(x**2*z + 4*x*y*z + 4*y**2*z)
>>> factor_list(expr)Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
(1, [(z, 1), (x + 2*y, 2)])
sammeln
Diese Funktion sammelt zusätzliche Begriffe eines Ausdrucks in Bezug auf eine Liste von Ausdrücken bis zu Potenzen mit rationalen Exponenten.
>>> expr=x*y + x - 3 + 2*x**2 - z*x**2 + x**3
>>> exprDas obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$x^3 + x^2z + 2x^2 + xy + x - 3$
Die Funktion collect () für diesen Ausdruck ergibt sich wie folgt:
>>> collect(expr,x)Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$x^3 + x^2(2 - z) + x(y + 1) - 3$
>>> expr=y**2*x + 4*x*y*z + 4*y**2*z+y**3+2*x*y
>>> collect(expr,y)Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$Y^3+Y^2(x+4z)+y(4xz+2x)$
stornieren
Die Funktion cancel () übernimmt jede rationale Funktion und bringt sie in die kanonische Standardform p / q, wobei p und q erweiterte Polynome ohne gemeinsame Faktoren sind. Die führenden Koeffizienten von p und q haben keine Nenner, dh sie sind ganze Zahlen.
>>> expr1=x**2+2*x+1
>>> expr2=x+1
>>> cancel(expr1/expr2)Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$x+1$
>>> expr = 1/x + (3*x/2 - 2)/(x - 4)
>>> exprDas obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$\frac{\frac{3x}{2} - 2}{x - 4} + \frac{1}{x}$
>>> cancel(expr)Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$\frac{3x^2 - 2x - 8}{2x^2 - 8}$
>>> expr=1/sin(x)**2
>>> expr1=sin(x)
>>> cancel(expr1*expr)Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$\frac{1}{\sin(x)}$
trigsimp
Diese Funktion wird verwendet, um trigonometrische Identitäten zu vereinfachen. Es ist anzumerken, dass Namenskonventionen für inverse trigonometrische Funktionen darin bestehen, ein a an die Vorderseite des Funktionsnamens anzuhängen. Beispielsweise wird der inverse Kosinus oder Bogenkosinus acos () genannt.
>>> from sympy import trigsimp, sin, cos
>>> from sympy.abc import x, y
>>> expr = 2*sin(x)**2 + 2*cos(x)**2
>>> trigsimp(expr)2
Die Trigsimp-Funktion verwendet Heuristiken, um die am besten geeignete trigonometrische Identität anzuwenden.
Powersimp
Diese Funktion reduziert den gegebenen Ausdruck, indem Potenzen mit ähnlichen Basen und Exponenten kombiniert werden.
>>> expr=x**y*x**z*y**z
>>> exprDas obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$x^y x^z y^z$
>>> powsimp(expr)Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$x^{y+z} y^z$
Sie können dafür sorgen, dass powsimp () nur Basen kombiniert oder nur Exponenten kombiniert, indem Sie kombinieren = 'Basis' oder kombinieren = 'exp' ändern. Standardmäßig ist comb = 'all', was beides bewirkt. Wenn force True ist, werden Basen kombiniert, ohne nach Annahmen zu suchen.
>>> powsimp(expr, combine='base', force=True)Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$x^y(xy)^z$
Kammimpuls
Kombinatorische Ausdrücke mit faktoriellen und binomischen Ausdrücken können mithilfe der Funktion combsimp () vereinfacht werden. SymPy bietet eine Fakultät ()
>>> expr=factorial(x)/factorial(x - 3)
>>> exprDas obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$\frac{x!}{(x - 3)!}$
Um den obigen kombinatorischen Ausdruck zu vereinfachen, verwenden wir die Funktion combsimp () wie folgt:
>>> combsimp(expr)Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$x(x-2)(x-1)$
Das Binomial (x, y) gibt die Anzahl der Möglichkeiten an, y Elemente aus einer Reihe von x verschiedenen Elementen auszuwählen. Es wird auch oft als xCy geschrieben.
>>> binomial(x,y)Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$(\frac{x}{y})$
>>> combsimp(binomial(x+1, y+1)/binomial(x, y))Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$\frac{x + 1}{y + 1}$
logcombine
Diese Funktion verwendet Logarithmen und kombiniert sie nach den folgenden Regeln:
- log (x) + log (y) == log (x * y), wenn beide positiv sind
- a * log (x) == log (x ** a) wenn x positiv und a real ist
>>> logcombine(a*log(x) + log(y) - log(z))Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$a\log(x) + \log(y) - \log(z)$
Wenn der Kraftparameter dieser Funktion auf True gesetzt ist, wird davon ausgegangen, dass die obigen Annahmen gelten, wenn für eine Menge noch keine Annahme vorliegt.
>>> logcombine(a*log(x) + log(y) - log(z), force=True)Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$\log\frac{x^a y}{z}$
Die Ableitung einer Funktion ist ihre momentane Änderungsrate in Bezug auf eine ihrer Variablen. Dies entspricht dem Ermitteln der Steigung der Tangentenlinie zur Funktion an einem Punkt. Wir können die Differenzierung mathematischer Ausdrücke in Form von Variablen mithilfe der Funktion diff () im SymPy-Paket ermitteln.
diff(expr, variable)
>>> from sympy import diff, sin, exp
>>> from sympy.abc import x,y
>>> expr=x*sin(x*x)+1 >>> exprDas obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$x\sin(x^2) + 1$
>>> diff(expr,x)Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$2x^2\cos(x^2) + \sin(x^2)$
>>> diff(exp(x**2),x)Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
2xex2
Um mehrere Ableitungen zu verwenden, übergeben Sie die Variable so oft, wie Sie unterscheiden möchten, oder übergeben Sie eine Zahl nach der Variablen.
>>> diff(x**4,x,3)Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$24x$
>>> for i in range(1,4): print (diff(x**4,x,i))Das obige Code-Snippet gibt den folgenden Ausdruck -
4*x**3
12*x**2
24*x
Es ist auch möglich, die diff () -Methode eines Ausdrucks aufzurufen. Es funktioniert ähnlich wie die diff () -Funktion.
>>> expr=x*sin(x*x)+1
>>> expr.diff(x)Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$2x^2\cos(x^2) + \sin(x^2)$
Ein nicht bewertetes Derivat wird mithilfe der Derivatklasse erstellt. Es hat die gleiche Syntax wie die Funktion diff (). Verwenden Sie die doit-Methode, um ein nicht bewertetes Derivat zu bewerten.
>>> from sympy import Derivative
>>> d=Derivative(expr)
>>> dDas obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$\frac{d}{dx}(x\sin(x^2)+1)$
>>> d.doit()Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$2x^2\cos(x^2) + \sin(x^2)$
Das SymPy-Paket enthält ein Integralmodul. Es implementiert Methoden zur Berechnung bestimmter und unbestimmter Integrale von Ausdrücken. Die integr () -Methode wird verwendet, um sowohl bestimmte als auch unbestimmte Integrale zu berechnen. Um ein unbestimmtes oder primitives Integral zu berechnen, übergeben Sie einfach die Variable nach dem Ausdruck.
Zum Beispiel -
integrate(f, x)Um ein bestimmtes Integral zu berechnen, übergeben Sie das Argument wie folgt:
(integration_variable, lower_limit, upper_limit)>>> from sympy import *
>>> x,y = symbols('x y')
>>> expr=x**2 + x + 1
>>> integrate(expr, x)Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$\frac{x^3}{3} + \frac{x^2}{2} + x$
>>> expr=sin(x)*tan(x)
>>> expr
>>> integrate(expr,x)Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$-\frac{\log(\sin(x) - 1)}{2} + \frac{\log(\sin(x) + 1)}{2} - \sin(x)$
Das Beispiel eines bestimmten Integrals ist unten angegeben -
>>> expr=exp(-x**2)
>>> integrate(expr,(x,0,oo) )Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$\frac{\sqrt\pi}{2}$
Sie können mehrere Limit-Tupel übergeben, um ein Mehrfachintegral auszuführen. Ein Beispiel ist unten angegeben -
>>> expr=exp(-x**2 - y**2)
>>> integrate(expr,(x,0,oo),(y,0,oo))Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$\frac{\pi}{4}$
Sie können ein nicht bewertetes Integral mit dem Integral-Objekt erstellen, das durch Aufrufen der Methode doit () ausgewertet werden kann.
>>> expr = Integral(log(x)**2, x)
>>> exprDas obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$\int \mathrm\log(x)^2 \mathrm{d}x$
>>> expr.doit()Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$x\log(x)^2 - 2xlog(x) + 2x$
Integrale Transformationen
SymPy unterstützt verschiedene Arten integraler Transformationen wie folgt:
- laplace_transform
- fourier_transform
- sine_transform
- cosine_transform
- hankel_transform
Diese Funktionen werden im Modul sympy.integrals.transforms definiert. Die folgenden Beispiele berechnen die Fourier-Transformation bzw. die Laplace-Transformation.
Example 1
>>> from sympy import fourier_transform, exp
>>> from sympy.abc import x, k
>>> expr=exp(-x**2)
>>> fourier_transform(expr, x, k)Bei Ausführung des obigen Befehls in der Python-Shell wird die folgende Ausgabe generiert:
sqrt(pi)*exp(-pi**2*k**2)Welches ist gleichbedeutend mit -
$\sqrt\pi * e^{\pi^2k^2}$
Example 2
>>> from sympy.integrals import laplace_transform
>>> from sympy.abc import t, s, a
>>> laplace_transform(t**a, t, s)Bei Ausführung des obigen Befehls in der Python-Shell wird die folgende Ausgabe generiert:
(s**(-a)*gamma(a + 1)/s, 0, re(a) > -1)In der Mathematik ist eine Matrix ein zweidimensionales Array von Zahlen, Symbolen oder Ausdrücken. Die Theorie der Matrixmanipulation befasst sich mit der Durchführung arithmetischer Operationen an Matrixobjekten unter bestimmten Regeln.
Die lineare Transformation ist eine der wichtigsten Anwendungen von Matrizen. Viele wissenschaftliche Bereiche, insbesondere in Bezug auf die Physik, verwenden matrixbezogene Anwendungen.
Das SymPy-Paket verfügt über ein Matrizenmodul, das sich mit der Matrixbehandlung befasst. Es enthält eine Matrixklasse, deren Objekt eine Matrix darstellt.
Note: If you want to execute all the snippets in this chapter individually, you need to import the matrix module as shown below −
>>> from sympy.matrices import MatrixExample
>>> from sympy.matrices import Matrix
>>> m=Matrix([[1,2,3],[2,3,1]])
>>> m
$\displaystyle \left[\begin{matrix}1 & 2 & 3\\2 & 3 & 1\end{matrix}\right]$Bei Ausführung des obigen Befehls in der Python-Shell wird die folgende Ausgabe generiert:
[1 2 3 2 3 1]
Die Matrix wird aus Listenobjekten geeigneter Größe erstellt. Sie können eine Matrix auch erhalten, indem Sie Listenelemente in einer bestimmten Anzahl von Zeilen und Spalten verteilen.
>>> M=Matrix(2,3,[10,40,30,2,6,9])
>>> M
$\displaystyle \left[\begin{matrix}10 & 40 & 30\\2 & 6 & 9\end{matrix}\right]$Bei Ausführung des obigen Befehls in der Python-Shell wird die folgende Ausgabe generiert:
[10 40 30 2 6 9]
Matrix ist ein veränderliches Objekt. Das Matrizenmodul stellt auch die ImmutableMatrix-Klasse zum Erhalten einer unveränderlichen Matrix bereit.
Grundlegende Manipulation
Das shape Die Eigenschaft des Matrix-Objekts gibt seine Größe zurück.
>>> M.shapeDie Ausgabe für den obigen Code lautet wie folgt:
(2,3)
Die Methode row () und col () gibt jeweils eine Zeile oder Spalte mit der angegebenen Nummer zurück.
>>> M.row(0)
$\displaystyle \left[\begin{matrix}10 & 40 & 30\end{matrix}\right]$Die Ausgabe für den obigen Code lautet wie folgt:
[10 40 30]
>>> M.col(1)
$\displaystyle \left[\begin{matrix}40\\6\end{matrix}\right]$Die Ausgabe für den obigen Code lautet wie folgt:
[40 6]
Verwenden Sie den Slice-Operator von Python, um ein oder mehrere Elemente abzurufen, die zu einer Zeile oder Spalte gehören.
>>> M.row(1)[1:3]
[6, 9]Die Matrixklasse verfügt über die Methoden row_del () und col_del (), mit denen die angegebene Zeile / Spalte aus der angegebenen Matrix gelöscht wird.
>>> M=Matrix(2,3,[10,40,30,2,6,9])
>>> M.col_del(1)
>>> MBei Ausführung des obigen Befehls in der Python-Shell wird die folgende Ausgabe generiert:
Matrix([[10, 30],[ 2, 9]])Sie können die Ausgabe mit dem folgenden Befehl mit Stil versehen:
$\displaystyle \left[\begin{matrix}10 & 30\\2 & 9\end{matrix}\right]$Sie erhalten die folgende Ausgabe, nachdem Sie das obige Code-Snippet ausgeführt haben:
[10 30 2 9]
>>> M.row_del(0)
>>> M
$\displaystyle \left[\begin{matrix}2 & 9\end{matrix}\right]$Sie erhalten die folgende Ausgabe, nachdem Sie das obige Code-Snippet ausgeführt haben:
[2 9]
In ähnlicher Weise fügen die Methoden row_insert () und col_insert () Zeilen oder Spalten am angegebenen Zeilen- oder Spaltenindex hinzu
>>> M1=Matrix([[10,30]])
>>> M=M.row_insert(0,M1)
>>> M
$\displaystyle \left[\begin{matrix}10 & 30\\2 & 9\end{matrix}\right]$Sie erhalten die folgende Ausgabe, nachdem Sie das obige Code-Snippet ausgeführt haben:
[10 40 30 2 9]
>>> M2=Matrix([40,6])
>>> M=M.col_insert(1,M2)
>>> M
$\displaystyle \left[\begin{matrix}10 & 40 & 30\\2 & 6 & 9\end{matrix}\right]$Sie erhalten die folgende Ausgabe, nachdem Sie das obige Code-Snippet ausgeführt haben:
[10 40 30 6 9]
Rechenoperationen
Übliche Operatoren +, - und * sind für die Addition, Subtraktion und Multiplikation definiert.
>>> M1=Matrix([[1,2,3],[3,2,1]])
>>> M2=Matrix([[4,5,6],[6,5,4]])
>>> M1+M2
$\displaystyle \left[\begin{matrix}5 & 7 & 9\\9 & 7 & 5\end{matrix}\right]$Sie erhalten die folgende Ausgabe, nachdem Sie das obige Code-Snippet ausgeführt haben:
[5 7 9 9 7 5]
>>> M1-M2
$\displaystyle \left[\begin{matrix}-3 & -3 & -3\\-3 & -3 & -3\end{matrix}\right]$Sie erhalten die folgende Ausgabe, nachdem Sie das obige Code-Snippet ausgeführt haben:
[- 3 -3 -3 -3 -3 -3]
Eine Matrixmultiplikation ist nur möglich, wenn - Die Anzahl der Spalten der 1. Matrix der Anzahl der Zeilen der 2. Matrix entsprechen muss. - Und das Ergebnis hat die gleiche Anzahl von Zeilen wie die 1. Matrix und die gleiche Anzahl von Spalten wie die 2. Matrix.
>>> M1=Matrix([[1,2,3],[3,2,1]])
>>> M2=Matrix([[4,5],[6,6],[5,4]])
>>> M1*M2
$\displaystyle \left[\begin{matrix}31 & 29\\29 & 31\end{matrix}\right]$Die Ausgabe für den obigen Code lautet wie folgt:
[31 29 29 31]
>>> M1.T
$\displaystyle \left[\begin{matrix}1 & 3\\2 & 2\\3 & 1\end{matrix}\right]$Die folgende Ausgabe wird nach Ausführung des Codes erhalten -
[1 3 2 2 3 1]
Verwenden Sie die Methode det (), um eine Determinante der Matrix zu berechnen. Eine Determinante ist ein Skalarwert, der aus den Elementen einer quadratischen Matrix berechnet werden kann
>>> M=Matrix(3,3,[10,20,30,5,8,12,9,6,15])
>>> M
$\displaystyle \left[\begin{matrix}10 & 20 & 30\\5 & 8 & 12\\9 & 6 & 15\end{matrix}\right]$Die Ausgabe für den obigen Code lautet wie folgt:
[10 20 30 5 8 12 9 6 15]
>>> M.det()Die Ausgabe für den obigen Code lautet wie folgt:
-120
Matrixkonstruktoren
SymPy bietet viele spezielle Arten von Matrixklassen. Zum Beispiel Identitätsmatrix, Matrix aller Nullen und Einsen usw. Diese Klassen werden als Auge, Nullen bzw. Einsen bezeichnet. Die Identitätsmatrix ist eine quadratische Matrix, bei der Elemente, die auf die Diagonale fallen, auf 1 gesetzt werden, der Rest der Elemente ist 0.
Example
from sympy.matrices import eye eye(3)Output
Matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]])$\displaystyle \left[\begin{matrix}1 & 0 & 0\\0 & 1 & 0\\0 & 0 & 1\end{matrix}\right]$Die Ausgabe für den obigen Code lautet wie folgt:
[1 0 0 0 1 0 0 0 1]
In der Diag-Matrix werden Elemente auf der Diagonale gemäß den angegebenen Argumenten initialisiert.
>>> from sympy.matrices import diag
>>> diag(1,2,3)
$\displaystyle \left[\begin{matrix}1 & 0 & 0\\0 & 2 & 0\\0 & 0 & 3\end{matrix}\right]$Die Ausgabe für den obigen Code lautet wie folgt:
[1 0 0 0 2 0 0 0 3]
Alle Elemente in der Nullmatrix werden auf 0 initialisiert.
>>> from sympy.matrices import zeros
>>> zeros(2,3)
$\displaystyle \left[\begin{matrix}0 & 0 & 0\\0 & 0 & 0\end{matrix}\right]$Die Ausgabe für den obigen Code lautet wie folgt:
[0 0 0 0 0 0]
In ähnlicher Weise ist one eine Matrix, bei der alle Elemente auf 1 gesetzt sind.
>>> from sympy.matrices import ones
>>> ones(2,3)
$\displaystyle \left[\begin{matrix}1 & 1 & 1\\1 & 1 & 1\end{matrix}\right]$Die Ausgabe für den obigen Code lautet wie folgt:
[1 1 1 1 1 1]
Das Sympy-Paket verfügt über eine Funktionsklasse, die im Modul sympy.core.function definiert ist. Es ist eine Basisklasse für alle angewandten mathematischen Funktionen sowie ein Konstruktor für undefinierte Funktionsklassen.
Folgende Funktionskategorien werden von der Funktionsklasse geerbt -
- Funktionen für komplexe Zahlen
- Trigonometrische Funktionen
- Funktionen für die Ganzzahl
- Kombinatorische Funktionen
- Andere verschiedene Funktionen
Funktionen für komplexe Zahlen
Dieser Funktionssatz ist in definiert sympy.functions.elementary.complexes Modul.
re
Diese Funktion gibt einen Realteil eines Ausdrucks zurück -
>>> from sympy import *
>>> re(5+3*I)Die Ausgabe für das obige Code-Snippet ist unten angegeben -
5
>>> re(I)Die Ausgabe für das obige Code-Snippet lautet -
0
Im
Diese Funktion gibt den Imaginärteil eines Ausdrucks zurück -
>>> im(5+3*I)Die Ausgabe für das obige Code-Snippet ist unten angegeben -
3
>>> im(I)Die Ausgabe für das obige Code-Snippet ist unten angegeben -
1
sign
Diese Funktion gibt das komplexe Vorzeichen eines Ausdrucks zurück.
Für einen echten Ausdruck lautet das Zeichen -
- 1, wenn der Ausdruck positiv ist
- 0, wenn der Ausdruck gleich Null ist
- -1 wenn der Ausdruck negativ ist
Wenn der Ausdruck imaginär ist, lautet das zurückgegebene Zeichen -
- Ich wenn im (Ausdruck) positiv ist
- -Ich wenn im (Ausdruck) negativ ist
>>> sign(1.55), sign(-1), sign(S.Zero)Die Ausgabe für das obige Code-Snippet ist unten angegeben -
(1, -1, 0)
>>> sign (-3*I), sign(I*2)Die Ausgabe für das obige Code-Snippet ist unten angegeben -
(-I, I)
Abs
Diese Funktion gibt den Absolutwert einer komplexen Zahl zurück. Es ist definiert als der Abstand zwischen dem Ursprung (0,0) und dem Punkt (a, b) in der komplexen Ebene. Diese Funktion ist eine Erweiterung der integrierten Funktion abs (), um symbolische Werte zu akzeptieren.
>>> Abs(2+3*I)Die Ausgabe für das obige Code-Snippet ist unten angegeben -
$\sqrt13$
conjugate
Diese Funktion gibt das Konjugat einer komplexen Zahl zurück. Um das komplexe Konjugat zu finden, ändern wir das Vorzeichen des Imaginärteils.
>>> conjugate(4+7*I)Sie erhalten die folgende Ausgabe, nachdem Sie das obige Code-Snippet ausgeführt haben:
4 - 7i
Trigonometrische Funktionen
SymPy hat Definitionen für alle trigonometrischen Verhältnisse - sin cos, tan usw. sowie seine inversen Gegenstücke wie asin, acos, atan usw. Diese Funktionen berechnen den jeweiligen Wert für einen bestimmten Winkel im Bogenmaß.
>>> sin(pi/2), cos(pi/4), tan(pi/6)Die Ausgabe für das obige Code-Snippet ist unten angegeben -
(1, sqrt(2)/2, sqrt(3)/3)
>>> asin(1), acos(sqrt(2)/2), atan(sqrt(3)/3)Die Ausgabe für das obige Code-Snippet ist unten angegeben -
(pi/2, pi/4, pi/6)
Funktionen für die Ganzzahl
Dies ist eine Reihe von Funktionen zum Ausführen verschiedener Operationen für die Ganzzahl.
ceiling
Dies ist eine univariate Funktion, die den kleinsten ganzzahligen Wert nicht weniger als ihr Argument zurückgibt. Bei komplexen Zahlen die Obergrenze des Real- und Imaginärteils getrennt.
>>> ceiling(pi), ceiling(Rational(20,3)), ceiling(2.6+3.3*I)Die Ausgabe für das obige Code-Snippet ist unten angegeben -
(4, 7, 3 + 4*I)
floor
Diese Funktion gibt den größten ganzzahligen Wert zurück, der nicht größer als das Argument ist. Bei komplexen Zahlen nimmt auch diese Funktion den Boden des Real- und Imaginärteils getrennt.
>>> floor(pi), floor(Rational(100,6)), floor(6.3-5.9*I)Die Ausgabe für das obige Code-Snippet ist unten angegeben -
(3, 16, 6 - 6*I)
frac
Diese Funktion repräsentiert den Bruchteil von x.
>>> frac(3.99), frac(Rational(10,3)), frac(10)Die Ausgabe für das obige Code-Snippet ist unten angegeben -
(0.990000000000000, 1/3, 0)
Kombinatorische Funktionen
Die Kombinatorik ist ein Gebiet der Mathematik, das sich mit Problemen der Auswahl, Anordnung und Funktionsweise innerhalb eines endlichen oder diskreten Systems befasst.
factorial
Die Fakultät ist in der Kombinatorik sehr wichtig, da sie die Anzahl der Möglichkeiten angibt, wie n Objekte permutiert werden können. Es wird symbolisch als ð ?? '¥ dargestellt! Diese Funktion ist die Implementierung einer Fakultätsfunktion über nichtnegative ganze Zahlen. Die Fakultät einer negativen ganzen Zahl ist eine komplexe Unendlichkeit.
>>> x=Symbol('x')
>>> factorial(x)Die Ausgabe für das obige Code-Snippet ist unten angegeben -
x!
>>> factorial(5)Die Ausgabe für das obige Code-Snippet ist unten angegeben -
120
>>> factorial(-1)Die Ausgabe für das obige Code-Snippet ist unten angegeben -
$\infty\backsim$
Binomial-
Diese Funktion gibt die Anzahl der Möglichkeiten an, wie wir k Elemente aus einer Menge von n Elementen auswählen können.
>>> x,y=symbols('x y')
>>> binomial(x,y)Die Ausgabe für das obige Code-Snippet ist unten angegeben -
$(\frac{x}{y})$
>>> binomial(4,2)Die Ausgabe für das obige Code-Snippet ist unten angegeben -
6
Mit der Binomialfunktion können Zeilen des Pascalschen Dreiecks erzeugt werden.
>>> for i in range(5): print ([binomial(i,j) for j in range(i+1)])Sie erhalten die folgende Ausgabe, nachdem Sie das obige Code-Snippet ausgeführt haben:
[1]
[1, 1]
[1, 2, 1]
[1, 3, 3, 1]
[1, 4, 6, 4, 1]
fibonacci
Die Fibonacci-Zahlen sind die ganzzahlige Sequenz, die durch die Anfangsterme F0 = 0, F1 = 1 und die Zwei-Term-Wiederholungsrelation Fn = Fnâ1 + Fn2 definiert ist.
>>> [fibonacci(x) for x in range(10)]Die folgende Ausgabe wird nach Ausführung des obigen Codeausschnitts erhalten -
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
tribonacci
Die Tribonacci-Zahlen sind die ganzzahlige Folge, die durch die Anfangsterme F0 = 0, F1 = 1, F2 = 1 und die Drei-Term-Wiederholungsrelation Fn = Fn-1 + Fn-2 + Fn-3 definiert ist.
>>> tribonacci(5, Symbol('x'))Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$x^8 + 3x^5 + 3x^2$
>>> [tribonacci(x) for x in range(10)]Die folgende Ausgabe wird nach Ausführung des obigen Codeausschnitts erhalten -
[0, 1, 1, 2, 4, 7, 13, 24, 44, 81]
Verschiedene Funktionen
Im Folgenden finden Sie eine Liste einiger häufig verwendeter Funktionen.
Min- Gibt den Mindestwert der Liste zurück. Es heißt Min, um Konflikte mit der eingebauten Funktion min zu vermeiden.
Max- Gibt den Maximalwert der Liste zurück. Es heißt Max, um Konflikte mit der eingebauten Funktion max zu vermeiden.
root - Gibt die n-te Wurzel von x zurück.
sqrt - Gibt die Hauptquadratwurzel von x zurück.
cbrt - Diese Funktion berechnet die Hauptwürfelwurzel von x (Verknüpfung für x ++ Rational (1,3)).
Das Folgende sind die Beispiele der obigen verschiedenen Funktionen und ihrer jeweiligen Ausgänge -
>>> Min(pi,E)e
>>> Max(5, Rational(11,2))$\frac{11}{2}$
>>> root(7,Rational(1,2))49
>>> sqrt(2)$\sqrt2$
>>> cbrt(1000)10
In der Mathematik ist das Quaternion-Zahlensystem eine Erweiterung komplexer Zahlen. Jedes Quaternion-Objekt enthält vier skalare Variablen und vier Dimensionen, eine reale Dimension und drei imaginäre Dimensionen.
Quaternion wird durch folgenden Ausdruck dargestellt:
q = a + bi + cj + dk
wo a, b, c und d sind reelle Zahlen und i, j, k sind Quaternionseinheiten, so dass i2 == j2 == k2 == ijk
Das sympy.algebras.quaternion Modul hat Quaternion-Klasse.
>>> from sympy.algebras.quaternion import Quaternion
>>> q=Quaternion(2,3,1,4)
>>> qDas obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$2 + 3i + 1j + 4k$
Quaternionen werden in der reinen Mathematik sowie in der angewandten Mathematik, Computergrafik, Computer Vision usw. verwendet.
>>> from sympy import *
>>> x=Symbol('x')
>>> q1=Quaternion(x**2, x**3, x) >>> q1Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$x^2 + x^3i + xj + 0k$
Quaternionsobjekt kann auch imaginäre Koeffizienten haben
>>> q2=Quaternion(2,(3+2*I), x**2, 3.5*I)
>>> q2Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$2 + (3 + 2i)i + x2j + 3.5ik$
hinzufügen()
Diese in der Quaternion-Klasse verfügbare Methode führt das Hinzufügen von zwei Quaternion-Objekten durch.
>>> q1=Quaternion(1,2,3,4)
>>> q2=Quaternion(4,3,2,1)
>>> q1.add(q2)Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$5 + 5i + 5j + 5k$
Es ist möglich, einem Quaternion-Objekt eine Zahl oder ein Symbol hinzuzufügen.
>>> q1+2Die folgende Ausgabe wird nach Ausführung des obigen Codeausschnitts erhalten -
$3 + 2i + 3j + 4k$
>>> q1+xDie folgende Ausgabe wird nach Ausführung des obigen Codeausschnitts erhalten -
$(x + 1) + 2i + 3j + 4k$
mul ()
Diese Methode führt eine Multiplikation von zwei Quaternionsobjekten durch.
>>> q1=Quaternion(1,2,1,2)
>>> q2=Quaternion(2,4,3,1)
>>> q1.mul(q2)Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$(-11) + 3i + 11j + 7k$
inverse ()
Diese Methode gibt die Umkehrung eines Quaternionsobjekts zurück.
>>> q1.inverse()Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$\frac{1}{10} + (-\frac{1}{5})i + (-\frac{1}{10})j + (-\frac{1}{5})k$
pow ()
Diese Methode gibt die Leistung eines Quaternionsobjekts zurück.
>>> q1.pow(2)Die folgende Ausgabe wird nach Ausführung des obigen Codeausschnitts erhalten -
$(-8) + 4i + 2j + 4k$
exp ()
Diese Methode berechnet das Exponential eines Quaternion-Objekts, dh Gl
>>> q=Quaternion(1,2,4,3)
>>> q.exp()Die folgende Ausgabe wird nach Ausführung des obigen Codeausschnitts erhalten -
$e\cos(\sqrt29) + \frac{2\sqrt29e\sin(\sqrt29)}{29}i + \frac{4\sqrt29e\sin(\sqrt29)}{29}j + \frac{3\sqrt29e\sin}{29}k$
Da die Symbole = und == in Python als Zuweisungs- und Gleichheitsoperatoren definiert sind, können sie nicht zur Formulierung symbolischer Gleichungen verwendet werden. SymPy bietet die Funktion Eq () zum Erstellen einer Gleichung.
>>> from sympy import *
>>> x,y=symbols('x y')
>>> Eq(x,y)Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
x = y
Da x = y genau dann möglich ist, wenn xy = 0 ist, kann die obige Gleichung wie folgt geschrieben werden:
>>> Eq(x-y,0)Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
x − y = 0
Das Solver-Modul in SymPy bietet die Funktion soveset (), deren Prototyp wie folgt lautet:
solveset(equation, variable, domain)Die Domain ist standardmäßig S.Complexes. Mit der Funktion solveset () können wir eine algebraische Gleichung wie folgt lösen:
>>> solveset(Eq(x**2-9,0), x)Die folgende Ausgabe wird erhalten -
{−3, 3}
>>> solveset(Eq(x**2-3*x, -2),x)Die folgende Ausgabe wird nach Ausführung des obigen Codeausschnitts erhalten -
{1,2}
Die Ausgabe von Solveset ist ein FiniteSet der Lösungen. Wenn keine Lösungen vorhanden sind, wird ein EmptySet zurückgegeben
>>> solveset(exp(x),x)Die folgende Ausgabe wird nach Ausführung des obigen Codeausschnitts erhalten -
$\varnothing$
Lineargleichung
Wir müssen die Funktion linsolve () verwenden, um lineare Gleichungen zu lösen.
Zum Beispiel sind die Gleichungen wie folgt:
xy = 4
x + y = 1
>>> from sympy import *
>>> x,y=symbols('x y')
>>> linsolve([Eq(x-y,4),Eq( x + y ,1) ], (x, y))Die folgende Ausgabe wird nach Ausführung des obigen Codeausschnitts erhalten -
$\lbrace(\frac{5}{2},-\frac{3}{2})\rbrace$
Die Funktion linsolve () kann auch lineare Gleichungen lösen, die in Matrixform ausgedrückt werden.
>>> a,b=symbols('a b')
>>> a=Matrix([[1,-1],[1,1]])
>>> b=Matrix([4,1])
>>> linsolve([a,b], (x,y))Wir erhalten die folgende Ausgabe, wenn wir das obige Code-Snippet ausführen -
$\lbrace(\frac{5}{2},-\frac{3}{2})\rbrace$
Nichtlineare Gleichung
Zu diesem Zweck verwenden wir die Funktion nonlinsolve (). Gleichungen für dieses Beispiel -
a 2 + a = 0 ab = 0
>>> a,b=symbols('a b')
>>> nonlinsolve([a**2 + a, a - b], [a, b])Wir erhalten die folgende Ausgabe, wenn wir das obige Code-Snippet ausführen -
$\lbrace(-1, -1),(0,0)\rbrace$
Differentialgleichung
Erstellen Sie zunächst eine undefinierte Funktion, indem Sie cls = Function an die Symbolfunktion übergeben. Verwenden Sie dsolve, um Differentialgleichungen zu lösen.
>>> x=Symbol('x')
>>> f=symbols('f', cls=Function)
>>> f(x)Die folgende Ausgabe wird nach Ausführung des obigen Codeausschnitts erhalten -
f(x)
Hier ist f (x) eine nicht bewertete Funktion. Seine Ableitung ist wie folgt -
>>> f(x).diff(x)Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$\frac{d}{dx}f(x)$
Wir erstellen zuerst ein Gl. Objekt, das der folgenden Differentialgleichung entspricht
>>> eqn=Eq(f(x).diff(x)-f(x), sin(x))
>>> eqnDas obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$-f(x) + \frac{d}{dx}f(x)= \sin(x)$
>>> dsolve(eqn, f(x))Das obige Code-Snippet liefert eine Ausgabe, die dem folgenden Ausdruck entspricht -
$f(x)=(c^1-\frac{e^-xsin(x)}{2}-\frac{e^-xcos(x)}{2})e^x$
SymPy verwendet die Matplotlib-Bibliothek als Backend, um 2D- und 3D-Diagramme mathematischer Funktionen zu rendern. Stellen Sie sicher, dass Matplotlib in der aktuellen Python-Installation verfügbar ist. Wenn nicht, installieren Sie dasselbe mit dem folgenden Befehl:
pip install matplotlibDie Plotunterstützung ist im Modul sympy.plotting definiert. Folgende Funktionen sind im Plotmodul vorhanden -
plot - 2D-Liniendiagramme
plot3d - 3D-Liniendiagramme
plot_parametric - 2D-Parameterdiagramme
plot3d_parametric - 3D-Parameterdiagramme
Die Funktion plot () gibt eine Instanz der Plot-Klasse zurück. Eine Plotfigur kann einen oder mehrere SymPy-Ausdrücke haben. Obwohl Matplotlib als Backend verwendet werden kann, können auch andere Backends wie Texplot, Pyglet oder Google Charts API verwendet werden.
plot(expr, range, kwargs)Dabei ist expr ein gültiger symPy-Ausdruck. Wenn nicht erwähnt, verwendet der Bereich standardmäßig (-10, 10).
Das folgende Beispiel zeigt Werte von x2 für jeden Wert im Bereich (-10,10) -
>>> from sympy.plotting import plot
>>> from sympy import *
>>> x=Symbol('x')
>>> plot(x**2, line_color='red')
Um mehrere Diagramme für denselben Bereich zu zeichnen, geben Sie vor dem Bereichstupel mehrere Ausdrücke an.
>>> plot( sin(x),cos(x), (x, -pi, pi))
Sie können für jeden Ausdruck auch einen eigenen Bereich angeben.
plot((expr1, range1), (expr2, range2))Die folgende Abbildung zeigt sin (x) und cos (x) über verschiedene Bereiche.
>>> plot( (sin(x),(x, -2*pi, 2*pi)),(cos(x), (x, -pi, pi)))
Die folgenden optionalen Schlüsselwortargumente können in der Funktion plot () angegeben werden.
line_color - Gibt die Farbe der Plotlinie an.
title - Eine Zeichenfolge, die als Titel angezeigt werden soll
xlabel - Eine Zeichenfolge, die als Beschriftung für die X-Achse angezeigt werden soll
ylabel - Eine Zeichenfolge, die als Beschriftung für die y-Achse angezeigt werden soll
>>> plot( (sin(x),(x, -2*pi, 2*pi)),(cos(x), (x, -pi, pi)), line_color='red', title='SymPy plot example')
Die Funktion plot3d () rendert ein dreidimensionales Diagramm.
plot3d(expr, xrange, yrange, kwargs)Das folgende Beispiel zeichnet ein 3D-Oberflächendiagramm -
>>> from sympy.plotting import plot3d
>>> x,y=symbols('x y')
>>> plot3d(x*y, (x, -10,10), (y, -10,10))
Wie im 2D-Diagramm kann ein dreidimensionales Diagramm auch mehrere Diagramme mit jeweils unterschiedlichen Bereichen enthalten.
>>> plot3d(x*y, x/y, (x, -5, 5), (y, -5, 5))
Die Funktion plot3d_parametric_line () rendert ein dreidimensionales parametrisches Liniendiagramm.
>>> from sympy.plotting import plot3d_parametric_line
>>> plot3d_parametric_line(cos(x), sin(x), x, (x, -5, 5))
Verwenden Sie zum Zeichnen eines parametrischen Flächendiagramms die Funktion plot3d_parametric_surface ().
plot3d_parametric_surface(xexpr, yexpr, zexpr, rangex, rangey, kwargs)
>>> from sympy.plotting import plot3d_parametric_surface
>>> plot3d_parametric_surface(cos(x+y), sin(x-y), x-y, (x, -5, 5), (y, -5, 5))
Das Geometriemodul in SymPy ermöglicht die Erstellung zweidimensionaler Objekte wie Linie, Kreis usw. Anschließend können wir Informationen darüber abrufen, z. B. die Kolinearität überprüfen oder Schnittpunkte finden.
Punkt
Die Punktklasse repräsentiert einen Punkt im euklidischen Raum. Das folgende Beispiel überprüft die Kollinearität von Punkten -
>>> from sympy.geometry import Point
>>> from sympy import *
>>> x=Point(0,0)
>>> y=Point(2,2)
>>> z=Point(4,4)
>>> Point.is_collinear(x,y,z)Output
True
>>> a=Point(2,3)
>>> Point.is_collinear(x,y,a)Output
False
Die distance () -Methode der Punktklasse berechnet die Entfernung zwischen zwei Punkten
>>> x.distance(y)Output
$2\sqrt2$
Die Entfernung kann auch in Form von Symbolen dargestellt werden.
Linie
Die Linienentität wird aus zwei Punktobjekten erhalten. Die Methode intersection () gibt den Schnittpunkt zurück, wenn sich zwei Linien schneiden.
>>> from sympy.geometry import Point, Line
>>> p1, p2=Point(0,5), Point(5,0)
>>> l1=Line(p1,p2)
>>> l2=Line(Point(0,0), Point(5,5))
>>> l1.intersection(l2)Output
[Point2D(5/2, 5/2)]
>>> l1.intersection(Line(Point(0,0), Point(2,2)))Output
[Point2D(5/2, 5/2)]
>>> x,y=symbols('x y')
>>> p=Point(x,y)
>>> p.distance(Point(0,0))Output
$\sqrt{x^2 + y^2}$
Dreieck
Diese Funktion erstellt ein Dreieck aus drei Punktobjekten.
Triangle(a,b,c)
>>> t=Triangle(Point(0,0),Point(0,5), Point(5,0))
>>> t.areaOutput
$-\frac{25}{2}$
Ellipse
Eine elliptische Geometrieeinheit wird konstruiert, indem ein Punktobjekt übergeben wird, das der Mitte und jeweils zwei Zahlen für den horizontalen und vertikalen Radius entspricht.
ellipse(center, hradius, vradius)
>>> from sympy.geometry import Ellipse, Line
>>> e=Ellipse(Point(0,0),8,3)
>>> e.areaOutput
$24\pi$
Der Vradius kann indirekt unter Verwendung eines Exzentrizitätsparameters bereitgestellt werden.
>>> e1=Ellipse(Point(2,2), hradius=5, eccentricity=Rational(3,4))
>>> e1.vradiusOutput
$\frac{5\sqrt7}{4}$
Das apoapsis der Ellipse ist der größte Abstand zwischen Fokus und Kontur.
>>> e1.apoapsisOutput
$\frac{35}{4}$
Die folgende Anweisung berechnet den Umfang der Ellipse -
>>> e1.circumferenceOutput
$20E(\frac{9}{16})$
Das equation Die Ellipsenmethode gibt die Ellipsengleichung zurück.
>>> e1.equation(x,y)Output
$(\frac{x}{5}-\frac{2}{5})^2 + \frac{16(y-2)2}{175} - 1$
In der Mathematik ist eine Menge eine genau definierte Sammlung verschiedener Objekte, die Zahlen, Personen, Buchstaben des Alphabets oder sogar andere Mengen sein können. Set ist auch einer der in Python integrierten Typen. SymPy bietet ein Set-Modul. Es enthält Definitionen verschiedener Mengenarten und verfügt über Funktionen zum Ausführen von Mengenoperationen wie Schnittmenge, Vereinigung usw.
Set ist eine Basisklasse für jeden anderen Set-Typ in SymPy. Beachten Sie, dass es sich vom integrierten Satzdatentyp von Python unterscheidet. Die Intervallklasse stellt reale Intervalle dar und ihre Randeigenschaft gibt a zurückFiniteSet Objekt.
>>> from sympy import Interval
>>> s=Interval(1,10).boundary
>>> type(s)sympy.sets.sets.FiniteSet
FiniteSet ist eine Sammlung diskreter Zahlen. Es kann von jedem Sequenzobjekt wie Liste oder Zeichenfolge abgerufen werden.
>>> from sympy import FiniteSet
>>> FiniteSet(range(5))Output
$\lbrace\lbrace0,1,...,4\rbrace\rbrace$
>>> numbers=[1,3,5,2,8]
>>> FiniteSet(*numbers)Output
$\lbrace1,2,3,5,8\rbrace$
>>> s="HelloWorld"
>>> FiniteSet(*s)Output
{H,W,d,e,l,o,r}
Beachten Sie, dass SymPy's Set wie das integrierte Set auch eine Sammlung unterschiedlicher Objekte ist.
ConditionSet ist eine Reihe von Elementen, die eine bestimmte Bedingung erfüllen
>>> from sympy import ConditionSet, Eq, Symbol
>>> x=Symbol('x')
>>> s=ConditionSet(x, Eq(x**2-2*x,0), Interval(1,10)) >>> sOutput
$\lbrace x\mid x\in[1,10]∧x^2 - 2x =0\rbrace$
Unionist eine zusammengesetzte Menge. Es enthält alle Elemente in zwei Sätzen. Beachten Sie, dass Elemente, die in beiden enthalten sind, in der Union nur einmal vorkommen.
>>> from sympy import Union
>>> l1=[3,1,5,7]
>>> l2=[9,7,2,1]
>>> a=FiniteSet(*l1)
>>> b=FiniteSet(*l2)
>>> Union(a,b)Intersection enthält andererseits nur die Elemente, die in beiden vorhanden sind.
>>> from sympy import Intersection
>>> Intersection(a,b)ProductSet Objekt repräsentiert kartesisches Produkt von Elementen in beiden Mengen.
>>> from sympy import ProductSet
>>> l1=[1,2]
>>> l2=[2,3]
>>> a=FiniteSet(*l1)
>>> b=FiniteSet(*l2)
>>> set(ProductSet(a,b))Complement(a,b) behält Elemente in a mit Ausnahme von Elementen bei, die mit b set gemeinsam sind.
>>> from sympy import Complement
>>> l1=[3,1,5,7]
>>> l2=[9,7,2,1]
>>> a=FiniteSet(*l1)
>>> b=FiniteSet(*l2)
>>> Complement(a,b), Complement(b,a)SymmetricDifference Set enthält nur ungewöhnliche Elemente in beiden Sets.
>>> from sympy import SymmetricDifference
>>> l1=[3,1,5,7]
>>> l2=[9,7,2,1]
>>> a=FiniteSet(*l1)
>>> b=FiniteSet(*l2)
>>> SymmetricDifference(a,b)Output
{2,3,5,9}
In SymPy sind mehrere Drucker verfügbar. Es folgt eine unvollständige Liste -
- str
- srepr
- ASCII hübscher Drucker
- Hübscher Unicode-Drucker
- LaTeX
- MathML
- Dot
SymPy-Objekte können auch als Ausgabe an Code verschiedener Sprachen wie C, Fortran, Javascript, Theano und Python gesendet werden.
SymPy verwendet Unicode-Zeichen, um die Ausgabe in Form eines hübschen Drucks zu rendern. Wenn Sie die Python-Konsole zum Ausführen einer SymPy-Sitzung verwenden, wird die beste hübsche Druckumgebung durch Aufrufen der Funktion init_session () aktiviert.
>>> from sympy import init_session
>>> init_session()IPython-Konsole für SymPy 1.5.1 (Python 3.7.4-64-Bit) (Bodentypen: Python).
Diese Befehle wurden ausgeführt -
>>> from __future__ import division
>>> from sympy import *
>>> x, y, z, t = symbols('x y z t')
>>> k, m, n = symbols('k m n', integer=True)
>>> f, g, h = symbols('f g h', cls=Function)
>>> init_printing()Dokumentation finden Sie unter https://docs.sympy.org/1.5.1/.
>>> Integral(sqrt(1/x),x)$\int \sqrt\frac{1}{x} dx$
Wenn LATEX nicht installiert ist, Matplotlib jedoch installiert ist, wird die Matplotlib-Rendering-Engine verwendet. Wenn Matplotlib nicht installiert ist, wird der hübsche Unicode-Drucker verwendet. Jupyter Notebook verwendet jedoch MathJax, um LATEX zu rendern.
In einem Terminal, das Unicode nicht unterstützt, wird ein hübscher ASCII-Drucker verwendet.
Verwenden Sie zur Verwendung des ASCII-Druckers die Funktion pprint (), wobei die Eigenschaft use_unicode auf False festgelegt ist
>>> pprint(Integral(sqrt(1/x),x),use_unicode=False)
Auf den Unicode Pretty-Drucker kann auch über pprint () und Pretty () zugegriffen werden. Wenn das Terminal Unicode unterstützt, wird es automatisch verwendet. Wenn pprint () nicht erkennen kann, dass das Terminal Unicode unterstützt, können Sie use_unicode = True übergeben, um die Verwendung von Unicode zu erzwingen.
Verwenden Sie die Funktion latex (), um die LATEX-Form eines Ausdrucks zu erhalten.
>>> print(latex(Integral(sqrt(1/x),x)))\int \sqrt{\frac{1}{x}}\, dx
Sie können auch einen Mathml-Drucker verwenden. Importieren Sie zu diesem Zweck die Funktion print_mathml. Eine String-Version wird durch die Funktion mathml () erhalten.
>>> from sympy.printing.mathml import print_mathml
>>> print_mathml(Integral(sqrt(1/x),x))<apply>
<int/>
<bvar>
<ci>x</ci>
</bvar>
<apply>
<root/>
<apply>
<power/>
<ci>x</ci>
<cn>-1</cn>
</apply>
</apply>
</apply>
>>>mathml(Integral(sqrt(1/x),x))'<apply><int/><bvar><ci>x</ci></bvar><apply><root/><apply><power/><ci>x</ci><cn>-1</cn></apply></apply></apply>'