Vorsicht: bei den untenstehenden Beispielen wird nur jeweils das Ergebnis der letzten Zeile einer Box tatsächlich ausgegeben! Zum Experimentieren Befehle jeweils in eigene Boxen kopieren oder Box mit der Tastenkombination STRG plus ; in mehrere Boxen zerteilen und einzeln ausführen. STRG plus BACKSPACE verbindet zwei Boxen wieder.

<br/>
Um eigene Worksheets mit Text und Beschreibungen zu ergänzen, im Sage Notebook einfach oben rechts auf "Edit" klicken. HTML kann zur Formatierung verwendet werden, ebenso LaTeX für Formeln (Mathe-Umgebung wie gewohnt verwenden). Die Sage-Boxen sind in der Text-Ansicht mit geschwungenen Klammern begrenzt.

<h1>Datentypen</h1>

<h2>Zahlen</h2>

<h3>Ganzzahlen</h3>

Sage kann mit beliebig großen ganzen Zahlen umgehen. Die Datentyp dazu heißt "Integer" (Beschreibung "Integer Ring").

{{{id=1|
a = 1234 + 2^1000
type(a)
parent(a)
///
}}}

Die Funktionen "type" und "parent" geben für beliebige Variablen deren internen Datentyp an. 
Neben dem Datentyp kann man auch testen, ob eine gewisse Variable $x$ (unabhängig vom Datentyp) eine ganze Zahl im mathematischen Sinne ist, d.h. $x \in \mathbb{Z}$:

{{{id=9|
x = 6/3
y = 1/3
z = sqrt(4)
x in ZZ; y in ZZ; z in ZZ
///
}}}

Einige praktische Funktionen im Zusammenhang mit Primzahlen und Teilbarkeit:

{{{id=12|
a = 23452345417985
factor(a)
is_prime(a)
next_prime(a)
abs(a - next_prime(a))
gcd(a, x)
divisors(a)
///
}}}

Einige Funktionen erlauben sowohl die Schreibweise var.fun() als auch fun(var), zum Beispiel:

{{{id=14|
factor(a)
a.factor()
///
}}}

Ziffern (binär, dezimal, ...) einer Zahl:

{{{id=17|
a.digits()
len(a.digits())
sum(a.digits())
a.digits(base=2)
///
}}}

Wenn nicht genau sicher ist, wie eine Funktion heißt, gibt es mit der Tabulator-Taste eine Autovervollständigung bzw. eine Liste passender Funktionen (z.B. div<tab>, a.<tab> für eine Liste der möglichen Funktionen von Variable a). Die Dokumentation zu einer Funktion (kurze Beschreibung, mögliche Parameter, Beispiele) erhält man mit ?:

{{{id=19|
gcd?
///
}}}

<h3>Brüche und exakte Ausdrücke</h3>

Brüche von Ganzzahlen werden weder abgerundet (wie Ganzzahldivision in C) noch mit Gleitkommazahlen approximiert, sondern exakt gespeichert. Das gleiche gilt auch für viele Funktionsauswertungen:

{{{id=20|
3/5
sin(pi/3)
///
}}}

{{{id=21|
parent(3/5); parent(sin(pi/3)); parent(6/2)
///
}}}

Rechnen mit exakten Ausdrücken ergibt wieder exakte Ausdrücke:

{{{id=23|
a = sin(pi/3)/sqrt(3)
a; parent(a); a in QQ
///
}}}

Auch hier kann man prüfen, ob ein Ausdruck beispielsweise eine rationale Zahl ($x \in \mathbb{Q}$) oder zumindest eine reelle Zahl ($x \in \mathbb{R}$) ist:

{{{id=25|
sin(pi/3) in QQ
sqrt(3) in QQ
sin(pi/3)/sqrt(3) in QQ
pi in QQ
pi in RR
///
}}}

<h3>Kommazahlen</h3>

Direkt als Kommazahlen angegebene Werte werden standardmäßig als Gleitkommazahlen mit 53 Bits Genauigkeit gespeichert:

{{{id=28|
1.0/6
parent(1.0/6)
///
}}}

Mithilfe der Funktion n (Abkürzung für numerical_approx) können exakte Ausdrücke durch Gleitkommazahlen approximiert werden:

{{{id=30|
c = sin(pi/3)
n(c)
c.n()
///
}}}

Dabei können Genauigkeit (in Bits, mit Parameter prec) bzw. Anzahl der Dezimalstellen (Parameter digits) festgelegt werden:

{{{id=32|
n(1/6, prec=10000)
n(1/6, digits=1000)
///
}}}

