Programmierung¶

Sage-Dateien Laden und Anhängen¶

Als nächstes zeigen wir wie man Programme, die einer separaten Datei geschrieben wurden in Sage lädt. Erstellen Sie eine Datei, welche Sie beispiel.sage nennen mit folgendem Inhalt:

print("Hello World")
print(2^3)

Sie können beispiel.sage einlesen und ausführen, indem Sie den load-Befehl verwenden.

Sage

sage: load("beispiel.sage")
Hello World
8

Python

>>> from sage.all import *
>>> load("beispiel.sage")
Hello World
8

Sage Live

load("beispiel.sage")

Sie können auch eine Sage-Datei an eine laufende Sitzung anhängen, indem Sie den attach-Befehl verwenden:

Sage

sage: attach("beispiel.sage")
Hello World
8

Python

>>> from sage.all import *
>>> attach("beispiel.sage")
Hello World
8

Sage Live

attach("beispiel.sage")

Wenn Sie nun beispiel.sage verändern und eine Leerzeile in Sage eingeben (d.h. return drücken) wird der Inhalt von beispiel.sage automatisch in Sage neu geladen.

Insbesondere lädt der attach-Befehl eine Datei jedesmal, wenn diese verändert wird automatisch neu, was beim Debuggen von Code nützlich sein kann, wobei der load-Befehl eine Datei nur einmal lädt.

Wenn Sage die Datei beispiel.sage lädt, wird sie zu Python-Code konvertiert, welcher dann vom Python-Interpreter ausgeführt wird. Diese Konvertierung ist geringfügig; sie besteht hautsächlich daraus Integer-Literale mit Integer() und Fließkomma-Literale mit RealNumber() zu versehen, ^ durch ** zu ersetzen und z.B. R.2 durch R.gen(2) auszutauschen. Die konvertierte Version von beispiel.sage befindet sich im gleichen Verzeichnis wie beispiel.sage und ist beispiel.sage.py genannt. Diese Datei enthält den folgenden Code:

print("Hello World")
print(Integer(2)**Integer(3))

Integer-Literale wurden mit Integer() versehen und das ^ wurde durch ein ** ersetzt. (In Python bedeutet ^ „exklusives oder“ und ** bedeutet „Exponentiation“.)

Dieses „preparsing“ ist in sage/misc/interpreter.py implementiert.)

Sie können mehrzeiligen eingerückten Code in Sage einfügen, solange Zeilenenden neue Blöcke kenntlich machen (dies ist in Dateien nicht notwendig). Jedoch beseht die beste Möglichkeit solchen Code in Sage einzufügen darin, diesen in einer Datei zu speichern und attach wie oben beschrieben zu verwenden.

Kompilierten Code erzeugen¶

Geschwindigkeit ist bei mathematischen Berechnungen äußerst wichtig. Python ist zwar eine komfortable Programmiersprache mit sehr hohen Abstraktionsniveau, jedoch können bestimmte Berechnungen mehrere Größenordnungen schneller als in Python sein, wenn sie in einer kompilierten Sprache mit statischen Datentypen implementiert wurden. Manche Teile von Sage würden zu langsam sein, wenn sie komplett in Python geschrieben wären. Um dies zu berücksichtigen unterstützt Sage eine kompilierte „Version“ von Python, welche Cython ([Cyt] und [Pyr]) genannt wird. Cython ist gleichzeitig sowohl zu Python, als auch zu C ähnlich. Die meisten von Pythons Konstruktionen, einschließlich „list comprehensions“, bedingte Ausdrücke und Code wie += sind erlaubt; Sie können auch Code importieren, den Sie in anderen Python-Modulen geschrieben haben. Darüberhinaus können Sie beliebige C Variablen definieren und beliebe C-Bibliothekaufrufe direkt ausführen. Der daraus entstehende Code wird nach C konvertiert und mithilfe eines C-Compilers kompiliert.

Um eigenen kompilierten Sagecode zu erstellen, geben Sie der Datei eine .spyx Endung (anstelle von .sage). Falls Sie mit der Kommandozeile arbeiten, können Sie kompilierten Code genau wie interpretierten Code anhängen und laden. (Im Moment wird das Anhängen von Cythoncode vom Notebook aus nicht unterstützt). Die tatsächliche Kompilierung wird „hinter den Kulissen“ durchgeführt ohne dass Sie explizit etwas tun müssen. Die komplierte „shared object library“ wird unter $HOME/.sage/temp/hostname/pid/spyx gespeichert. Diese Dateien werden gelöscht wenn Sie Sage beenden.

Auf spyx-Dateien wird kein „preparsing“ angewendet, d.h. 1/3 wird in einer spyx-Datei zu 0 ausgewertet, anstelle der rationalen Zahl $1/3$. Wenn foo eine Funktion in der Sage-Bibliothek ist die Sie verwenden möchten, müssen Sie sage.all importieren und sage.all.foo benutzen.

import sage.all
def foo(n):
    return sage.all.factorial(n)

Auf C-Funktionen in separaten Dateien zugreifen¶

