Programmierung für Mathematiker

Transkript

1 Programmierung für Mathematiker Prof. Dr. Thomas Schuster M.Sc. Dipl.-Phys. Anne Wald

2 Funktionen Funktion Zusammenfassung eines Anweisungsblocks zu einer aufrufbaren Einheit Gehört zu den wichtigsten Konzepten fast aller Programmiersprachen Aufgaben von Funktionen: 1 Wiederverwendbarkeit von einmal geschriebenem Code 2 Strukturierung und Vereinfachung von Code bessere Übersicht und Lesbarkeit 3 einfachere Fehlersuche, separates Testen möglich 4 leichteres Hinzufügen weiterer Funktionalitäten Die sinnvolle Strukturierung eines Programms in Unterprogramme ist einer der wichtigsten Schritte bei der Programmierung!

3 Charakterisierung von Funktionen Eine Funktion besitzt einen sinnvollen (=sprechenden) Namen, mit dem sie aufgerufen wird. nimmt eine (möglicherweise leere) Liste von Parametern mit festgelegten Datentypen als Eingabe. hat einen Anweisungsblock, der bei ihrem Aufruf ausgeführt wird. liefert nichts oder einen Wert eines festgelegten Datentyps als Ausgabe Mathematische Schreibweise: Funktion : {int, float,...} N {int, float,...} oder {}, N 0 (Parameter1,..., ParameterN) Anweisungen Ausgabewert Im Gegensatz zu mathematischen Funktionen kann der Anweisungsblock auch Befehle enthalten, die nicht direkt etwas mit der Ausgabe zu tun haben (auch Funktion: {} {} kann in C sinnvoll sein).

4 Syntax Deklaration Rückgabetyp Funktionsname(ParTyp1 [Par1],..., ParTypN [ParN]); Definition Rückgabetyp Funktionsname(ParTyp1 Par1,..., ParTypN ParN) { Anweisungsblock } Unterschied zwischen Deklaration und Definition: verschiedene Abstraktionsebenen! Deklaration (= Signatur) legt fest, was eine Funktion tut. muss vor dem erstmaligen Aufruf und außerhalb von main im Code stehen. endet mit einem Semikolon. Parameter-Datentypen genügen. Definition legt fest, wie eine Funktion etwas tut. kann an einer beliebigen Stelle außerhalb von main im Code stehen. hat kein Semikolon am Ende. Parameter sind mit Typ und Name anzugeben.

5 Beispiel 1 /** Praeprozessordirektive ****/ 2 #include <stdio.h> /** Funktionsdeklarationen ****/ 6 float summe(float a, float b); // auch moeglich: 7 // float summe(float, float); /** Hauptprogramm ****/ 11 int main(void) 12 { 13 float sum; 14 sum = summe(3.5, 1); // Funktionsaufruf 15 } /** Funktionsdefinitionen ****/ 19 float summe(float a, float b) 20 { 21 float sum = a + b; // Funktionsrumpf 22 return sum; // Funktionsrumpf 23 }

6 Der Datentyp void Funktionen ohne Rückgabe: Deklaration: void Funktion(Parameterliste); Beispiel: void srand48(long seed); Verwendung: z. B. Bildschirmausgabe, Statusänderung eines externen Mechanismus In anderen Programmiersprachen (z.b. Pascal) oft als Prozedur bezeichnet. In C gibt es keine Differenzierung zwischen Funktion und Prozedur. Funktionen ohne Parameter: Deklaration: Rückgabetyp Funktion(void); Beispiel: double drand48 (void); Verwendung: z. B. Ausführung von externen Mechanismen Kombination: z. B. void abort(void); (Gewaltsames Ende des Programms)

7 return und main return Mit der Ausführung der return-anweisung wird die aktuelle Funktion sofort beendet. Enthält der Funktionsrumpf keine return-anweisung, so endet die Ausführung des Rumpfes bei Erreichen der letzten schließenden geschweiften Klammer. schlechter Stil! Beachte: Es kann immer nur ein (skalarer) Wert zurückgegeben werden. main main ist in Wirklichkeit eine Funktion (mit Rückgabetyp int). Quelltext innerhalb von main wird als Hauptprogramm bezeichnet. Es sind äquivalent: main() int main() int main(void) main liefert standardmäßig den Rückgabewert 0 wenn keine Fehler aufgetreten sind. Mit return...; können andere Werte zurückgeliefert werden. Fehlerbehandlung