Falls man wiederholt dieselbe Genauigkeit benötigt, kann man sich auch eine Typ dafür definieren (hier R mit 1000 Bits Präzision) und den wiederholt verwenden:

{{{id=34|
R = RealField(1000)
c = R(sin(pi/3))
b = R(1/3)
parent(c * b)
///
}}}

Bei Rechnungen mit mehreren verschieden genauen Werten hat das Ergebnis die geringste in der Eingabe vorkommende Präzision:

{{{id=36|
ungenau = n(1/10)
genau = R(1/15)
eins = genau/ungenau
parent(eins)
///
}}}

{{{id=106|
a = (1/3).n(prec=13)
b = (1/3).n(prec=100)

parent(a*b)
///
}}}

Nachträgliches Konvertieren zu einer besseren Präzision hilft natürlich nicht, um ein bereits ungenaues Ergebnis (hier 53 Bits Präzision) zu verbessern:

{{{id=107|
a = R(1.0/3.0)
parent(a); a
///
}}}

Will man eine Kommazahl wieder zu einer Ganzzahl runden, gibt es mehrere Möglichkeiten: normal kaufmännisch runden (round), aufrunden (ceil) oder abrunden (floor):

{{{id=38|
number = 3456.7 / 376
number; round(number); ceil(number); floor(number)
///
}}}

<h3>Komplexe Zahlen</h3>

Für die Darstellung von komplexen Zahlen $z \in \mathbb{C}$  sind die Konstanten I und i auf die imaginäre Einheit vordefiniert; in Python (und notfalls auch in Sage) kann auch die Notation mit j verwendet werden:

{{{id=16|
sqrt(-1)
z = 3 + 4*i
z2 = 3 + 4j
parent(z); parent(z2)
z3 = z2 / (4 + 2*I)
z3 in CC
///
}}}

Um separat auf Imaginärteil, Realteil, Absolutbetrag usw. einer komplexen Zahl zugreifen zu können, gibt es diverse Hilfsfunktionen:

{{{id=39|
z3; imag(z3); real(z3); abs(z3)
///
}}}

Vorsicht, man kann I und i (genau wie andere Konstanten wie pi, ...) auch versehentlich überschreiben:

{{{id=41|
I = 5
3 + 4*I
///
}}}

<h3>Wahrheitswerte (Bool)</h3>

Vergleiche und wahr-falsch-Fragen haben als Ergebnis-Datentyp Wahrheitswerte (Bool):

{{{id=104|
parent(5 in ZZ)
parent(3 < 5)
parent(4 * 5 == 20)
///
}}}

Boolesche Werte und Bedingungen kann man mit "and, or, not" (entspricht in C &&, ||, !) verknüpfen:

{{{id=44|
5 in ZZ and not 3 < 5
///
}}}

Anders als in C sind auch mehrere Vergleiche hintereinander möglich:

{{{id=46|
-5 < -3 < -1
///
}}}

Bei Vergleichen mit exakten Ausdrücken ist es teilweise notwendig, das Ergebnis der Gleichung explizit in einen Wahrheitswert zu konvertieren:

{{{id=48|
sin(pi/3) == sqrt(3)/2
bool(sin(pi/3) == sqrt(3)/2)
///
}}}

<h2>Listen</h2>

<h3>Listen, Tuples, Strings...</h3>

... spielen in Python und daher Sage eine sehr wichtige Rolle - mehr dazu in der nächsten Vorlesung.

<h3>Sets, Vektoren, ...</h3>

... sind spezielle Listen und werden wir uns auch später genauer ansehen
 

<h2>Symbolische Variablen und Funktionen</h2>
<h3>Variablen und symbolische Ausdrücke</h3>

In den obigen Beispielen waren Variablen jeweils durch den zugewiesenen Wert bestimmt. Aber in der Mathematik hat man sehr oft eigentlich nicht mit konkreten Werten, sondern mit symbolischen Variablen zu tun.
Beispielsweise ist die Gleichung $(x + y)^2 = x^2 + 2 \cdot x \cdot y + y^2$ für jeden beliebigen Wert von $x, y \in \mathbb{R}$ wahr. Um in Sage mit Variablen zu arbeiten, die noch keinen Wert haben, muss man sie mit der var-Funktion als symbolische Variablen deklarieren:

{{{id=4|
var("x")
parent(x)
///
}}}

Dann kann Sage beispielsweise Ausdrücke mit x ausmultiplizieren, oder allgemeine Gleichungen überprüfen:

