Zuweisung, Gleichheit und Arithmetik¶
Bis auf wenige Ausnahmen benutzt Sage die Programmiersprache Python, deshalb werden Ihnen die meisten einführenden Bücher über Python dabei helfen Sage zu lernen.
Sage benutzt = für Zuweisungen und ==, <=, >=,
< und > für Vergleiche.
sage: a = 5
sage: a
5
sage: 2 == 2
True
sage: 2 == 3
False
sage: 2 < 3
True
sage: a == 5
True
>>> from sage.all import *
>>> a = Integer(5)
>>> a
5
>>> Integer(2) == Integer(2)
True
>>> Integer(2) == Integer(3)
False
>>> Integer(2) < Integer(3)
True
>>> a == Integer(5)
True
a = 5 a 2 == 2 2 == 3 2 < 3 a == 5
Sage unterstützt alle grundlegenden mathematischen Operationen:
sage: 2**3 # ** bedeutet hoch
8
sage: 2^3 # ^ ist ein Synonym für ** (anders als in Python)
8
sage: 10 % 3 # für ganzzahlige Argumente bedeutet % mod, d.h. Restbildung
1
sage: 10/4
5/2
sage: 10//4 # für ganzzahlige Argumente gibt // den \
....: # ganzzahligen Quotienten zurück
2
sage: 4 * (10 // 4) + 10 % 4 == 10
True
sage: 3^2*4 + 2%5
38
>>> from sage.all import *
>>> Integer(2)**Integer(3) # ** bedeutet hoch
8
>>> Integer(2)**Integer(3) # ^ ist ein Synonym für ** (anders als in Python)
8
>>> Integer(10) % Integer(3) # für ganzzahlige Argumente bedeutet % mod, d.h. Restbildung
1
>>> Integer(10)/Integer(4)
5/2
>>> Integer(10)//Integer(4) # für ganzzahlige Argumente gibt // den \
... # ganzzahligen Quotienten zurück
2
>>> Integer(4) * (Integer(10) // Integer(4)) + Integer(10) % Integer(4) == Integer(10)
True
>>> Integer(3)**Integer(2)*Integer(4) + Integer(2)%Integer(5)
38
2**3 # ** bedeutet hoch
2^3 # ^ ist ein Synonym für ** (anders als in Python)
10 % 3 # für ganzzahlige Argumente bedeutet % mod, d.h. Restbildung
10/4
10//4 # für ganzzahlige Argumente gibt // den \
# ganzzahligen Quotienten zurück
4 * (10 // 4) + 10 % 4 == 10
3^2*4 + 2%5
Die Berechnung eines Ausdrucks wie 3^2*4 + 2%5 hängt von der
Reihenfolge ab, in der die Operationen ausgeführt werden. Dies wird in
der „Operatorrangfolge-Tabelle“ in Binäre arithmetische Operatorrangfolge festgelegt.
Sage stellt auch viele bekannte mathematische Funktionen zur Verfügung; hier sind nur ein paar Beispiele
sage: sqrt(3.4)
1.84390889145858
sage: sin(5.135)
-0.912021158525540
sage: sin(pi/3)
1/2*sqrt(3)
>>> from sage.all import *
>>> sqrt(RealNumber('3.4'))
1.84390889145858
>>> sin(RealNumber('5.135'))
-0.912021158525540
>>> sin(pi/Integer(3))
1/2*sqrt(3)
sqrt(3.4) sin(5.135) sin(pi/3)
Wie das letzte Beispiel zeigt, geben manche mathematische Ausdrücke
‚exakte‘ Werte anstelle von numerischen Approximationen zurück. Um
eine numerische Approximation zu bekommen, können Sie entweder die
Funktion n oder die Methode n verwenden (beide haben auch
den längeren Namen, numerical_approx, und die Funktion N ist
die gleiche wie n). Diese nehmen auch die optionalen Argumente
prec, welches die gewünschte Anzahl von Bit an Genauigkeit ist und
digits, welches die gewünschte Anzahl Dezimalstellen an Genauigkeit
ist, entgegen; der Standardwert ist 53 Bit Genauigkeit.
sage: exp(2)
e^2
sage: n(exp(2))
7.38905609893065
sage: sqrt(pi).numerical_approx()
1.77245385090552
sage: sin(10).n(digits=5)
-0.54402
sage: N(sin(10),digits=10)
-0.5440211109
sage: numerical_approx(pi, prec=200)
3.1415926535897932384626433832795028841971693993751058209749
>>> from sage.all import *
>>> exp(Integer(2))
e^2
>>> n(exp(Integer(2)))
7.38905609893065
>>> sqrt(pi).numerical_approx()
1.77245385090552
>>> sin(Integer(10)).n(digits=Integer(5))
-0.54402
>>> N(sin(Integer(10)),digits=Integer(10))
-0.5440211109
>>> numerical_approx(pi, prec=Integer(200))
3.1415926535897932384626433832795028841971693993751058209749
exp(2) n(exp(2)) sqrt(pi).numerical_approx() sin(10).n(digits=5) N(sin(10),digits=10) numerical_approx(pi, prec=200)
Python ist dynamisch typisiert, also ist dem Wert, auf den jede Variable weist, ein Typ zugeordnet; jedoch darf eine Variable Werte eines beliebigen Python-Typs innerhalb eines Sichtbarkeitsbereich aufnehmen.
sage: a = 5 # a ist eine ganze Zahl
sage: type(a)
<class 'sage.rings.integer.Integer'>
sage: a = 5/3 # jetzt ist a eine rationale Zahl
sage: type(a)
<class 'sage.rings.rational.Rational'>
sage: a = 'hello' # jetzt ist a ein String
sage: type(a)
<... 'str'>
>>> from sage.all import *
>>> a = Integer(5) # a ist eine ganze Zahl
>>> type(a)
<class 'sage.rings.integer.Integer'>
>>> a = Integer(5)/Integer(3) # jetzt ist a eine rationale Zahl
>>> type(a)
<class 'sage.rings.rational.Rational'>
>>> a = 'hello' # jetzt ist a ein String
>>> type(a)
<... 'str'>
a = 5 # a ist eine ganze Zahl type(a) a = 5/3 # jetzt ist a eine rationale Zahl type(a) a = 'hello' # jetzt ist a ein String type(a)
Die Programmiersprache C, welche statisch typisiert ist, unterscheidet sich hierzu stark; eine Variable, die dazu deklariert ist eine Ganzzahl (int) aufzunehmen, kann in ihrem Sichtbarkeitsbereich auch nur ganze Zahlen aufnehmen.