Es ist auch nicht schwer auf C-Funktions zuzugreifen welche in separaten *.c Dateien definiert sind. Hier ist ein Beispiel. Erzeugen Sie die Dateien test.c und test.spyx in dem gleichen Verzeichnis mit den Inhalten:

Der reine C-Code: test.c

int add_one(int n) {
  return n + 1;
}

Der Cython-Code: test.spyx:

cdef extern from "test.c":
    int add_one(int n)

def test(n):
    return add_one(n)

Dann funktioniert das Folgende:

Sage

sage: attach("test.spyx")
Compiling (...)/test.spyx...
sage: test(10)
11

Python

>>> from sage.all import *
>>> attach("test.spyx")
Compiling (...)/test.spyx...
>>> test(Integer(10))
11

Sage Live

attach("test.spyx")
test(10)

Wenn die zusätzliche Bibliothek foo gebraucht wird um den C-Code, der aus einer Cython-Datei generiert wurde zu kompilieren, fügen Sie die Zeile clib foo zu dem Cython-Quellcode hinzu. Auf ähnliche Weise kann eine zusätzliche Datei bar zu der Kompilierung mit der Deklaration cfile bar hinzugefügt werden.

eigenständige Python/Sage Skripte¶

Das folgende eigenständige Sageskript faktorisiert ganze Zahlen, Polynome, usw.:

#!/usr/bin/env sage

import sys

if len(sys.argv) != 2:
    print("Usage: %s <n>" % sys.argv[0])
    print("Outputs the prime factorization of n.")
    sys.exit(1)

print(factor(sage_eval(sys.argv[1])))

Um dieses Skript benutzen zu können muss SAGE_ROOT in ihrer PATH-Umgebungsvariable enthalten sein. Falls das das obige Skript factor genannt wurde, ist hier ein beispielhafter Aufruf:

bash $ ./factor 2006
2 * 17 * 59

Dictionaries¶

