Folgen und Funktionen in der Mathematik

Transkript

1 Folgen und Funktionen in der Mathematik Anhand von einigen exemplarischen Beispielen soll die Implementierung von mathematischen Algorithmen in C/C++ gezeigt werden: Reelle Funktionen in C/C++ Diese wird man meist als double-funktion mit einem oder mehreren Argumenten programmieren, also z.b: double f(double x) oder double f(double x, double a,...) Verwendet man mathematische Funktionen wie Exponentialfunktionen, Winkelfunktionen usw., so ist in C meist die Headerdatei math.h zu inkludieren und das Programm mit gcc lm zu kompilieren. In C++ genügt es, den Header cmath zu inkludieren. Folgen in C/C++ bzw. Funktionen von ganzzahligen positiven Argumenten a) Folgen sind in der Mathematik oft durch einen Funktionsterm wie a = ( n^2-n+3 ) definiert. Folgen natürlicher Zahlen können sehr leicht durch eine int a(int n) oder auch int a(unsigned n) Funktion nachgebildet werden, z.b. hier int a(int n) return n*n-n+3; // NICHT VERGESSEN: ^ ist nicht das Quadrat Reelle Zahlenfolgen wird man eher mit double-ergebnis definieren: double a(int n) return (n+1.0)/n; // NICHT VERGESSEN: Vermeide int-division Manchmal macht es durchaus Sinn, bei der Berechnung der Funktionsterme Gleitkommazahlen zu verwenden, um Überläufe zu vermeiden und um Ganzzahldivisionen zu verhindern: double a(int n) return (n*n*n-1)/(n*n+3); // Überlauf und Ganzzahldivision!

2 double a(int n) double x = n; return (x*x*x-1)/(x*x+3); // Alles behoben! Natürlich lassen sich Folgen auch durch Lambdas definieren: auto a = [](int n) double x = n; return (x*x*x-1)/(x*x+3); ; b) Manchmal sind Folgen in der Mathematik rekursiv definiert, d.h. man erfährt nur, wie man aus alten Folgengliedern neue berechnen kann: Fibonacci-Folge und ähnliche rekursive Folgen: Die klassische Fibonacci-Folge ist festgelegt durch F(0) = 0, F(1) = 1, F(n) = F(n-2)+F(n-1) für alle n >= 2 d.h. aus 2 Folgengliedern ergibt sich das nächste als deren Summe. Es gibt auch nichtrekursive Formeln für diese Folge, aber die einfachste Art der Berechnung ist die Rekursion. C/C++/Java erlauben rekursive Funktionen, sodass sich diese Definition fast wörtlich umsetzen lässt: int Fibonacci(int n) // berechne Folgenglied mit Index n if (n >= 2) // der Hauptfall, n = 2, 3, 4, return Fibonacci(n-2)+Fibonacci(n-1); if (n == 0) // man braucht wegen des return hier kein else return 0; if (n == 1) return 1; // ab hier Fehler, das darf nicht sein cerr << "Fehler: Fibonacci(" << n << ")\n"; return -1; Man stellt aber trotz Optimierung fest, dass z.b. der Aufruf Fibonacci(50) ewig braucht. Der Grund liegt darin, dass z.b. Fibonacci(50) die Aufrufe Fibonacci(49) und Fibonacci(48) verursacht, diese erzeugen Aufrufe von Fibonacci(48),

3 Fibonacci(47) sowie Fibonacci(47), Fibonacci(46). D.h. jeder Aufruf erzeugt 2 weitere Aufrufe und die Arbeitslast steigt wie 2 n. Für n=50 ist das die riesige Zahl 2 50 = , sodass der enorme Zeitaufwand damit erklärbar ist. Manchmal lassen sich rekursiv definierte Funktionen in eine Schleife umschreiben, manchmal lässt sich die Tiefe der Rekursion (aus wie vielen alten Elementen berechnet man das neue) reduzieren, z.b. hier: Die neue Funktion Fibonacci(n, a, b) berechne das n.te Glied der Fibonacci-Folge mit den Startwerten a und b: Fibonacci(0, a, b) = a, Fibonacci(1, a, b) = b und Fibonacci(n, a, b) = Fibonacci(n-2, a, b) + Fibonacci(n-1, a, b) für alle n >= 2. schreibt man die ersten Glieder dieser Folge an, erhält man: a, b, a+b, a+2b, 2a+3b und man sieht, dass das n. Glied dieser Folge das (n-1). Glied der Folge ist, bei der man den allerersten Wert weglässt: b, a+b, a+2b, 2a+3b d.h. Fibonacci(n, a, b) = Fibonacci(n-1, b, a+b) Diese Rekursion hat nur noch eine Tiefe von 1 und wächst linear. Größter gemeinsamer Teiler ggt und der Euklidische Algorithmus Euklidischer Algorithmus: Es seien a >= b > 0 natürliche Zahlen; a = q*b + r (Division von a durch b mit Rest r, Quotient q) Es gilt: r == 0: ggt(a,b) = b r!= 0: ggt(a,b) = ggt(b,r) (Rekursion) die ggt-funktion kann man genauso programmieren, sie ruft sich dann selbst auf -> rekursive Funktion int ggt(int a,int b) // berechnet rekursiv den ggt von a >= b > 0 int r; r = a % b; // Divisionsrest if (r == 0) return b; else return ggt(b,r);

