Version 2.1

# Funktions- und Klassen-Referenz

Klassen
Globale Funktionen

Übersicht:

## Klassen

Klasse | Bedeutung
ContFrac | Kettenbrüche
Edge | Kanten eines Graphen
Graph | Graphen
Logic | Aussagenlogik
Matrix | Matrizen
Mod | Elemente der Restklassenringe Z[m]
NumeralSystem | Umrechnung zwischen Stellenwertsystemen
Perm | Permutationen (aus Dictionary oder Zyklendarstellung)
Poly | Polynome über beliebigen Ringen
Rational | Rationale Zahlen
Rsa | RSA-Verschlüsselung
Set | Polymorphe Mengen
Vector | Vektoren

## Globale Funktionen

Function | Bedeutung
allFactors (n) | Liste aller Primfaktoren von n
binomial (n, k) | Binomialkoeffizient (n über k)
ceil (x) | kleinste ganze Zahl n >= x
chinese (mod1, *mod2) | Mod-Objekt zu mod1 mod2, ... nach Chinesischem Restsatz
closure (elements, operation) | Der Abschluss der Menge elements unter der binären Operation operation
copy (x) | unabhängige Kopie
divisors (n) | Liste der Teiler von n
eulerPhi (n) | Eulersche Phi-Funktion
expMod (a, x, m) | Berechnet (a**x) % m effizient.
factor (n) | Primfaktorenzerlegung
factorial (n) | n! = 1*2*3* ... *n (n Fakultät)
factors (n) | Liste der Primfaktoren von n (jeder nur einmal)
fibonacci (n) | n-tes Element der Fibonacci-Folge
fit (data, values) | Interpolation mit der Gaußschen Methode der kleinsten Quadrate
floor (x) | größte ganze Zahl n <= x (Gauß-Klammer)
fromTo (a, b, step=1) | Iterator über die ganzen Zahlen von a bis einschl. b im Abstand step
gcd (a,b) | Größter gemeinsamer Teiler von a und b
gcdExt (a,b) | Erweiterter Euklidischer Algorithmus.
isInteger (n) | gibt `True` zurück genau dann, wenn n vom Typ `int` ist.
isNatural (n) |
isPrime (n,s=20) | Rückgabewert bool (ist n Primzahl?)
join (l, filler="") | verbindet die Elemente von `l` zu einem String
lcm (a, b) | Kleinstes gemeinsames Vielfaches von a und b
nextPrime (n) | nächste Primzahl ab (einschließlich) n
permutations (v, prefix=[]) | Liste aller Permutationen von v
permute (v, fn, prefix=[]) | wendet Prozedur `fn` auf alle Permutationen von Liste v an.
plot (terms, x0, x1, **options) |
plotFunctions (functions, x0, x1, **options) |
prime (n) | n-te Primzahl
printTable (height, width, cellFunction, **options) | gibt eine Tabelle mit height Zeilen und width Spalten aus, deren Zellen mit cellFunction berechnet werden.
printValueTable (values, variable="n", start=0, end=10, increment=1, vertical=True) | Gibt eine Wertetafel aus.
product (obj, start=None, end=None, step=1) | Product der Elemente des iterierbaren Objekts a bzw. aller obj(i) für i in fromTo(start,end,step)
rand (n) | Zufallszahl im Bereich 0 ... n-1 n kann eine beliebige natürliche Zahl sein (int).
sum (obj, start=None, end=None, step=1) | Summe der Elemente des iterierbaren Objekts a bzw. aller obj(i) für i in fromTo(start,end,step)
toNumber (s) | verwandelt den String s in eine rationale oder Gleitkommazahl

# Globale Funktionen

## allFactors

Aufruf: `allFactors(n)`

Beschreibung:
Liste aller Primfaktoren von n
Beispiel: `allFactors(24)` gibt `[2, 2, 2, 3]` zurück.
Siehe auch `factor`, `factors`.

## binomial

Aufruf: `binomial(n, k)`

Beschreibung:
Binomialkoeffizient (n über k)
n muss nichtnegative ganze Zahl sein, k im Bereich 0 .. n.

## ceil

Aufruf: `ceil(x)`

Beschreibung:
kleinste ganze Zahl n >= x

## chinese

Aufruf: `chinese(mod1, *mod2)`

Beschreibung:
Mod-Objekt zu mod1 mod2, ... nach Chinesischem Restsatz
Voraussetzung: mod1, mod2, ... sind Mod-Objekte mit paarweise teilerfremden Moduln.
`chinese(Mod(a1, m1), Mod(a2, m2, ...)`
berechnet Mod(x, m1*m2*...) mit 0 <= `x` < m1*m2*... und
`x % m1 == a1`
`x % m2 == a2`
, ...
Beispiel:

        chinese(Mod(1,5), Mod(2,7))  # -à Mod(16,35)