8 Beispiel 1: Funktion mit Rückgabewert Die charakteristische Funktion eines Intervalls [a, b] mit a < b ist definiert als { 1, x [a, b] χ [a,b] (x) := 0, sonst. Implementierung: je nach Wert von x wird 1.0 oder 0.0 zurückgegeben. Definition im Code: // Charakteristische Funktion des Intervalls [a,b] // (1 innerhalb, 0 ausserhalb) float charfunkintervall(const float a, const float b, float x) { if(a >= b) // Hier muss eine Fehlerbehandlung hin if ((x >= a) && (x <= b)) return 1.0; else return 0.0; }

9 Beispiel 2: Funktion ohne Rückgabewert void geplapper(int zahl1, double zahl2, char c) { printf("diese Funktion erzeugt eine Menge (sinnloser) Ausgaben "); printf("am Bildschirm.\n\n"); printf("jetzt noch eine horizontale Linie, dann geht's los!\n"); printf(" \n"); printf("zahl1 = %d, Zahl2 = %f\n", zahl1, zahl2); if(c == '+') printf("die Summe der beiden Zahlen ist %f\n\n", zahl1+zahl2); printf("so, jetzt bin ich fertig!\n"); return; }

10 Mathematische Funktionen Nutzung erfordert Präprozessordirektive Compilierung gcc ProgrammName.c -o ProgrammName -lm #include <math.h> Signatur int abs(int a) float fabsf(float a) double fabs(double a) double sqrt(double x) double pow(double b, double e) double exp(double x) double log(double x) double log10(double x) Bedeutung a a a x b e e x ln(x) log 10 (x)

11 Mathematische Funktionen Signatur Bedeutung double sin(double x) sin(x) double cos(double x) cos(x) double tan(double x) tan(x) double asin(double x) arcsin(x) double acos(double x) arccos(x) double atan(double q) arctan(q) ( π 2, π 2 ) double atan2(double x, double y) arctan(y/x) ( π, π] double sinh(double x) sinh(x) double cosh(double x) cosh(x) double floor(double x) x double ceil(double x) x

12 Konstanten in math.h Name Bedeutung M_E e M_LOG2E log 2 (e) M_LOG10E log 10 (e) M_LN2 ln(2) M_LN10 ln(10) M_PI π M_PI_2 π/2 M_PI_4 π/4 M_1_PI 1/π M_SQRT2 2 M_SQRT1_2 1/ 2 Bemerkung: Die Namen der Konstanten werden vom Präprozessor im Code textuell durch die entsprechenden Werte ersetzt, z. B. M_PI durch (Gleitkommazahlen werden automatisch als double interpretiert.)

13 Call by Value Beispiel: Vertauschen zweier Werte (?) 1 #include <stdio.h> 2 3 // Funktionsdeklaration 4 void vertausche(int p, int q); // oder (int, int) // Hauptprogramm 8 int main(void) 9 { 10 int a = 1, b = 3; 11 vertausche(a, b); 12 printf("a = %d, b = %d\n", a, b); 13 return 0; // guter Stil 14 } // Funktionsdefinition 17 void vertausche(int p, int q) 18 { 19 int hilf = p; 20 p = q; 21 q = hilf; 22 return; 23 } Ausgabe: a = 1, b = 3 Die Werte wurden gar nicht vertauscht! Warum?

14 Call by value Definition Bei einem Funktionsaufruf werden nicht die Variablen als solche, sondern lediglich ihre Werte, d.h. Kopien der Variableninhalte übergeben. + Funktionsaufrufe können direkt als Parameter für eine andere Funktion verwendet werden, da der Wert und nicht die Funktion selbst übergeben wird. Beispiel: printf("wurzel von 2 = %f\n", sqrt(2.0)); + Unbeabsichtigte Manipulation der Variablen durch Funktionen wird vermieden. Der Manipulation von Variablen sind Grenzen gesetzt, da immer nur ein (skalarer) Wert zurückgeliefert werden kann. (Ausweg: Zeiger und Call by reference, später) Häufige Fehlerquelle: Annahme, dass Funktionsparameter durch die Funktion verändert werden können. Dem ist nicht so! Beispiel: float a = 2.0; sqrt(a); Hier wird der Rückgabewert von sqrt mit Parameter 2.0 nicht wieder in a gespeichert, sondern verworfen!

15 Scope und Lifetime Definition (Scope) Der Scope (Sichtbarkeit) eines deklarierten Objekts (Variable oder Funktion) ist der Bereich im Quelltext, in dem es bekannt, d. h. mit seinem Namen aufrufbar ist. Generell gilt: Variablen sind innerhalb des textuellen Codeblocks sichtbar, in dem sie deklariert wurden. Funktionen sind ab ihrer Deklaration in der gesamten Datei sichtbar. Definition (Lifetime) Die Lifetime (Lebenszeit) einer Variablen beschreibt den Zeitraum, in dem der Speicherbereich der Variablen für sie reserviert ist. Grundregel: Eine Variable existiert vom Moment ihrer Deklaration bis zu dem Zeitpunkt, an dem der Block, welcher die Deklaration umschließt, verlassen wird.

16 Lokale und globale Variablen Lokale Variablen Lokale Variablen werden zu Beginn eines Anweisungsblocks deklariert. Lifetime: Bis zum Ende des Anweisungsblocks, also auch in inneren Blöcken Scope: Innerhalb des Blocks, sofern sie nicht durch Variablen gleichen Namens in untergeordneten Blöcken überdeckt werden Funktionen liegen textuell außerhalb jedes anderen Blocks lokale Variablen sind dort generell nicht sichtbar. Globale Variablen Globale Variablen werden außerhalb aller Funktionen (einschl. main) deklariert. Namenskonvention: Unterstrich am Ende des Namens, z. B. int var_ = 42; Lifetime: Gesamte Dauer der Programmausführung (auch über Dateigrenzen hinweg später) Scope: Überall (auch in Funktionen) Gefahren: Namenskonflikte, unkontrollierte Manipulation, Chaos Nutzung globaler Variablen auf ein Minimum reduzieren!

17 Sichtbarkeit: Beispiel 1 1 #include <stdio.h> 2 3 int main(void) 4 { 5 int a = 4; 6 { 7 int a = 5; 8 printf("innen: a = %d\n", a); 9 } 10 printf("aussen: a = %d\n", a); return 0; 13 } Ausgabe: Innen: a = 5 Aussen: a = 4

18 Sichtbarkeit: Beispiel 2 1 #include <stdio.h> 2 3 int main(void) 4 { 5 int i; 6 7 for (i=5; i<10; i++) 8 { 9 int i=0; 10 i++; 11 printf("in Schleife: i = %2d\n", i); 12 } printf("nach Schleife: i = %2d\n", i); 15 return 0; 16 } Ausgabe: In Schleife: i = 1 In Schleife: i = 1 In Schleife: i = 1 In Schleife: i = 1 In Schleife: i = 1 Nach Schleife: i = 10

19 Lokale und globale Variablen 1 #include <stdio.h> 2 3 int a_ = 10; // globale Variable 4 5 int funktion(int); 6 void prozedur(void); 7 8 int main(void) 9 { 10 prozedur(); 11 prozedur(); 12 funktion(a_); 13 printf("a_ = %d\n", a_); 14 return 0; 15 } void prozedur(void) 18 { 19 a_ *= a_; 20 return; 21 } int funktion(int a_) // schlechter Stil: nur globale Variablen 24 { // sollten mit "_" enden! 25 return(--a_); 26 } Ausgabe: a_ = 10000

20 Automatische und statische Variablen Bisher waren alle Variablen automatische Variablen, d.h. sie existieren bis zu dem Zeitpunkt, an dem der Block, welcher die Deklaration umschließt, verlassen wird. Statische Variablen Möglichkeit, dass eine Funktion beim nächsten Durchlauf die Information, die in der Variablen gespeichert wurde, verwenden kann (wie in einem Gedächtnis) Sichtbarkeit: Innerhalb des Blocks, sofern sie nicht durch Variablen gleichen Namens in untergeordneten Blöcken überdeckt werden Deklaration: static Datentyp Name=Wert; Beispiel: 1 void zaehle() { 2 static int i = 1; // i wird (nur) beim ersten Aufruf von zaehle initialisiert 3 printf("%d\n", i); 4 i = i + 1; 5 }

21 Rekursive Programmierung Rekursion Aufruf einer Funktion durch sich selbst. Iteration Wiederholung eines Anweisungsblocks. Bemerkungen zur rekursiven Programmierung: Man muss die Schachtelungstiefe der Rekursion selbst überwachen, sonst kann es zum sog. Stapelüberlauf (engl. stack overflow) kommen. Meist sind Iteration und Rekursion äquivalent, aber häufig ist die Überführung in die jeweils andere Variante nicht offensichtlich. Je nach Fragestellung (Laufzeit-, Speicher-, Lesbarkeitsoptimierung) entscheidet man sich für eine der beiden Methoden. Viele effiziente Sortieralgorithmen oder Divide-and-Conquer-Techniken basieren auf dem Prinzip der Rekursion.

22 Rekursive Programmierung Einfaches Beispiel: Fakultät n! = n(n 1) 1 = fac(n) Es gilt: fac(n) = { n * fac(n-1), n > 1 1, n {0, 1} Interessanteres Beispiel: Quersumme einer natürlichen Zahl Algorithmus 1 Die Quersumme einer einstelligen Zahl ist die Zahl selbst. 2 Die Quersumme einer mehrstelligen Zahl ist die Summe der letzten Ziffer und der Quersumme der Zahl ohne ihre letzte Ziffer. Beispiel: Quersumme(5) = 5 Quersumme (31415) = Quersumme (3141) + 5

23 Quersumme iterativ 1 #include <stdio.h> 2 3 int main(void) 4 { 5 int zahl, qsumme = 0; 6 7 printf("zahl = "); 8 scanf("%d", &zahl); 9 10 printf("quersumme(%d) = ", zahl); while (zahl) 13 { 14 qsumme += zahl % 10; 15 zahl /= 10; 16 } printf("%d\n", qsumme); return 0; 21 }

24 Quersumme rekursiv 1 #include <stdio.h> 2 3 int qsumme(int); 4 5 int main(void) 6 { 7 int zahl; 8 printf("zahl = "); 9 scanf("%d", &zahl); printf("\nquersumme(%d) = %d\n",zahl, qsumme(zahl)); return 0; 14 } int qsumme(int zahl) 18 { 19 if (zahl / 10) 20 return zahl % 10 + qsumme(zahl / 10); return zahl; 23 }

25 Funktionen elementare Merkregeln Deklaration und Definition Die Funktionsdeklaration steht im Code vor main. Die Funktionsdefinition kommt ans Ende der Datei (unauffällig versteckt ). Anzahl und Datentypen der Parameter sowie Rückgabetyp müssen übereinstimmen. Guter Stil: Deklaration mit Kommentar versehen, der Parameter und Rückgabewert erläutert Der Name soll die Tätigkeit (Rückgabetyp void) bzw. den zurückgegebenen Wert (nichtleerer Rückgabetyp) widerspiegeln. Jede Funktion sollte durch ein return [Wert]; beendet werden. Aufruf Die Anzahl der Parameter muss konsistent mit der Deklaration sein. Es findet Call by value statt, d. h. die Funktion hat nicht die Parameter selbst, sondern nur die darin gespeicherten Werte zur Verfügung. Daher können diese auch nicht permanent verändert werden! Die übergebenen Werte werden automatisch in die Datentypen laut Deklaration umgewandelt ( gecastet ). Bei inkompatiblen Typen warnt der Compiler lediglich. Funktionen sehen nur globale Variablen, übergebene Parameter sowie lokale Variablen im Funktionsrumpf.

26 Statische Felder Definition Ein Feld (engl. array) ist die Zusammenfassung von Elementen gleichen Typs zu einer aufrufbaren Einheit. Deklaration: Datentyp Feldname[Anzahl]; Legt ein Feld von Anzahl Elementen des Typs Datentyp an. Achtung: Anzahl muss ein positiver ganzzahliger Wert sein. Wie bei primitiven Datentypen ist eine Initialisierung bei der Deklaration möglich: int N[4] = {1, 3, -5, 42}; double x[] = {1.9, , 5.73e+21}; // Die Groesse (3) wird hier vom Compiler automatisch bestimmt int p = 23; unsigned j[p] = {1, 0, 3}; float y[2] = {1.0, 3, -7.2}; // Wichtig: p initialisieren! // Rest bleibt uninitialisiert // Fehler: zu viele Elemente!

27 Statische Felder Die Deklaration float x[5]; legt ein Feld der Länge 5 an. Die Komponenten (Feldeinträge, Feldelemente) sind dabei alle vom Typ float. Folgerung: Das Feld mit Bezeichner x belegt im Arbeitsspeicher 5 4 = 20 Byte. Auf die Komponenten kann mittels x[0], x[1], x[2], x[3] und x[4] zugegriffen werden. Beispiel: x[0] = 11.0; x[1] = 12.0; x[2] = 13.0; x[3] = 14.0; x[4] = 15.0; Merke: Die Indizierung von Feldeinträgen beginnt in C stets mit 0! 1. Komp. 2. Komp. 3. Komp. 4. Komp. 5. Komp. 4 Byte 4 Byte 4 Byte 4 Byte 4 Byte Größe x[0] x[1] x[2] x[3] x[4] "Name" Inhalt Merke: Alle Komponenten eines Feldes werden vom Compiler direkt hintereinander im Arbeitsspeicher abgelegt.

28 Einschränkungen und Stolperfallen Einmal festgelegt, kann die Größe eines statischen Feldes nicht mehr verändert werden. Der maximalen Größe eines Feldes sind enge Grenzen gesetzt (Gefahr eines stack overflow = Stapelüberlauf). Die Rückgabe eines Feldes durch eine Funktion oder die Übergabe eines Feldes als Parameter einer Funktion ist nicht möglich, da es sich nicht um einen primitiven, sondern einen zusammengesetzten Datentyp handelt. Beim Zugriff auf ein Feldelement außerhalb des zulässigen Indexbereichs erfolgt im allgemeinen keine Fehlermeldung! Auch der Compiler warnt nicht! Die Zuweisung x[7] = schreibt in den Bereich, der (zufällig) von alpha belegt wird. Mögliche Folge: Das Programm wird völlig unberechenbar! Häufigste Fehlerquelle: int x[n];... x[n] = 1; Tritt zumeist dann auf, wenn x[1] statt x[0] als erster Eintrag interpretiert wird.

29 Beispiel: Euklidische Norm eines Vektors im R 3 1 #include <stdio.h> 2 #include <math.h> 3 4 int main(void) 5 { 6 double x[3], norm2 = 0.0, norm; 7 int i; 8 9 // Vektor einlesen 10 for (i=0; i<3; i++) // Vorsicht: Indices beginnen bei 0! 11 { 12 printf("geben Sie die %d-te Komponente ein: ", i+1); 13 scanf("%lf", &x[i]); 14 } // Vektor ausgeben 17 printf("\nder Vektor hat folgende Eintraege:\n"); 18 for (i=0; i<3; i++) 19 printf("x[%d] = % 7.4lf\n", i, x[i]); // Berechnung der Summe der Komponentenquadrate 22 for (i=0; i<3; i++) 23 norm2 += x[i]*x[i]; norm = sqrt(norm2); // euklidische Norm printf("\ndie Norm des Vektors ist %.4lf.\n\n", norm); 28 return 0; 29 }

30 Beispiel: Euklidische Norm eines Vektors im R 3 Ausgabe: Geben Sie die 1-te Komponente ein: 1 Geben Sie die 2-te Komponente ein: -2 Geben Sie die 3-te Komponente ein: 2 Der Vektor hat folgende Eintraege: x[0] = x[1] = x[2] = Die Norm des Vektors ist

31 Mehrdimensionale Felder Deklaration: Datentyp Feldname[dim1][dim2]...[dimN]; Beachte: A[4][3] wird (unabhängig vom Typ) im Speicher zeilenweise abgelegt: A[0][0], A[0][1], A[0][2], A[1][0],..., A[1][2], A[2][0],..., A[3][2] Mathematische Interpretation: A = (a ij ) 1 i 4 R j 3 A[0][0] A[0][1] A[0][2] a 11 a 12 a 13 A[1][0] A[1][1] A[1][2] a 21 a 22 a 23 A[2][0] A[2][1] A[2][2] a 31 a 32 a 33 A[3][0] A[3][1] A[3][2] a 41 a 42 a 43

32 2D-Felder als Matrizen Beispiel: Zeilenweises Einlesen der Komponenten einer 2 3-Matrix vom Typ int 1 #include <stdio.h> 2 3 int main(void) 4 { 5 int i, j; 6 int A[2][3]; 7 8 for(i=0; i<2; i++) 9 { 10 for(j=0; j<3; j++) 11 { 12 printf("a[%d][%d] = ", i, j); 13 scanf("%d", &A[i][j]); 14 } // for j 15 } // for i return 0; 18 }

33 2D-Felder als Matrizen Auch bei mehrdimensionalen Feldern ist eine direkte Initialisierung möglich, bspw. int A[3][2] = {{11,12},{21,22},{31,32}}; Da die Komponenten im Speicher in einer Reihe angeordnet sind, ist obige Zeile äquivalent zu int A[3][2] = {11,12,21,22,31,32}; Erfolgt bei der Deklaration eine partielle Initialisierung, so wird mit Nullen aufgefüllt: int A[3][3] = {{1,2},{3},{4,5}}; generiert die Matrix A = [ 1 ]