Die Präsentation wird geladen. Bitte warten

Die Präsentation wird geladen. Bitte warten

DVG1 - Modulare Programmierung 1 Modulare Programmierung.

Ähnliche Präsentationen


Präsentation zum Thema: "DVG1 - Modulare Programmierung 1 Modulare Programmierung."—  Präsentation transkript:

1 DVG1 - Modulare Programmierung 1 Modulare Programmierung

2 DVG1 - Modulare Programmierung 2 Beispiel Schreiben Sie ein Programm, das eine Tabelle erzeugt, die für i=1,7,49,...< die Werte i, sqrt(i) und ( double)i*i enthält. i | sqrt(i) | i*i | E+00 | E+00 7 | E+00 | E | E+00 | E | E+01 | E | E+01 | E | E+02 | E | E+02 | E | E+02 | E | E+03 | E | E+03 | E | E+04 | E+16

3 DVG1 - Modulare Programmierung 3 0.te Näherung public class t1 { public static void main(String [] args) { System.out.println( "\n i | sqrt(i) | i*i"); System.out.println( " "); for (long i=1;i< ;i*=7) System.out.println(i+" | "+Math.sqrt(i)+" | "+(double)i*i); } }

4 DVG1 - Modulare Programmierung 4 Ergebnis der 0.ten Näherung i | sqrt(i) | i*i | 1.0 | | | | 7.0 | | | | 49.0 | | | E | | E | | E | | E | | E | | E16

5 DVG1 - Modulare Programmierung 5 1.te Näherung public class t1 { public static void main(String [] args) { System.out.println( "\n i | sqrt(i) | i*i"); System.out.println( " "); for (long i=1;i< ;i*=7) System.out.println(i+"\t| "+Math.sqrt(i)+"\t| "+(double)i*i); } }

6 DVG1 - Modulare Programmierung 6 Ergebnis der 1.ten Näherung i | sqrt(i) | i*i | 1.0| 1.0 7| | | 7.0| | | | 49.0| | | E | 343.0| E | | E | | E | | E | | E16

7 DVG1 - Modulare Programmierung 7 Probleme n Die Wirkung von Tabulatoren ist nicht vollständig durch das Programm beeinflußbar. n Zahlen sollten rechtsbündig ausgegeben werden. n Das Format von Gleitkommazahlen hängt sehr von dem Wert ab und ist somit nicht vorhersehbar. –Anzahl der Stellen –Exponentialdarstellung –Vorzeichen n Fazit: formatgesteuerte Ausgabe fehlt in JAVA! –Z.B. Pascal: write(i:8,x:8:2);

8 DVG1 - Modulare Programmierung 8 Formatierung von Festkommazahlen Eingabe: Festkommazahl ( byte, short, int, long ) –Alle Festkommatypen werden automatisch nach long konvertiert. ==> Wir wählen long als Eingabetyp: long z n Ausgabe: Zeichenkette, die den Wert der Eingabezahl repräsentiert. Format der Ausgabe: – : Leerzeichen – : Vorzeichen = ' ' oder '-' – : Ziffern n zusätzliche Eingabe: –Länge der Ausgabe: int l

9 DVG1 - Modulare Programmierung 9 n Probleme: –Was tun, wenn falsche Parameter eingegeben werden? ==> einzige Möglichkeit für Fehler ist l null ausgeben –Was tun, wenn sich die Zahl nicht mit l Stellen darstellen läßt? z.B.: l=3 und z= ==> Zeichenkette "**...*" mit l Sternen ausgeben

10 DVG1 - Modulare Programmierung 10 Vorhandene Lösungen untersuchen In JAVA existiert die Methode Long.toString Aus der JAVA-Doku: n public static String toString(long i) –Returns a new String object representing the specified integer. The argument is converted to signed decimal representation and returned as a string, exactly as if the argument and the radix 10 were given as arguments to the toString method that takes two arguments. n Parameters: –i - a long to be converted. n Returns: –a string representation of the argument in base 10.

