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

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

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)

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

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

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.