def umnozhaj(fak1, fak2):
"""
Multipliziert fak1 und fak2 nach der russischen Bauernmethode
fak1 und fak2 müssen natürliche Zahlen sein
"""
# Dumme Eingaben abfangen
if not is_natural(fak1) or not is_natural(fak2):
raise Exception("Russische Bauern brauchen und können nur" + " natürliche Zahlen multiplizieren.")
# Akkumulator initialisieren
if is_even(fak1): # bei gerader Zahl in der ersten Spalte
prod = 0
else:
prod = fak2
# Iterieren, bis fak1 0 oder 1 erreicht hat
while fak1 > 1:
# fak1 ganzzahlig durch zwei teilen
fak1 >>= 1
# fak2 mit zwei multiplizieren
fak2 <<= 1
# Bei gerader Zahl in der ersten Spalte zweite Spalte streichen
if is_even(fak1):
pass
# Bei ungerader Zahl zum Ergebnis addieren
else:
prod += fak2
return prod
def binomk_iter(n, k):
"""
Berechnet den Binomialkoeffizienten n über k iterativ
Die Berechnung ist an die explizite Formel angelehnt. -- Sie zieht die
Faktoren aus den Fakultäten auseinander, dividiert also erst und
multipliziert dann.
"""
# Dumme Eingaben abfangen
if not is_natural(n) or not is_natural(k):
raise Exception("n und k müssen natürliche Zahlen sein")
# Nach Definition:
if k > n:
return 0
# Binomialkoeffizienten berechnen
res = 1
for i in range(1, k+1):
res *= n / i
n -= 1 # Einfaches Dekrement ist schneller als explizite Subtraktion
return int(res)
def binomk_naiv(n, k):
"""
Berechnet den Binomialkoeffizienten n über k naiv und rekursionsfrei
Benutzt wird die Formel (n k) = n! / ((n-k)! * k!).
"""
# Dumme Eingaben abfangen
if not is_natural(n) or not is_natural(k):
raise Exception("n und k müssen natürliche Zahlen sein")
# Nach Definition:
if k > n:
return 0
else:
return fac_iter(n) // (fac_iter(n - k) * fac_iter(k))
def pow_iter(base, expon):
"""
Berechnet endrekursiv base^expon für natürliche Zahlen
0^0 wird als 1 festgelegt.
"""
# Dumme Eingaben abfangen
if not is_natural(base) or not is_natural(expon):
raise Exception("Basis und Exponent müssen natürliche Zahlen sein")
# Potenz berechnen
prod = 1
for factor_nr in range(expon):
prod *= base
return prod
def pow_rek(base, expon):
"""
Berechnet endrekursiv base^expon für natürliche Zahlen
0^0 wird als 1 festgelegt.
"""
# Dumme Eingaben abfangen
if not is_natural(base) or not is_natural(expon):
raise Exception("Basis und Exponent müssen natürliche Zahlen sein")
# rekursive Hilfsfunktion mit kumulativem Parameter definieren
def pow_helper(prod, base, expon):
if expon == 0:
return prod
else:
return pow_helper(prod * base, base, expon - 1)
# Aufruf der Hilfsfunktion
return pow_helper(1, base, expon)
def _check(self, job):
"""
Check whether input tuple is valid job
"""
priority = job[1]
if not (number.is_natural(priority) and 1 <= priority <= 100):
raise Exception("Priority must be natural number between 1 and "
+ " 100")
return
def binomk_rek(n, k):
"""
Berechnet den Binomialkoeffizienten n über k über die rekursive Formel
"""
# Dumme Eingaben abfangen
if not is_natural(n) or not is_natural(k):
raise Exception("n und k müssen natürliche Zahlen sein")
# Nach Definition:
if k > n:
return 0
# Rekursionsanker setzen
if k == 0:
return 1
if k == 1:
return n
# Bühne frei für Rekursion
return binomk_rek(n-1, k-1) + binomk_rek(n-1, k)
def fac_iter(n):
"""
Berechnet die Fakultät der Zahl n iterativ
"""
# Dumme Eingaben abfangen
if not is_natural(n):
raise Exception("Wir berechnen nur Fakultäten von natürlichen"
+ " Zahlen. Für andere Zahlenbereiche ist die"
+ " Gammafunktion zu verwenden.")
# Fakultät berechnen
factorial = 1 # 0! = 1
for factor in range(2, n+1):
factorial *= factor
return factorial
def draw_mm_fractal(size, filename):
"""
Schreibt ein Mickey-Mouse-Fraktal in eine Postscript-Datei
Parameter:
size ... "Größe" des Bildes. Da wir es mit Vektorgrafiken zu tun
haben, bestimmt der Parameter hauptsächlich die
Rekusionstiefe und damit die Detailliertheit des Bildes.
filename
... Name der Datei, in die geschrieben werden soll
Rückgabe: Nüschts
"""
# Dumme Eingaben abfangen
if not number.is_natural(size):
raise Exception("Bildgröße muss eine natürliche Zahl sein.")
if not isinstance(filename, str):
raise Exception("Dateiname muss ein String sein.")
# Größe der kleinsten Kreise an Bildgröße anpassen
resolution = 610 / size
def rec_circles(x_0, y_0, size):
"""
Schreibt rekursiv die Befehle für die Kreise des Fraktals
Parameter:
x_0, y_0 ... Koordinaten des linken unteren Punktes des Feldes für
die aktuelle Rekursion
size ... größe des Feldes für die aktuelle Rekursion
Die Funktion schreibt einen Kreis in jeden Quadranten des aktuellen
Bildfeldes und ruft sich dann für jeden Quadranten rekursiv auf.
"""
# Größe der Felder für nächsttiefere Rekursionsebene
half_size = size / 2
if size > resolution:
# Kreis in die linke untere Ecke und rekursiv kleine Kreise
fillCircle( x_0 + size, y_0 + size, size)
rec_circles(x_0, y_0, half_size)
# Kreis in die rechte untere Ecke und rekursiv kleine Kreise
fillCircle( x_0 + 3 * size, y_0 + size, size)
rec_circles(x_0 + 2 * size, y_0, half_size)
# Kreis in die linke obere Ecke und rekursiv kleine Kreise
fillCircle( x_0 + size, y_0 + 3 * size, size)
rec_circles(x_0, y_0 + 2 * size, half_size)
# Kreis in die rechte obere Ecke und rekursiv kleine Kreise
fillCircle( x_0 + 3 * size, y_0 + 3 * size, size)
rec_circles(x_0 + 2 * size, y_0 + 2 * size, half_size)
else:
return
# Header schreiben
begin(filename, size, size)
# Schwarz als Farbe für überall definieren
setColor(0, 0, 0)
# großen schwarzen Klecks in die Mitte
half_size = size / 2
fillCircle(half_size, half_size, half_size)
# kleine Kreise rekursiv
rec_circles(0, 0, size / 2)
# PS-Datei abschließen
end()
return