(16 mod 5 = 1, 16 mod 7 = 2).
Siehe auch `Mod`

## closure

Aufruf: `closure(elements, operation)`

Beschreibung:
Der Abschluss der Menge elements unter der binären Operation operation
operation muss eine function mit zwei Parametern sein.

## copy

Aufruf: `copy(x)`

Beschreibung:
unabhängige Kopie

## divisors

Aufruf: `divisors(n)`

Beschreibung:
Liste der Teiler von n

## eulerPhi

Aufruf: `eulerPhi(n)`

Beschreibung:
Eulersche Phi-Funktion
Anzahl der zu n teilerfremden Zahlen im Bereich von 1 bis n

## expMod

Aufruf: `expMod(a, x, m)`

Beschreibung:
Berechnet (a**x) % m effizient.
Synonym für die Python-Standardfunktion `pow`.

## factor

Aufruf: `factor(n)`

Beschreibung:
Primfaktorenzerlegung
Rückgabewert: Liste mit Paaren [Primfaktor, Exponent]
Beispiel:
`factor(24)`
gibt `[[2,3],[3,1]]` zurück.
Siehe auch `factors`, `allFactors`.

## factorial

Aufruf: `factorial(n)`

Beschreibung:
n! = 1*2*3* ... *n (n Fakultät)

## factors

Aufruf: `factors(n)`

Beschreibung:
Liste der Primfaktoren von n (jeder nur einmal)
Beispiel:
`factors(24)` gibt `[2, 3]` zurück.
Siehe auch `factor`, `allFactors`.

## fibonacci

Aufruf: `fibonacci(n)`

Beschreibung:
n-tes Element der Fibonacci-Folge fibonacci(0) = 0
fibonacci(1) = 1
fibonacci(n) = fibonacci(n-1) + fibonacci(n-2) für n >= 2

## fit

Aufruf: `fit(data, values)`

Beschreibung:
Interpolation mit der Gaußschen Methode der kleinsten Quadrate
`fit(data, values)` berechnet nach der Methode der kleinsten Quadrate eine Linearkombination der Funktionen, die x auf die Terme in `values` abbilden.
(entspricht der Mathematica-Funktion `Fit`).
Beispiel:

     fit([(-1,2), (1,1), (2,1), (3,0), (5,3)],
         ["1", "x", "x**2"])

berechnet `[c1, c2, c3]` so dass die Funktion
`f(x) = c1*1 + c2*x + c3 * x**2`
die Bedingungen f(-1)=2, f(1)=1, f(2)=1, f(3)=0, f(5)=3 approximiert.
Ergebnis: "(6/5 * 1) + (-53/70 * x) + (3/14 * x**2)

## floor

Aufruf: `floor(x)`

Beschreibung:
größte ganze Zahl n <= x (Gauß-Klammer)

## fromTo

Aufruf: `fromTo(a, b, step=1)`

Beschreibung:
Iterator über die ganzen Zahlen von a bis einschl. b im Abstand step
Wenn step nicht übergeben wird, wird step auf 1 gesetzt.
Beispiele:

        list(fromTo(3, 6))               # -à  [3,4,5,6]
        list(fromTo(3, 6, 2))            # -à  [3,5]
        list(fromTo(6, 3))               # -à  []
        list(fromTo(6, 3, -2))           # -à  [6,4]
        [2*i for i in fromTo(6, 3, -2)]  # -à  [12,8]
        sum(fromTo(1, 10))               # -à  55

## gcd

Aufruf: `gcd(a,b)`

Beschreibung:
Größter gemeinsamer Teiler von a und b
Berechnung mit dem euklidischen Algorithmus
Siehe auch `lcm`

## gcdExt

Aufruf: `gcdExt(a,b)`

Beschreibung:
Erweiterter Euklidischer Algorithmus.
Gibt (d, x, y) zurück mit d == gcd(a,b) und x*a + y*b == d

## isInteger

Aufruf: `isInteger(n)`

Beschreibung:
gibt `True` zurück genau dann, wenn n vom Typ `int` ist.

## isNatural

Aufruf: `isNatural(n)`

## isPrime

Aufruf: `isPrime(n,s=20)`

Beschreibung:
Rückgabewert bool (ist n Primzahl?)
Implementierung mit Miller-Rabin-Test
(vgl. Cormen, Leiserson, Rivest: Algorithms, S. 841)
Siehe auch `prime`, `nextPrime`.

## join

Aufruf: `join(l, filler="")`

