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

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

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 :ref:`section-precedence` 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)

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

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)
    <type 'sage.rings.integer.Integer'>
    sage: a = 5/3  # jetzt ist a eine rationale Zahl
    sage: type(a)
    <type 'sage.rings.rational.Rational'>
    sage: a = 'hello'  # jetzt ist a ein String
    sage: type(a)
    <type '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.

Für Verwirrung in Python sorgt häufig, dass Integer Literale, die mit
Null beginnen als Oktalzahl, d.h. als Zahl zur Basis 8, behandelt werden.

::

    sage: 011
    9
    sage: 8 + 1
    9
    sage: n = 011
    sage: n.str(8)   # Darstellung von n als String zur Basis 8
    '11'

Dies ist konsistent mit der Programmiersprache C.
