Übungspaket 13 Der Datentyp double Übungsziele: Skript: 1. Umgang mit dem Datentyp double, 2. Deklarationen von double-variablen, 3. double-konstanten 4. und double-rechenoperationen. Kapitel: 32 Semester: Wintersemester 2017/18 Betreuer: Kevin, Theo, Thomas und Ralf Synopsis: In diesem Übungspaket gibt es einiges zum Thema Fest- bzw. Fließkommazahlen. Die Struktur der Aufgaben ähnelt sehr den vorherigen. Neben der eigentlichen Verarbeitung von Fließkommazahlen ist die Umwandlung von Werten des Datentyps int in den Datentyp double und umgekehrt Gegenstand der Aufgaben.
Teil I: Stoffwiederholung Aufgabe 1: Konstanten In Skript und Vorlesung haben wir zwei Möglichkeiten (Festkomma- und Exponentialform) kennen gelernt, mittels derer man Gleitkommazahlen notieren kann. Aus welchen vier Komponenten kann eine Gleitkommazahl bestehen? 1. Vorzeichen der Zahl 2. Mantisse 3. Vorzeichen des Exponenten 4. Exponent Durch die Möglichkeit, einzelne Teile quasi weg zu lassen bzw. stark zu verkürzen gibt es reichlich Kombinationsmöglichkeiten, die teilweise fast schon abstrus aussehen. Bilde mindestens zehn Zahlen, anfangs einfache, am Ende möglichst merkwürdig aussehende. Im Zweifelsfalle immer mal das Syntaxdiagramm aus Kapitel 32 konsultieren. C-Syntax Wert C-Syntax Wert C-Syntax Wert 123.456 123,456 -.123-0,123 1.2E-3 0,0012 -.056E3-56,0-4.5E1-45,0 20E-2 0,2 0.1E2 10,0 1E2 100,0 -.1-0,1-1E-4-0,0001.2E2 22,0-2E2-200,0 Aufgabe 2: Ein- und Ausgabe In Skript und Vorlesung haben wir kurz erwähnt, dass double-werte mittels %lf und %e ein- und ausgegeben werden können. Die Möglichkeiten sind vielfältig, wie man beispielsweise auf der Manual Page (man 3 printf) sehen kann. Ziel dieser Aufgabe ist es, diese Möglichkeiten ein wenig auszuloten. Schreibe dazu ein kleines Testprogramm, das mindestens zehn unterschiedliche Ausgabeformatierungen mit jeweils einem aktuellen Wert ausgibt. Notiere die verwendeten Formatierungen und Ausgaben in folgender Tabelle. Format Wert Ausgabe %8.1f 123.456 123.4 %8.2f 123.456 123.45 %8.3f 123.456 123.456 %8.4f 123.456 123.4560 %5.3f 123.456 123.456 Format Wert Ausgabe %8.1e 123.456 1.2e+02 %8.2e 123.456 1.23e+02 %8.3e 123.456 1.235e+02 %8.4e 123.456 1.2346e+02 %8.5e 123.456 1.23456e+02 Einführung in die Praktische Informatik, Wintersemester 2017/18 13-1
Teil II: Quiz Aufgabe 1: Ausdrücke: double versus int Selbst bei fortgeschrittenen Programmierern gibt es immer wieder Fragezeichen im Gesicht, wenn in Ausdrücken double und int-werte bzw. Variablen gemischt auftauchen. Die beiden Grundregeln lauten: 1. Vor Ausführung einer arithmetischen Operation werden beide Operanden in den selben (größeren) Datentyp gewandelt. 2. Beim Zuweisen eines Gleitkommawertes an eine int-variable werden die Nachkommastellen immer abgeschnitten. Für das folgende Quiz gilt: int i1 = 2, i2 = 3 und double d1 = 2.0, d2 = 5.0. Ausdruck Typ Wert 1 + 2 int 3 2.0 + 3.0 double 5.0 2 + 4.0 double 6.0 2.0*(3 + 4) double 14.0 i1 + i2 int 5 2 + d2 double 7.0 d1 - d2 - i1 double -5.0 Ausdruck Typ Wert 16 / 5 int 3 17 / 6 int 2 15 / 6.0 double 2.5 i2 / 4 int 0 (i1 + i2) / 2.0 double 2.5 i1/(i2 - i1-1) --- Fehler d1/(i2 - i1-1) double Aufgabe 2: Ausgaben Wie sehen die resultierenden Ausgaben aus? Anweisung Ausgabe printf("%f",123.456) 123.456000 printf("%e",12.34) 1.234000e+01 printf("%6.2f",123.4) 123.40 printf("%9.4f",123.4) 123.4000 printf("%6.2f",-1.2) -1.20 Anweisung Ausgabe printf("%6.2f",-.1234) -0.12 printf("%6.2f",-1234.) -1234.00 printf("%9.3e",12.34) 1.234e+01 printf("%9.1e",-12.34) -1.2e+01 printf("%9.1e",12.34) 1.2e+01 13-2 Wintersemester 2017/18, Einführung in die Praktische Informatik
Teil III: Fehlersuche Aufgabe 1: Verarbeitung von Fließkommazahlen Das folgende Programm soll alle Zahlen von 1.0, 1.1, 1.2,..., 1.8 aufsummiert und das Ergebnis in Form von xxx.xx ausgeben. Leider sind wieder ein paar Fehler versteckt, die ihr finden sollt. 1 # include <stdio h> 2 3 int main ( int argc ; char ** argv ) 4 { 5 double x. deltax, sum ; 6 sum = 0; deltax = 0,1; 7 for ( x = 1. 0; x < 1.75, x = x deltax ) 8 sum = sum * x; 9 printf ( " summe = %6.2 e\n", summe ); 10 } Zeile Fehler Erläuterung Korrektur 1 include Die #include-direktive schreibt sich mit kleinem l. include.............................................................................................................................................. 3 ; statt, Die Parameter müssen mit einem Komma voneinander getrennt werden.,.............................................................................................................................................. 5. statt, Die Parameter müssen mit einem Komma voneinander getrennt werden............................................................................................................................................... 6, statt. Gleitpunktzahlen werden nicht mit einem Komma sondern einem Punkt notiert, da es sich bei C um eine englischsprachige Programmiersprache handelt............................................................................................................................................... 7 1.75 Da die Schleifenbedingung x < 1.75lautet, wird die 1.8 nicht, wie eigentlich gefordert, berücksichtigt.,. 1.85.............................................................................................................................................. 7, statt ; In der for-schleife werden die einzelnen Teile mittels Semikolons voneinander getrennt. ;.............................................................................................................................................. 7 fehlendes + Es fehlt der Operator zum aktualisieren des x-wertes. +.............................................................................................................................................. 8 * statt + Zum Bilden der Summe muss der +-Operator verdented werden. +.............................................................................................................................................. 9 falsche Formatierung Da die Ausgabe im Festkommaformat erfolgen soll, muss ein f zur Formatierung verwendet werden. %6.2f Einführung in die Praktische Informatik, Wintersemester 2017/18 13-3
Programm mit Korrekturen: Das folgende Programm entspricht dem vorherigen, in dem die vorhandenen Fehler behoben wurden. 1 # include <stdio.h> 2 3 int main ( int argc, char ** argv ) 4 { 5 double x, deltax, sum ; 6 sum = 0. 0; deltax = 0. 1; 7 for ( x = 1. 0; x < 1. 85; x = x + deltax ) 8 sum = sum + x; 9 printf ( " summe = %6.2 f\n", sum ); 10 } 13-4 Wintersemester 2017/18, Einführung in die Praktische Informatik
Teil IV: Anwendungen Aufgabe 1: Umwandlung von double nach int 1. Aufgabenstellung Jedem sollte klar sein, dass der Datentyp int nur eine Untermenge des Datentyps double ist. Entsprechend muss man sich bei der Konvertierung von double nach int Gedanken darüber machen, ob man rundet oder abschneidet. Wie im Skript erläutert, wird in der Programmiersprache C generell abgeschnitten. Daher sollt Ihr in dieser Übungsaufgabe ein Stück Programm entwickeln, das bei der Konvertierung rundet. Dabei ist darauf zu achten, dass auch negative Zahlen richtig gerundet werden. 2. Pflichtenheft Aufgabe : Wandlung von double-werte in int-werte mit Rundung Eingabe : ein double-wert Ausgabe : ein int-wert Vorüberlegungen : Beim Runden von Zahlen muss man zwischen positiven und negativen Zahlen unterscheiden. Positive Zahlen werden ab.5 aufsonst abgerundet. Beispiel: 3.5 wird auf 4 aufgerundet, wohingegen 3.3 auf 3 abgerundet wird. Negative Zahlen werden genau andersherum behandelt. Beispielsweise wird eine -2.6 auf -3 abgerundet, wohingegen eine -2.45 auf -2 aufgerundet wird. 3. Testdaten Eingabe: 0 0.1-0.1 3.4 3.5-5 -5.4-5.5 Ausgabe: 0 0 0 3 4-5 -5-6 4. Implementierung Das Runden positiver Zahlen kann man erreichen, wenn man zuerst 0.5 addiert und anschließend die Nachkommastellen abschneidet. Bei negativen Zahlen muss man statt dessen 0.5 subtrahieren. Für die Konvertierung eignet sich folgender Ansatz: Runden von double-zahlen Variablen: Double: in Integer: out wenn in >= 0.0 dann out = in + 0.5 sonst out = in - 0.5 Einführung in die Praktische Informatik, Wintersemester 2017/18 13-5
5. Kodierung 1 # include <stdio.h> 2 3 int main ( int argc, char ** argv ) 4 { 5 double in; 6 int out ; 7 printf ( " Bitte reele Zahl eingeben : " ); 8 scanf ( "%lf", & in ); 9 if ( in >= 0.0 ) 10 out = in + 0. 5; 11 else out = in - 0. 5; 12 printf ( "in: %6.3 f out : %d\n", in, out ); 13 } Aufgabe 2: Drucken einer tabellierten Sinus-Funktion 1. Aufgabenstellung In der Schule konnten wir die Sinus-Werte für gegebene Winkelargumente in verschiedenen Tafeln nachschlagen. Heutzutage sind diese Tafeln nicht mehr so verbreitet wie früher. Daher entwickeln wir in dieser Übungsaufgabe ein kleines Programm, das uns die Sinus-Werte in einem gegebenen Bereich tabellarisch ausgibt. Entwickle ein Programm, das n Wertepaare, bestehend aus dem Argument und dem korrespondierendem Funktionswert, im Intervall [x min..x max ] in Tabellenform ausgibt. Für x min = 0, x max = 90 und n = 10 könnte die Ausgabe wie folgt aussehen: x sin (x) ---------+--------- 0. 0000 0. 00000 10.0000 0.17365 20.0000 0.34202 30.0000 0.50000 40.0000 0.64279 50.0000 0.76604 60.0000 0.86603 70.0000 0.93969 80.0000 0.98481 90.0000 1.00000 Bei Interesse kann das Programm auch dahingehend erweitert werden, dass es die Parameter x min, x max und n interaktiv einliest. 13-6 Wintersemester 2017/18, Einführung in die Praktische Informatik
2. Pflichtenheft Aufgabe : tabellarische Darstellung von x und sin x Eingabe : x min, x max und n Ausgabe : Tabelle mit Tabellenkopf Sonderfälle : 1. Test ob n > 0 und 2. Test ob x min < x max ggf. Fehlermeldung ausgeben und Programm abbrechen 3. Testdaten x min x max n 0 90 10 0 90 2-90 90 20 4. Implementierung Ausgehend von der Aufgabenstellung können wir folgende Überlegungen anstellen. Erstens müssen wir die notwendigen Parameter x min, x max und n einlesen und diese auf ihre Plausibilität prüfen. Sollte alles ok sein, müssen wir die Tabelle drucken. Da diese neben dem Tabellenkopf aus genau n Zeilen besteht, sollten wir hierfür eine for-schleife nehmen. Das Berechnen der Funktionswerte und Ausgeben beider Zahlen ist für uns mittlerweile recht einfach. Erstellen einer tabellierten Sinus-Funktion Variablen: Double: x, x min, x max, f Integer: n, i Lese wenn dann x min und x max x min < x max Lese n wenn n > 1 dann Tabellenkopf ausgeben für i = 0 bis n schrittweite 1 wiederhole setze x = x min + i*(x max - x min)/(n - 1) setze f = sin(x) Ausgabe x und f sonst Fehlermeldung ausgeben sonst Fehlermeldung ausgeben Das ist wieder nur eine von vielen Lösungsmöglichkeiten. Am besten vergleicht ihr wieder eure Lösung mit der hier vorgestellten und analysiert die Unterschiede. Einführung in die Praktische Informatik, Wintersemester 2017/18 13-7
5. Kodierung Hinweise: 1. Die sin()-funktion und die Konstante M PI (für π) sind in math.h definiert. 2. Beim Binden müsst Ihr die Option -lm angeben, damit die sin()-funktion auch dazu gebunden wird. Beispiel: gcc supi-ich.c -o supi-ich -lm 3. Schaut euch in der Dokumentation an, was für Argumente die sin()-funktion erwartet. 1 # include <stdio.h> 2 # include <math.h> 3 4 int main ( int argc, char ** argv ) 5 { 6 double x, f, x_min, x_max ; 7 int i, n; 8 printf ( " Bitte folgende Parameter eingeben \ n" ); 9 printf ( " xmin : " ); scanf ( "%lf", & x_min ); 10 printf ( " xmax : " ); scanf ( "%lf", & x_max ); 11 if ( x_ min < x_ max ) 12 { 13 printf ( "n : " ); scanf ( "%d", & n ); 14 if ( n > 1 ) 15 { 16 printf ( "\n" ); 17 printf ( " x sin (x)\n" ); 18 printf ( " ---------+----------\n" ); 19 for ( i = 0; i < n; i = i + 1 ) 20 { 21 x = x_min + i*( x_max - x_min )/(n - 1); 22 f = sin ( x * 2.0 * M_ PI / 360. 0 ); 23 printf ( " %8.4 f %8.5 f\n", x, f ); 24 } 25 } 26 else printf ( " Sorry, n > 1 muss gelten \ n" ); 27 } 28 else printf ( " Sorry, xmin < xmax muss gelten \ n" ); 29 return 0; 30 } 13-8 Wintersemester 2017/18, Einführung in die Praktische Informatik
Die auf der vorherigen Seite gezeigte Lösung entspricht dem traditionellen Vorgehen des Software Eningeerings, nach dem ein Programm oder eine Funktion eine Stelle hat, an der sie ihre Arbeit beendet hat. Dies ist die Letzte Zeile. Viele C- Programmierer bevorzugen einen anderen Stil, den wir beispielhaft auf der nächsten Seite zeigen. Das Schema ist, dass die Tests nach Fehlern schauen und das Programm ggf. mitten drin beenden. Dies erkennt man daran, dass es nach einer Fehlerausgabe eine entsprechende return-anweisung gibt. 1 # include <stdio.h> 2 # include <math.h> 3 4 int main ( int argc, char ** argv ) 5 { 6 double x, f, x_min, x_max ; 7 int i, n; 8 printf ( " Bitte folgende Parameter eingeben \ n" ); 9 printf ( " xmin : " ); scanf ( "%lf", & x_min ); 10 printf ( " xmax : " ); scanf ( "%lf", & x_max ); 11 if ( x_ min >= x_ max ) 12 { 13 printf (" Sorry, es muss gelten : xmin < xmax!\n"); 14 return 1; 15 } 16 printf ( "n : " ); scanf ( "%d", & n ); 17 if ( n <= 1 ) 18 { 19 printf ( " Sorry, es muss gelten : n > 1!\ n" ); 20 return 1; 21 } 22 printf ( "\n" ); 23 printf ( " x sin (x)\n" ); 24 printf ( " ---------+----------\n" ); 25 for ( i = 0; i < n; i = i + 1 ) 26 { 27 x = x_min + i*( x_max - x_min )/(n - 1); 28 f = sin ( x * 2.0 * M_ PI / 360. 0 ); 29 printf ( " %8.4 f %8.5 f\n", x, f ); 30 } 31 } Probiert beide Stile einfach aus und findet denjenigen, mit dem ihr am besten zurecht kommt. Einführung in die Praktische Informatik, Wintersemester 2017/18 13-9
Aufgabe 3: Euro-Dollar Konvertierung 1. Aufgabenstellung Manchmal fliegt man in die USA um Urlaub zu machen oder um zu arbeiten. Entsprechend muss man auch Geld wechseln ;-) Entwickle ein Programm, das zuerst den Wechselkurs einliest, und anschließend nacheinander Dollar-Beträge einliest, in Euro-Beträge wandelt und diese ausgibt. 2. Pflichtenheft Da mehrere Euro-Beträge verarbeitet werden sollen, ist die Schleifenbedingung eine wesentliche Frage des Pflichtenheftes. Aufgabe : tabellarisches Darstellen von Euro und Dollar-Beträgen Eingabe : Wechselkurs und beliebig viele Euro-Beträge Ausgabe : Euro und Dollarbeträge Sonderfälle : Negative Wechselkurse sind nicht zulässig Abbruchbedingung : Negative Euro-Beträge beenden das Programm 3. Testdaten Wechselkurs Euro-Betrag 1.00 10.00 11.11 86.12 13.24 1.34 Dollar-Betrag 1.34 13.40 14.89 115.14 17.74 4. Implementierung Gemäß Aufgabenstellung muss ein Wechselkurs eingelesen werden. Dieser muss positiv sein. Anschließend sollen beliebig viele Dollar-Beträge gelesen und in Euro- Beträge umgerechnet werden. Dies wird solange wiederholt, bis ein negativer Dollar- Betrag eingegeben wird. Da sich also das Ende der Schleife erst durch die Nutzereingaben ergibt, wählen wir eine while-schleife. Der Rest ist eigentlich relativ einfach. Programm zum ermitteln von Eurobeträgen Variablen: Double: wechselkurs, euro, dollar lese wechelkurs wenn wechselkurs > 0 dann lese dollar solange dollar >= 0 wiederhole setze euro = dollar * wechselkurs ausgabe euro und dollar lese dollar sonst Ausgabe Fehlermeldung 13-10 Wintersemester 2017/18, Einführung in die Praktische Informatik
5. Kodierung 1 # include <stdio.h> 2 3 int main ( int argc, char ** argv ) 4 { 5 double exrate, euro, dollar ; 6 printf ( " Bitte Wechselkurs eingeben : " ); 7 scanf ( "%lf", & exrate ); 8 printf ( " Bitte Dollar - Betrag eingeben : " ); 9 scanf ( "%lf", & dollar ); 10 while ( dollar >= 0.0 ) 11 { 12 euro = dollar * exrate ; 13 printf ( " euro = %6.2 f dollar = %6.2 f\n", 14 euro, dollar ); 15 printf ( " Bitte Dollar - Betrag eingeben : " ); 16 scanf ( "%lf", & dollar ); 17 } 18 } Aufgabe 4: Reihenschaltung von Widerständen 1. Aufgabenstellung Die Aneinanderreihung von n Widerständen R 1,..., R n führt zu einem Reihenwiderstand R = R 1 +... + R n = n i=i R i. Entwickle ein Programm, dass der Reihe nach verschiedene Widerstandswerte einliest, den Gesamtwiderstand ausrechnet und diesen am Ende ausgibt. Bei dieser Aufgabe steht die Zahl der einzulesenden Werte nicht fest, sondern soll durch die Eingabe eines geeigneten Wertes erkannt werden. Hinweis: Die Wahl der Schleifenbedingung und der verwendeten Datentypen sollte pragmatisch und nicht esotherisch erfolgen ;-) Das betrifft auch die Zahl der Nachkommastellen. 2. Pflichtenheft Aufgabe : Berechnen eines resultierenden Reihenwiderstandes Eingabe : Eine beliebige Zahl von Widerstandswerten Ausgabe : Der resultierende Reihenwiderstand wird ausgegeben Sonderfälle : Negative Widerstandswerte sind nicht zulässig Abbruchbedingung : Die Eingabe eines negativen Widerstandswertes beendet das Programm Einführung in die Praktische Informatik, Wintersemester 2017/18 13-11
3. Testdaten Widerstandswerte Resultat 1.0 14.0 101.0 116.0 13.4 13.4 1.0 1.0 2.0 3.0 3.0 4.0 14.0 4. Implementierung Diese Aufgabenstellung ist äußerst einfach: Wir müssen nur der Reihe nach Widerstandswerte einlesen und aufaddieren. Da sich die Zahl der Wiederholungen erst durch die Nutzereingaben ergibt, wählen wir wieder eine while-schleife. Negative Widerstandswerte beenden die Schleife. Am Ende geben wir noch eine schöne Ergebniszeile aus. Programm zur Berechnung in Reihe geschalteter Widerstände Variablen: Double: r, total setze total = 0.0 lese r solange r >= 0 wiederhole setze total = total + r lese r Ausgabe: Text: "Gesamwiderstand" Wert: total 5. Kodierung 1 # include <stdio.h> 2 3 int main ( int argc, char ** argv ) 4 { 5 double r, total ; 6 printf ( " Bitte Widerstandswert eingeben : " ); 7 total = 0. 0; 8 scanf ( "%lf", & r ); 9 while ( r >= 0 ) 10 { 11 total = total + r; 12 printf ( " Bitte Widerstandswert eingeben : " ); 13 scanf ( "%lf", & r ); 14 } 15 printf ( " Gesamtwiderstand : %6.1 f\n", total ); 16 } 13-12 Wintersemester 2017/18, Einführung in die Praktische Informatik
Aufgabe 5: Parallelschaltung von Widerständen 1. Aufgabenstellung Die Parallelschaltung von n Widerständen R 1,..., R n führt zu einem Gesamtwiderstand R = 1/(1/R 1 +... + 1/R n ) = 1/( n i=i 1/R i ). In der Elektrotechnik ist auch folgende Schreibweise üblich: 1/R = (1/R 1 +... + 1/R n ) = n i=i 1/R i. Diese Aufgabe ist naturgemäß deutlich schwieriger als die vorherige. Da sie aber zu den Standardaufgaben eines Elektrotechnikers gehört, sollten wir sie unbedingt bearbeiten. Entwickle ein Programm, das der Reihe nach verschiedene Widerstandswerte einliest, den Gesamtwiderstand der Parallelschaltung dieser Widerstände ausrechnet und diesen am Ende ausgibt. Bei dieser Aufgabe steht die Zahl der einzulesenden Werte nicht fest, sondern soll durch die Eingabe eines geeigneten Wertes erkannt werden. Hinweis: Die Wahl der Schleifenbedingung und der verwendenden Datentypen sollte pragmatisch und nicht esotherisch erfolgen ;-) 2. Pflichtenheft Aufgabe Eingabe Ausgabe Sonderfälle : Berechnen eines resultierenden Parallelwiderstandes : Eine beliebige Zahl von Widerstandswerten : Der resultierende Parallelwiderstand wird ausgegeben : Widerstandswerte, die kleiner oder gleich null sind, sind nicht zulässig Abbruchbedingung : Die Eingabe eines Widerstandswertes, der kleiner oder gleich null ist, beendet das Programm 3. Testdaten Widerstandswerte Resultat 2.0 2.0 2.0 0.7 13.4 13.4 10.0 67.0 35.0 13.0 89.0 40.0 3.9 Einführung in die Praktische Informatik, Wintersemester 2017/18 13-13
4. Implementierung Diese Aufgabe so ähnlich wie die vorherige. Entsprechend gelten die dort gemachten Vorüberlegungen auch hier. Da wir aber eine Division durch Null vermeiden müssen, sind jetzt nur noch strikt positive Widerstandswerte erlaubt. Programm zur Berechnung einer Parallelschaltung Variablen: Double: r, total setze total = 0.0 lese r solange r > 0 wiederhole setze total = total + 1.0 / r lese r wenn total > 0.0 dann ausgabe 1.0 / total sonst Ausgabe Fehlermeldung 5. Kodierung 1 # include <stdio.h> 2 3 int main ( int argc, char ** argv ) 4 { 5 double r, total = 0. 0; 6 printf ( " Bitte Widerstandswert eingeben : " ); 7 scanf ( "%lf", & r ); 8 while ( r > 0 ) 9 { 10 total = total + 1.0 / r; 11 printf ( " Bitte Widerstandswert eingeben : " ); 12 scanf ( "%lf", & r ); 13 } 14 if ( total > 0.0 ) 15 printf ( " Gesamtwiderstand : %6.1 f\n", 1/ total ); 16 else printf ( " Leider wurde kein Wert eingeben \ n"); 17 } 13-14 Wintersemester 2017/18, Einführung in die Praktische Informatik