Beschreibung:
verbindet die Elemente von `l` zu einem String
Zwischen je zwei Elemente wird `filler` eingefügt.
Ersatz für die schwer lesbare String-Methode join() bzw. für die Funktion string.join().
Im Gegensatz zu diesen Funktionen werden zusätzlich die Listenelemente zu Strings konvertiert.
Beispiel:
`join(fromTo(1,5), "-")` liefert `"1-2-3-4-5"`.

## lcm

Aufruf: `lcm(a, b)`

Beschreibung:
Kleinstes gemeinsames Vielfaches von a und b
Siehe auch `gcd`

## nextPrime

Aufruf: `nextPrime(n)`

Beschreibung:
nächste Primzahl ab (einschließlich) n
Siehe auch `isPrime`, `prime`.

## permutations

Aufruf: `permutations(v, prefix=[])`

Beschreibung:
Liste aller Permutationen von v
Wenn v sortiert ist, werden auch die Permutationen in sortierter Reihenfolge erzeugt.

## permute

Aufruf: `permute(v, fn, prefix=[])`

Beschreibung:
wendet Prozedur `fn` auf alle Permutationen von Liste v an.
Wenn v sortiert ist, werden auch die Permutationen in sortierter Reihenfolge erzeugt.

## plot

Aufruf: `plot(terms, x0, x1, **options)`

## plotFunctions

Aufruf: `plotFunctions(functions, x0, x1, **options)`

## prime

Aufruf: `prime(n)`

Beschreibung:
n-te Primzahl
Siehe auch `isPrime`, `nextPrime`.

## printTable

Aufruf: `printTable(height, width, cellFunction, **options)`

Beschreibung:
gibt eine Tabelle mit height Zeilen und width Spalten aus, deren Zellen mit cellFunction berechnet werden.
cellFunction muss eine Funktion mit zwei Parametern (Zeile, Spalte) sein.
Folgende optionalen benannten Parameter werden unterstützt:
rowHeadFn: Falls vorhanden, werden Zeilenköpfe angezeigt und mit dieser Funktion berechnet.
colHeadFn: Falls vorhanden, werden Spaltenköpfe angezeigt und mit dieser Funktion berechnet.
headAlign: "left" (Standard), "right" oder "center"
cellAlign: "left", "right" (Standard) oder "center"
title: Falls vorhanden, wird eine Titelzeile mit diesem Text über der Tabelle angezeigt
corner: Falls vorhanden (und auch rowHeadFn und colHeadFn), wird dieser Text in der oberen linken Tabellenecke angezeigt.
Diese Funktion wird vom Menübefehl Einfügen -- Tabelle verwendet.
Beispiel:

     printTable(7, 7, lambda i,k: i*k % 7,
        rowHeadFn = lambda i: i,
        colHeadFn = lambda k: k,
        title = "Multiplikation mod 7",
        corner = "*")

Gibt eine Multiplikationstabelle modulo 7 aus.

## printValueTable

Aufruf: `printValueTable(values, variable="n", start=0, end=10, increment=1, vertical=True)`

Beschreibung:
Gibt eine Wertetafel aus.
Diese Funktion wird vom Menübefehl Einfügen -- Wertetafel verwendet.
Beispiel:

    printValueTable([(lambda n:n^2, "n²"), (lambda n:2^n, "2n")],
                     "n", 0, 10, True)

Listet die Werte n² und 2n für n von 0 bis 10 auf.

## product

Aufruf: `product(obj, start=None, end=None, step=1)`

Beschreibung:
Product der Elemente des iterierbaren Objekts a bzw. aller obj(i) für i in fromTo(start,end,step)
Die Elemente müssen mit dem Operator * verknüpfbar sein
Beispiele:
`product([i^2 for i n fromTo(1,10)])`
`product(fibonacci, 0, 10)`
`product(lambda i:i^2, 2, 10, 2)`

## rand

Aufruf: `rand(n)`

Beschreibung:
Zufallszahl im Bereich 0 ... n-1
n kann eine beliebige natürliche Zahl sein (int).

## sum

Aufruf: `sum(obj, start=None, end=None, step=1)`

Beschreibung:
Summe der Elemente des iterierbaren Objekts a bzw. aller obj(i) für i in fromTo(start,end,step)
Die Elemente müssen mit dem Operator + verknüpfbar sein (z. B. Zahlen oder Strings).
Beispiele:
`sum([i^2 for i n fromTo(1,10)])`
`sum(fibonacci, 0, 10)`
`sum(lambda i:i^2, 2, 10, 2)`

## toNumber

Aufruf: `toNumber(s)`

Beschreibung:
verwandelt den String s in eine rationale oder Gleitkommazahl
Beispiele:
`toNumber("3.1")`
`toNumber("7/3")`