11 DVG1 - Modulare Programmierung 11 public static String toString(long i, int radix) Creates a string representation of the first argument in the radix specified by the second argument.... If the first argument is negative, the first element of the result is the ASCII minus sign '- ' ('\u002d'. If the first argument is not negative, no sign character appears in the result. The remaining characters of the result represent the magnitude of the first argument. If the magnitude is zero, it is represented by a single zero character '0' ('\u0030'); otherwise, the first character of the representation of the magnitude will not be the zero character.... Parameters: i - a long. radix - the radix. Returns: a string representation of the argument in the specified radix.

12 DVG1 - Modulare Programmierung 12 n Darstellung ist o.k. n Wenn die Zahl zu klein ist, werden zu wenig Stellen ausgegeben. n Wenn Zahl zu groß ist, werden zu viel Stellen ausgegeben. ==> n Long.toString kann verwendet werden. Das Resultat muß aber modifiziert werden.

13 DVG1 - Modulare Programmierung 13 return s; String s; Berechnung der Ausgabe false return null; true l <= 0 Blockdiagramm - 1.Version long z, int l

14 DVG1 - Modulare Programmierung 14 Methode - 1.Version public static String toString (long z, int l) { if ( l <= 0 ) return null; String s; // Berechnung der Ausgabezeichenkette return s; }

15 DVG1 - Modulare Programmierung 15 false return s; Fehlerbehandlung >l links auffüllen

16 DVG1 - Modulare Programmierung 16 Methode - 2.Version public static String toString (long z, int l) { if ( l <= 0 ) return null; String s = Long.toString(z); if ( s.length() == l ) return s; if ( s.length() < l) { // links auffuellen return s; } // Fehlerbehandlung return s; }

17 DVG1 - Modulare Programmierung 17 return s; String s = Long.toString(z); s.length() =l >l

18 DVG1 - Modulare Programmierung 18 Methode - 3.Version public static String toString (long z, int l) { if ( l <= 0 ) return null; String s = Long.toString(z); if ( s.length() == l ) return s; if ( s.length() < l) { do { s = ' '+s; } while ( s.length()

19 DVG1 - Modulare Programmierung 19 Methode - 1.optimierte Version public static String toString (long z, int l) { if ( l <= 0 ) return null; String s = Long.toString(z); while ( s.length() < l) { s = ' '+s; } if ( s.length() == l ) return s; s = "*"; while ( s.length() < l) { s = '*' + s; } return s; }

20 DVG1 - Modulare Programmierung 20 Methode - 2.optimierte Version public static String toString (long z, int l) { if ( l <= 0 ) return null; String s = Long.toString(z); char fz = ' '; if ( s.length() > l) { fz= '*' ; s = "*"; } while ( s.length() < l) { s = fz+s; } return s; }

21 DVG1 - Modulare Programmierung 21 Methode - endgültige Version /** * toString konvertiert eine long -Variable * in eine Zeichenkette und füllt mit Leerzeichen bis zur * Länge l auf. Die Gesamtlänge enthält * das Vorzeichen "-" für negative Zahlen. * Falls die Zahl nicht in dem Format darstellbar ist, * wird die Zeichenkette "**...*" ausgegeben. * Wird l<=0 angegeben, so wird null * zurückgegeben. Gerhard Telschow 1.0 z auszugebende Variable l Länge der Ausgabe Zeichenkette */

22 DVG1 - Modulare Programmierung 22 public static String toString(long z, int l) { // Falls l<= null zurueckgeben ! if (l<=0) return null; // Rohkonvertierung vom System uebernehmen String s = Long.toString(z); // Standardfuellzeichen ist das Leerzeichen char fz = ' '; // Wenn Laenge zu gross ist, Fuellzeichen wird *, // Zeichenkette wird geloescht if ( s.length() > l ) { fz = '*'; s = "*"; } // Wenn noetig mit Fuellzeichen auffuellen while ( s.length() < l) { s = fz + s; } return s; }

23 DVG1 - Modulare Programmierung 23 2.te Näherung public class t1 { public static void main(String [] args) { System.out.println( "\n i | sqrt(i) | i*i"); System.out.println( " "); for (long i=1;i< ;i*=7) System.out.println(InOut.toString(i,12)+" | "+Math.sqrt(i)+"\t| "+(double)i*i); } }

24 DVG1 - Modulare Programmierung 24 Ergebnis der 2.ten Näherung i | sqrt(i) | i*i | 1.0| | | | 7.0| | | | 49.0| | | E | 343.0| E | | E | | E | | E | | E16

25 DVG1 - Modulare Programmierung 25 Nutzung der Entwicklung Um die entwickelte Methode weiter zu nutzen und deren Anwendung zu erleichtern, können wir zusätzliche Schnittstellen entwickeln. Z.B.: Konvertierung einer Zahl und anschließende Ausgabe: /** * print gibt eine long -Variable aus und * füllt mit führenden Leerzeichen bis zur Länge * l auf. Die Gesamtlänge enthält das * Vorzeichen "-" für negative Zahlen. * Falls die Zahl nicht in dem Format darstellbar ist, wird die * Zeichenkette "**...*" ausgegeben. * Wird l<=0 angegeben, so erfolgt keine Ausgabe. Gerhard Telschow 1.0 z auszugebende Variable l Länge der Ausgabe incl. Vorzeichen Nothing */ public static void print(long z, int l) { String s = toString(z, l); if ( s != null) System.out.print(s); }

26 DVG1 - Modulare Programmierung 26 Z.B.: Konvertierung einer Zahl und anschließende Ausgabe mit Zeilenschaltung: /** * println gibt eine long -Variable aus und * füllt mit führenden Leerzeichen bis zur Länge * l auf. Die Gesamtlänge enthält das * Vorzeichen "-" für negative Zahlen. Anschließend wird * auf eine neue Zeile geschaltet. * Falls die Zahl nicht in dem Format darstellbar ist, wird die * Zeichenkette "**...*" ausgegeben. * Wird l<=0 angegeben, so erfolgt keine Ausgabe. Gerhard Telschow 1.0 z auszugebende Variable l Länge der Ausgabe incl. Vorzeichen Nothing */ public static void println(long z, int l) { print(z,l); System.out.println(); }

27 DVG1 - Modulare Programmierung 27 Weg von der Aufgabe zur Lösung Aufgabe GrobkonzeptVerfeinerungLösungOptimierungAusbauDokumentationEndgültige Lösung

28 DVG1 - Modulare Programmierung 28 Formatierung von Gleitkommazahlen Eingabe : Gleitkommazahl ( float, double ) –float wird automatisch nach double konvertiert ==> wählen double : double z n Ausgabe: Zeichenkette, die den Wert der Eingabezahl repräsentiert. Format der Ausgabe:... E... – : Vorzeichen = ' ' oder '-' – : Ziffern der Mantisse mit folgenden Nullen – : Vorzeichen = '+' oder '-' – : Ziffern des Exponenten mit führenden Nullen n zusätzliche Eingabe: –Länge der Mantisse: int mant (Stellen nach dem Dezimalpunkt) –Länge des Exponenten: int expo –Gesamtlänge der Ausgabe: int l, l = mant+expo+5

29 DVG1 - Modulare Programmierung 29 n Probleme: –Welche Parameter wählt man. Nur zwei der drei Parameter l, mant und expo können genutzt werden. Wählen l und mant. –Was tun, wenn falsche Parameter eingegeben werden? Fehler ist l < mant+6 Fehler ist mant < 1 null ausgeben –Sonderfälle: z==+0.0 ==> " E+0..0" z==-0.0 ==> " E+0..0" z==+Infinity ==> " Inf " z==-Infinity ==> "-Inf " z==NaN ==> "NaN " –Was tun, wenn sich die Zahl nicht mit l Stellen darstellen läßt? ==> Zeichenkette "**...*" mit l Sternen ausgeben

30 DVG1 - Modulare Programmierung 30 Tests für die Sonderfälle n z==+0.0: if ( z == 0.0 & 1.0/z > 0.0 )... n z==-0.0: if ( z == 0.0 & 1.0/z < 0.0 )... n z==+Infinity: if ( (1.0/z) == 0.0 & z > 0.0 )... n z==-Infinity: if ( (1.0/z) == 0.0 & z < 0.0 )... n z==NaN: if ( z != z)...

31 DVG1 - Modulare Programmierung 31 return s;Berechnung der AusgabeSonderfälle false String s; return null; true l

32 DVG1 - Modulare Programmierung 32 Methode - 1.Version public static String toString (double z, int l, int mant) { if ( l < mant+6 | mant < 1 ) return null; String s; // Sonderfaelle // Berechnung der Ausgabezeichenkette return s; }

33 DVG1 - Modulare Programmierung 33 return s; rechts auffüllen true false s.length()>0 Exponent s=s+"E+0" s="-Inf" false s=" Inf" true z>0.0 s="NaN" true Mantisse false s="-0.0" true s=" 0.0" true 1.0/z>0.0 false z== /z==0.0 false z != z

34 DVG1 - Modulare Programmierung 34 Methode - Sonderfälle if ( z != z ) s="NaN" ; else { if (1.0/z == 0.0) { if ( z>0.0 ) s=" Inf"; else s="-Inf"; } else { if ( z == 0.0 ) { if ( 1.0/z > 0.0 ) s=" 0.0"; else s="-0.0"; while (s.length()

35 DVG1 - Modulare Programmierung 35 if ( s.length() > 0 ) { while (s.length()

36 DVG1 - Modulare Programmierung 36 Ergebnis berechnenFehler behandelnExponent umwandelnVorzeichen des Exponent bestimmenMantisse umwandelnMantisse und Exponent berechnenVorzeichen bestimmen

37 DVG1 - Modulare Programmierung 37 s=s.substring(0,mant+2); false s=s+'0'; true s.length()=10.0 false int e=0; z=-z; true vz='-'; z<0.0 char vz=' ';

38 DVG1 - Modulare Programmierung 38 false return vz+s+'E'+vze+se; return s; s=s+'*'; s.length()l-mant-5 se='0'+se; true se.length()

39 DVG1 - Modulare Programmierung 39 /********************************************************************** Das Vorzeichen wird bestimmt, in vz gemerkt und die Zahl in positiv verwandelt. ***********************************************************************/ char vz = ' '; if (z<0.0) { vz='-'; z=-z; } /********************************************************************** Der Exponent wird berechnet; z*10^e bleibt der eingegebene Wert ***********************************************************************/ int e = 0; while (z >= 10.0) { z*=0.1; e++; } while (z<1.0) { z*=10.0; e--; } /********************************************************************** Mantisse umwandeln **********************************************************************/ s=Double.toString(z); while (s.length()

40 DVG1 - Modulare Programmierung 40 /********************************************************************** Vorzeichen des Exponenten bestimmen **********************************************************************/ String vze = "+"; if (e<0) { vze="-"; e=-e; } /********************************************************************** Exponenten umwandeln **********************************************************************/ String se = Integer.toString(e); while (se.length()l-mant-5) { s=""; while (s.length()

41 DVG1 - Modulare Programmierung 41 3.te Näherung public class t1 { public static void main(String [] args) { System.out.println( "\n i | sqrt(i) | i*i"); System.out.println( " "); for (long i=1;i< ;i*=7) System.out.println(InOut.toString(i,12)+" | "+ InOut.toString(Math.sqrt(i),19,12)+" | "+ InOut.toString((double)i*i),19,12)); } }

42 DVG1 - Modulare Programmierung 42 Ergebnis der 3.ten Näherung i | sqrt(i) | i*i | E+00 | E+00 7 | E+00 | E | E+00 | E | E+01 | E | E+01 | E | E+02 | E | E+02 | E | E+02 | E | E+03 | E | E+03 | E | E+04 | E+16

43 DVG1 - Modulare Programmierung 43 Nutzung der Entwicklung Um die entwickelte Methode weiter zu nutzen und deren Anwendung zu erleichtern, können wir zusätzliche Schnittstellen entwickeln. Z.B.: Konvertierung einer Zahl und anschließende Ausgabe: public static void print(double z, int l, int mant) { String s = toString(z, l, mant); if ( s != null) System.out.print(s); } public static void println(double z, int l, int mant) { print(z, l, mant); System.out.println(); }


Herunterladen ppt "DVG1 - Modulare Programmierung 1 Modulare Programmierung."

Ähnliche Präsentationen


Google-Anzeigen