4 Noch kürzer kann man die Funktion noch schreiben, wenn man den if else-block durch den?: Operator ersetzt. Die Syntax ist Bedingung? Wert_if_true : Wert_if_false Damit lassen sich kurze if else-blöcke oft vermeiden: int ggt(int a,int b) // berechnet rekursiv den ggt von a, b // a,b muessen positiv sein!!! // außerdem muss a >= b sein int r = a % b; return (r == 0)? b : gtt(b, r); Bei dieser Rekursion erzeugt ein Aufruf des ggt nur einen weiteren Aufruf, sodass hier kein exponentielles Wachstum der Aufrufe erfolgt und die Rechenzeit erträglich klein bleibt. Trotzdem kann man auch hier die Abarbeitung in eine Schleife verlagern und dadurch Ressourcen einsparen: int ggt(int a, int b) // berechnet den ggt in Schleife, a >= b > 0 int r; do r = a % b; // Divisionsrest a = b; b = r; while (r!= 0); return a; // eigentlich muss man b zurückgeben // b wurde in der Schleife schon mit r = 0 überschrieben // ist aber Gott sei Dank noch in a gespeichert Wenn es möglich ist, Algorithmen nichtrekursiv zu formulieren, wird man meist mit Zeitoder Speicherplatzersparnis belohnt. Nicht alle rekursiven Folgen lassen sich in eine nichtrekursive Form bringen! In beiden Varianten muss man noch eine zusätzliche Funktion int ggt(int a, int b) schreiben, die vorher dafür sorgt, dass die Bedingungen an a und b (a >= b > 0) zutreffen oder hergestellt werden, und die abschließend ggt() aufruft:

5 int ggt(int a, int b) if (a < 0) a = -a; // jetzt ist sicher a >= 0 if (b < 0) b = -b; // jetzt ist sicher b >= 0 if (a < b) // vertausche a und b std::swap(a, b); // jetzt gilt 0 <= b <= a return b == 0? a // bei b == 0 gib a zurueck : ggt(a,b); // ansonsten berechne den ggt Wenn man die Schleifen-Variante zur Berechnung verwendet, kann man beide Funktionen zu einer zusammenfassen: int ggt(int a, int b) if (a < 0) a = -a; // jetzt ist sicher a >= 0 if (b < 0) b = -b; // jetzt ist sicher b >= 0 if (a < b) // vertausche a und b std::swap(a, b); // jetzt gilt 0 <= b <= a if (b!= 0) int r; // ab hier der Euklidische Algorithmus als Schleife do r = a % b; a = b; b = r; while (r!= 0); return a; Die Potenz-Funktion Da C/C++ keine eingebaute Potenzfunktion besitzt, könnte man Sie recht leicht mithilfe von Schleifen und Multiplikationen realisieren (oder die Exponentialfunktion und Logarithmusfunktion verwenden). Eine sehr elegante rekursive Version: double hoch(double x, int n) if (n > 0) // Hauptfall return (n % 2!= 0)? x * hoch(x, n-1)// n ist ungerade?

6 : hoch(x*x, n/2); // n ist gerade! if (n < 0) return hoch(1/x, -n); return 1; Noch universeller wird diese Funktion, wenn man Sie als Template für einen beliebigen Grundtyp T schreibt (siehe später): template<typename T> T hoch(const T& x, int n) if (n > 0) // Hauptfall return (n % 2!= 0)? x*hoch(x, n-1) // n ist ungerade? : hoch(x*x, n/2); // n ist gerade! if (n < 0) return hoch(1/x, -n); return 1; Diese Funktion kann double, float, complex<double>, complex<float> potenzieren und könnte auch für das Potenzieren von quadratischen Matrizen verwendet werden (wenn man diesen Typ definiert hat!).