Ein Dictionary (manchmal auch assoziativer Array genannt) ist eine Abbildung von ‚hashbaren‘ Objekten (z.B. Strings, Zahlen und Tupel; Lesen Sie die Python documentation http://docs.python.org/tut/node7.html und http://docs.python.org/lib/typesmapping.html für weitere Details) zu beliebigen Objekten.

Sage

sage: d = {1:5, 'sage':17, ZZ:GF(7)}
sage: type(d)
<... 'dict'>
sage: list(d.keys())
[1, 'sage', Integer Ring]
sage: d['sage']
17
sage: d[ZZ]
Finite Field of size 7
sage: d[1]
5

Python

>>> from sage.all import *
>>> d = {Integer(1):Integer(5), 'sage':Integer(17), ZZ:GF(Integer(7))}
>>> type(d)
<... 'dict'>
>>> list(d.keys())
[1, 'sage', Integer Ring]
>>> d['sage']
17
>>> d[ZZ]
Finite Field of size 7
>>> d[Integer(1)]
5

Sage Live

d = {1:5, 'sage':17, ZZ:GF(7)}
type(d)
list(d.keys())
d['sage']
d[ZZ]
d[1]

Der dritte „key“ zeigt, dass Indizes eines Dictionaries kompliziert, also beispielsweise der Ring der ganzen Zahlen, sein können.

Sie können das obige Dictionary auch in eine Liste mit den gleichen Daten umwandeln:

Sage

sage: list(d.items())
[(1, 5), ('sage', 17), (Integer Ring, Finite Field of size 7)]

Python

>>> from sage.all import *
>>> list(d.items())
[(1, 5), ('sage', 17), (Integer Ring, Finite Field of size 7)]

Sage Live

list(d.items())

Eine häufig vorkommende Ausdrucksweise ist über einem Paar in einem Dictionary zu iterieren:

Sage

sage: d = {2:4, 3:9, 4:16}
sage: [a*b for a, b in d.items()]
[8, 27, 64]

Python

>>> from sage.all import *
>>> d = {Integer(2):Integer(4), Integer(3):Integer(9), Integer(4):Integer(16)}
>>> [a*b for a, b in d.items()]
[8, 27, 64]

Sage Live

d = {2:4, 3:9, 4:16}
[a*b for a, b in d.items()]

Ein Dictionary ist ungeordnet, wie die letzte Ausgabe verdeutlicht.

Mengen¶

Python hat einen standardmäßigen Mengen-Datentyp. Sein Hauptmerkmal ist, neben weiteren typischen Mengenoperationen, dass das Nachschlagen ob ein Element zu der Menge gehört oder nicht, sehr schnell geht.

Sage

sage: X = set([1,19,'a']);   Y = set([1,1,1, 2/3])
sage: X   # random sort order
{1, 19, 'a'}
sage: X == set(['a', 1, 1, 19])
True
sage: Y
{2/3, 1}
sage: 'a' in X
True
sage: 'a' in Y
False
sage: X.intersection(Y)
{1}

Python

>>> from sage.all import *
>>> X = set([Integer(1),Integer(19),'a']);   Y = set([Integer(1),Integer(1),Integer(1), Integer(2)/Integer(3)])
>>> X   # random sort order
{1, 19, 'a'}
>>> X == set(['a', Integer(1), Integer(1), Integer(19)])
True
>>> Y
{2/3, 1}
>>> 'a' in X
True
>>> 'a' in Y
False
>>> X.intersection(Y)
{1}

Sage Live

X = set([1,19,'a']);   Y = set([1,1,1, 2/3])
X   # random sort order
X == set(['a', 1, 1, 19])
Y
'a' in X
'a' in Y
X.intersection(Y)

Sage besitzt auch einen eigenen Mengen-Datentyp, welcher (manchmal) mit Hilfe des standardmäßigen Python-Mengen-Datentyps implementiert ist, jedoch darüberhinaus manche Sage-spezifischen Funktionen aufweist. Sie können eine Sage-Menge erzeugen indem Sie Set(...) verwenden. Zum Beispiel,

Sage

sage: X = Set([1,19,'a']);   Y = Set([1,1,1, 2/3])
sage: X   # random sort order
{'a', 1, 19}
sage: X == Set(['a', 1, 1, 19])
True
sage: Y
{1, 2/3}
sage: X.intersection(Y)
{1}
sage: print(latex(Y))
\left\{1, \frac{2}{3}\right\}
sage: Set(ZZ)
Set of elements of Integer Ring

Python

>>> from sage.all import *
>>> X = Set([Integer(1),Integer(19),'a']);   Y = Set([Integer(1),Integer(1),Integer(1), Integer(2)/Integer(3)])
>>> X   # random sort order
{'a', 1, 19}
>>> X == Set(['a', Integer(1), Integer(1), Integer(19)])
True
>>> Y
{1, 2/3}
>>> X.intersection(Y)
{1}
>>> print(latex(Y))
\left\{1, \frac{2}{3}\right\}
>>> Set(ZZ)
Set of elements of Integer Ring

Sage Live

X = Set([1,19,'a']);   Y = Set([1,1,1, 2/3])
X   # random sort order
X == Set(['a', 1, 1, 19])
Y
X.intersection(Y)
print(latex(Y))
Set(ZZ)

Iteratoren¶

Iteratoren sind seit Version 2.2 ein Teil von Python und erweisen sich in mathematischen Anwendungen als besonders nützlich. Wir geben hier ein paar Beispiele an; Lesen Sie [PyT] um weitere Details zu erfahren. Wir erstellen einen Iterator über die Quadrate der nichtnegativen ganzen Zahlen bis $10000000$.

Sage

sage: v = (n^2 for n in range(10000000))
sage: next(v)
0
sage: next(v)
1
sage: next(v)
4

Python

>>> from sage.all import *
>>> v = (n**Integer(2) for n in range(Integer(10000000)))
>>> next(v)
0
>>> next(v)
1
>>> next(v)
4

Sage Live

v = (n^2 for n in range(10000000))
next(v)
next(v)
next(v)

Nun erzeugen wir einen Iterator über den Primzahlen der Form $4p+1$ wobei auch $p$ prim ist und schauen uns die ersten Werte an.

Sage

sage: w = (4*p + 1 for p in Primes() if is_prime(4*p+1))
sage: w         # in the next line, 0xb0853d6c is a random 0x number
<generator object at 0xb0853d6c>
sage: next(w)
13
sage: next(w)
29
sage: next(w)
53

Python

>>> from sage.all import *
>>> w = (Integer(4)*p + Integer(1) for p in Primes() if is_prime(Integer(4)*p+Integer(1)))
>>> w         # in the next line, 0xb0853d6c is a random 0x number
<generator object at 0xb0853d6c>
>>> next(w)
13
>>> next(w)
29
>>> next(w)
53

Sage Live

w = (4*p + 1 for p in Primes() if is_prime(4*p+1))
w         # in the next line, 0xb0853d6c is a random 0x number
next(w)
next(w)
next(w)

Bestimmte Ringe, z. B. endliche Körper und die ganzen Zahlen, haben zugehörige Iteratoren:

Sage

sage: [x for x in GF(7)]
[0, 1, 2, 3, 4, 5, 6]
sage: W = ((x,y) for x in ZZ for y in ZZ)
sage: next(W)
(0, 0)
sage: next(W)
(0, 1)
sage: next(W)
(0, -1)

Python

>>> from sage.all import *
>>> [x for x in GF(Integer(7))]
[0, 1, 2, 3, 4, 5, 6]
>>> W = ((x,y) for x in ZZ for y in ZZ)
>>> next(W)
(0, 0)
>>> next(W)
(0, 1)
>>> next(W)
(0, -1)

Sage Live

[x for x in GF(7)]
W = ((x,y) for x in ZZ for y in ZZ)
next(W)
next(W)
next(W)

Programmierung¶

Sage-Dateien Laden und Anhängen¶

Kompilierten Code erzeugen¶

Auf C-Funktionen in separaten Dateien zugreifen¶

eigenständige Python/Sage Skripte¶

Datentypen¶

Listen, Tupel, und Folgen¶

Dictionaries¶

Mengen¶

Iteratoren¶

Schleifen, Funktionen, Kontrollstrukturen und Vergleiche¶

Profiling¶