{{{id=51|
expand((x + 3)^5)
///
}}}

{{{id=52|
var("x y")
bool((x+y)^2 == x^2+y^2+2*x*y)
///
}}}

<h3>Mathematische Funktionen</h3>

Besonders wichtig sind symbolische Variablen für die Definition von mathematischen Funktionen. Mathematische Funktionen sind nicht zu verwechseln mit den Prozedur-artigen "Funktionen" in C: Beispielsweise kann man mathematische Funktionen im Gegensatz zu C-Funktionen zueinander addieren, integrieren, ableiten, Grenzwerte berechnen, ... 

<br/>
Wie C-artige Funktionen in Sage funktionieren ist Thema in der nächsten Vorlesung.

<br/>
Die Definition von Funktionen ist sehr intuitiv:

{{{id=53|
f(x) = x^2 + x
g(x) = x^3
parent(f)
show(g)
///
}}}

Die gerade definierten Funktionen kann man nun addieren, hintereinanderausführen und so weiter:

{{{id=55|
expand(g(f))
f + g
///
}}}

Auch das Ergebnis von Funktionen für bestimmte Eingaben lässt sich berechnen. (Vorsicht, das Ergebnis hat einen symbolischen Datentyp - Zahlen-spezifische Funktionen wie factor funktionieren erst wie gewohnt, wenn man das Ergebnis zum Zahlen-Datentyp zurückkonvertiert:)

{{{id=57|
f(4)
parent(f(4))
factor(f(4))
factor(Integer(f(4)))
///
}}}

<h3>Differenzieren und Integrieren</h3>

Sage kann die gerade definierten Funktionen auch ableiten:

{{{id=5|
diff(f)
///
}}}

Bei Funktionen mit mehreren Variablen muss man angeben, nach welcher Variable (partiell) abgeleitet werden soll:

{{{id=60|
h(x, y) = y^2 + sin(x)
diff(h, x)
///
}}}

Unbestimmtes und bestimmtes Integral in Bezug auf die Integrationsvariable x:

{{{id=62|
integrate(f, x)
integrate(f, x, 0, 4)
///
}}}

<h3>Plots</h3>

Funktionsgraph plotten:

{{{id=64|
plot(f)
///
}}}

Standardmäßig wird für x-Werte im Intervall $[-1, 1]$ geplottet; normalerweise möchte man den Integrationsbereich selbst spezifizieren und vielleicht auch Farben usw. angeben:

{{{id=66|
plot(f, (x, -2, 0.5))
plot(f, (x, -2, 0.5), color="red")
///
}}}

Das Ergebnis eines Plots ist ein eigener Grafik-Datentyp, den man beispielsweise auch abspeichern kann:

{{{id=68|
p = plot(f, (x, -2, 0.5))
parent(p)
show(p)
p.save("meinbild.pdf")
///
}}}

Mehrere Plots in einem Bild zusammenkombinieren:

{{{id=70|
p_ableitung = plot(diff(f), (x, -2, 0.5), color = "blue")
show(p + p_ableitung)
///
}}}

<h3>Gleichungen, Nullstellen</h3>

Nullstellen der Funktion $f(x) = x^2 - 2x - 3$ finden:

{{{id=71|
f(x) = x^2 - 2*x - 3
solve(f(x) == 0, x)
///
}}}

<h3>Grenzwerte</h3>

Grenzwerte von Folgen und Funktionen berechnen, hier beispielsweise $\lim_{x \to \infty} \frac{1}{x} = 0$ und $\lim_{x \to 0^-} \frac{1}{x} = \infty$:

{{{id=108|
f(x) = 1/x
limit(f, x = +oo) # Grenzwert Richtung +unendlich
///
}}}

{{{id=73|
limit(f, x = 0, dir = "minus") # Grenzwert Richtung 0 (von links)
///
}}}

Bei manchen Funktionen ist der Grenzwert undefiniert:

{{{id=75|
f(x) = x * sin(1/x)
plot(f)
limit(f(x), x = +oo)
///
}}}

Konvergenz einer Reihe, beispielsweise $\sum_{n=1}^{\infty} \frac{1}{n^2}$:

{{{id=77|
var("n")
a(n) = 1/n^2
sum(a(n), n, 1, +oo)
///
}}}

<h3>3D-Plots</h3>

3D-Plots für Funktionen mit mehreren Variablen sind interaktiv:

{{{id=79|
var("x y")
h(x, y) = y^2 + sin(x)
plot3d(h, (x, -1, 1), (y, -1, 1))
///
}}}