Einführung in die Software-Qualitätssicherung

Transkript

1 Einführung in die Software-Qualitätssicherung Ralf Adams, TBS1 Bochum Version 1.1 vom 6. Oktober 2006

2 Inhaltsverzeichnis 1 Einführung Motivation Inhalte des Skripts Konstruktive QS Punkt, Punkt, Komma, Strich Semikolon Falsch gesetzt Fehlende Semikolon Komma Komma oder Punkt? Fehlende Kommata Konstanten Kommentare Geschachtelte Kommentare Division mit Zeigern Andere Kommentarzeichen Zuweisung und Vergleich Ausführungsreihenfolge Inkrement / Dekrement UND/ODER-Verknpfungen Funktionsparameter Rechnen Probleme bei ganzen Zahlen Darstellung ganzer Zahlen Über- und Unterlauf Rundungsfehler Zahlendarstellung nach IEEE Rundungsfehler Test auf Gleichheit Source Files Kommentare Formatierungen Datentypen Variablen und Konstanten Zeiger Funktionen Makros Einführung in die Software-Qualitätssicherung 2

3 Inhaltsverzeichnis 2.15 Operatoren Kontrollfluss Namenskonvention für Variablen SQL-Datenbanken Performance Performance-Regeln Performance-Kennlinien Analytische QS Qualitätsmerkmale Funktionalität Angemessenheit Richtigkeit Interoperabilität Ordnungsmäßigkeit Sicherheit Zuverlässigkeit Reife Fehlertoleranz Wiederherstellbarkeit Benutzbarkeit Verstädlichkeit Erlernbarkeit Bedienbarkeit Effizienz Zeitverhalten / Performance Verbrauch Änderbarkeit / Wartbarkeit Analysierbarkeit Modifizierbarkeit Prüfbarkeit Übertragbarkeit / Portabilität Anpassbarkeit Installierbarkeit Konformität Austauschbarkeit Source Code Abdeckung Modifizierte Äquivalenzklassenanalyse Einführung in die Software-Qualitätssicherung 3

4 Tabellenverzeichnis 2.1 Unterschiedliche vorzeichenbehaftete Darstellungen bei 4 Bit Breite Präfix nach der ungarischen Notation Usability und Anwenderkreis Muster einer Testfalltabelle Erster Schritt der MÄKA (Felder ermitteln) Zweiter/Dritter Schritt der MÄKA (ÄKs ermitteln) Vierter Schritt der MÄKA (Kombinationen erstellen) Vierter Schritt der MÄKA (Kombinationen bearbeiten) Einführung in die Software-Qualitätssicherung 4

5 Abbildungsverzeichnis 2.1 Kennlinien der Performance Szenarien Qualitätsmerkmale für Software nach DIN / ISO Einführung in die Software-Qualitätssicherung 5

6 Definitionen 1 Exponent und Mantisse Numerisch instabil Standard Richtlinie Testen (eng) QS-Merkmal Qualität (nach DIN 55350, Teil 11) Testen (allgemein nach DIN 55350, Teil 11) QS-Merkmal: Angemessenheit / (Nur-)Vollständigkeit QS-Merkmal: Richtigkeit QS-Merkmal: Interoperabilität QS-Merkmal: Ordnungsmäßigkeit QS-Merkmal: Sicherheit QS-Merkmal: Reife QS-Merkmal: Fehlertoleranz QS-Merkmal: Wiederherstellbarkeit QS-Merkmal: Verstädlichkeit QS-Merkmal: Erlernbarkeit QS-Merkmal: Bedienbarkeit QS-Merkmal: Zeitverhalten / Performance QS-Merkmal: Verbrauch QS-Merkmal: Analysierbarkeit QS-Merkmal: Modifizierbarkeit QS-Merkmal: Prüfbarkeit QS-Merkmal: Anpassbarkeit QS-Merkmal: Installierbarkeit QS-Merkmal: Konformität QS-Merkmal: Austauschbarkeit C 0 -Abdeckung Programmpfad C 1 -Abdeckung C 0,k - und C 1,k -Abdeckung Einführung in die Software-Qualitätssicherung 6

7 Quelltexte 2.1 float.c Teil float.c Teil float.c Teil Rundungsfehler Fall 1: Subtraktion sehr ähnlicher Zahlen Rundungsfehler Fall 2: Stark abweichende Zahlen Rundungsfehler Fall 3: Stark abweichende Zahlen Rundungsfehler Fall 4: Additionsreihenfolge (1) Rundungsfehler Fall 4: Additionsreihenfolge (2) Test auf Gleichheit (1) Test auf Gleichheit (2) Test auf Gleichheit (3) Wechselgeld Zahlenkonvertierung Einführung in die Software-Qualitätssicherung 7

8 Literaturverzeichnis Boehm, Oliver: Fehlerfrei Programmieren in C und C Auflage. Heidelberg: dpunkp- Verlag, 2000 ISBN , Ein einfach tolles Buch. Sollte man kaufen und lesen und lesen und lesen... Council, Transaction Processing Performance: Homepage. Homepage der TPC-Norm Organisation Gruma, G.: Management Site in bleak SQA Survey Soft News. IEEE Software, May 1988, Hämerlin, Günther/Hoffmann, Karl-Heinz: Numerische Mathematik. 1. Auflage. Springer Verlag, 1989 ISBN Schnupp, Peter: Von C zu C: Problemlos Portieren. München, Wien: Carl Hanser Verlag, 1990 ISBN , Oliver Böhm: Diese Buch enthält einige wertvolle Hinweise, wie man portable Programme schreibt. Es ist allen Programmieren zu empfehlen, die für mehrere Welten entwicklen mssen. Stoer, Josef: Numerische Mathematik Auflage. Springer-Lehrbuch, 1983 ISBN Stoer, Josef/Burlisch, Roland: Numerische Mathematik Auflage. Springer-Lehrbuch, 1983 ISBN Trauboth, Heinz: Software-Qualitätssicherung. 2. Auflage. München: Oldenbourg-Verlag, 1996, Handbuch der Informatik Thema 15, Eine sehr theoretische Übersicht über aktuelle QS-Methoden. Nicht zum Lernen, aber zum Nachschlagen geeignet. Zawodny, Jeremy D.: MySQL Performance Tuning. Juni 2001, Eine gute einfach gehalten Einführung in Perfomance Tuning Einführung in die Software-Qualitätssicherung 8

9 1 Einführung 1.1 Motivation Software Qualitätssicherung ist ein unter Schülern und Programmieren genauso beliebtes Thema wie Dokumentation. Jeder erkennt die Notwendigkeit, keiner mag es tun. Mit diesem Skript sollen zwei wesentliche Ziele erreicht werden: 1. Darstellung wichtiger Grundbegriffe 2. Interesse und Spaß m Thema wecken Wird erstmal erkannt, dass ein guter Test mit einem eleganten Stück Source Code vergleichbar ist, hoffe ich kreatives Interesse an dem Thema zu wecken. Software-Fehler sind ein akzeptierter Bestandteil der Nutzung von Software. Es ist mathematisch nachweisbar, dass es unmöglich ist immer fehlerfreie Software zu produzieren, bzw. Fehlerfreiheit nachzuweisen. In der USA werden 8-10 Fehler pro 1000 Source Code Zeilen als normal betrachtet. 1 Dass man diese Fehlerquote mit einfachen und bekannten Mitteln reduzieren kann, zeigt das Discovery Projekt der NASA. Das Flugrechnersystem hat ca. 500K Zeilen und die Bodensoftware ca. 1,7M Zeilen Source Code. IBM hatte am Ende des Projekts eine Fehlerquote von 0,11 (Bord) und 0,4 (Boden) pro 1000 Zeilen Source Code. Schlüssel zum Erfolg waren (Quelle: Trauboth): Das Management stand hinter der QS. Das gesamte Projektteam war in die QS eingebunden. Der Auftraggeber hat die Prioritäten richtig gesetzt und war in den QS-Entscheidungen eingebunden. Trotzdem ist nach einer Umfrage richtige QS nicht etabliert. Eine US-amerikanische Studie ermittelte folgende Zahlen(Gruma): 74% der Betriebe haben eine Stelle für Qualitätssicherung. 23% dieser Personen haben eine adäquate Aus- oder Fortbildung. 1 Damit wird keine Aussage über die Qualität des Fehlers gemacht! Einführung in die Software-Qualitätssicherung 9

10 1 Einführung 13% der Betriebe erfassen die Kosten der QS. 6% der Betriebe führen eine Fehleranalyse durch. 5% setzen QS-Tools ein. 4% der Betriebe messen ihre Qualität anhand von Metriken. Der Markt für dieses Know-how ist gewaltig. Studien zeigen, dass ca % des Projektaufwands in den Test fließen. Informatiker 2, Fachinformatiker und informationstechnische Assistenten werden aber überwiegen in der Kunst der Softwarenentwicklung trainiert. Somit werden die 40 60% vermutlich sehr laienhaft verballert. 1.2 Inhalte des Skripts Analytische QS: Auch gemeinhin als Testen bezeichnet. Es werden verschiedene Testmethoden vorgestellt. Eine blackbox- und eine whitebox-methode. Konstruktive QS: Die Kunst eine SW schon mit möglichst wenig Fehlern in den Test gehen zu lassen. Hier werden verschiedenste Aspekte beleuchtet: Programmierichtlinien Source Code Review Datenbankperformance Viele Aspekte der QS und besonders des Qualitätsmanagements bleiben - leider - unberücksichtigt. Dazu gehören beispielsweise folgende Themen: Softwareänerungsmanagement Konfigurationsmanagement Analyse- und Designmethoden ABC-Analyse Hacking u.v.m. Da dies ein Skript für den Schulbetrieb und kein fertiges Buch ist, lebt dieses Skript. Die Versionsnummer gibt somit keinen Stabilitätsgrad an, sondern stellt lediglich den Grad der Veränderung zur letzten Version dar. 2 Ich möchte an dieser Stelle für das ganze Skript hinweisen, dass keine -innen Formulierungen verwendet werden. Ich verwende die Begriffe als geschlechtsneutrale Berufsbezeichnungen und möchte nicht den Eindruck erwecken, dass nur Männer diesen Beruf ausüben. Einführung in die Software-Qualitätssicherung 10

11 Murphys Law: Wenn etwas schief gehen kann, wird es schief gehen. Wenn etwas nicht schief gehen kann, wird es trotzdem schief gehen. Wenn ein Kette von Ereignissen schief gehen kann, wird es in der schlechtestmöglichen Reihenfolge schief gehen. Wenn ein Ereignis, das hätte schief gehen können, nicht schief geht, wäre es besser gewesen, es wäre schief gegangen. In diesem Kapitel geht es nicht darum alle Fehlerquellen aufzulisten. Am Ende sollte aber der Blick für mögliche Fehlerquellen geschärft sein. 2.1 Punkt, Punkt, Komma, Strich Semikolon Falsch gesetzt In C wird eine Anweisung durch ein Semikolon abgeschlossen. Dies ist meist auch das Zeilenende. Gerade für Anfänger entsteht aber häufig das Missverständnis, dass auch Schleifenoder Verzweigungensköpfe mit einem Semikolon abgeschlossen werden. 1 for (i = 0; i < n; i ++); 2 a[i] = i; Der Programmierer will offensichtlich das Array mit dem Wert i vorbelegen. Aufgabe 2.1 Schreiben Sie ein Programm, welches diesen Source Code enthält und lassen sie sich den Inhalt des Arrays a ausgeben. Interpretieren Sie das Ergebnis und korrigieren Sie das Programm. Ähnliches sollte bei diesem Programm zu beobachten sein: 1 if (i < 0); 2 printf ("\ nein negatives i" ); Einführung in die Software-Qualitätssicherung 11

12 Fehlende Semikolon Anfänger vergessen oft das Semikolon. Die erzeugt zwar eine Fehlermeldung, aber leider keine besonders hilfreiche: 1 int main () { 2 printf (" Dies ist Zeile 1\ n") 3 printf (" Dies ist Zeile 2\ n"); 4 return 0; 5 } In Zeile 2 fehlt das Semikolon. Leider wird der Compiler eine Fehlermeldung erzeugen, dass irgendwas mit Zeile 3 nicht in Ordnung sei. Das hängt damit zusammen, dass der Compiler das Ende einer Anweisung anhand des Semikolons erkennt. Nun erst überpüft er, ob die gesamte Anweisung sinnvoll ist. Wegen des fehlenden Semikolons betrachtet er beide Zeilen als eine Anweisung, die in Zeile 3 endet. Also gilt: Bei einem parse error in line?? oder missing ; in line?? immer erst gucken, ob man das Semikolon in der Vorgängerzeile vergessen hat Komma Ein wenig bekannter Operator ist der Komma-Operator. Er wird hauptsächlich in for-schleifen verwendet: 1 for (i = 0, j = 0; i < 10; i++, j += 2) { 2 /* Tue was */ 3 } Der Komma-Operator erlaubt es in einer Anweisung mehrere Befehle unterzubringen. In diesem Fall werden innerhalb der for-schleife zwei Variablen benötigt: i, j. Während i immer um eins erhöht wird, wächst j immer um zwei. Natrlich kann - und sollte - man diese Logik auch ohne Komma-Operator programmieren Komma oder Punkt? Bei der Zuweisung einer Fließkommazahl passiert es dem Anfänger leider manchmal, dass er folgende Zuweisung programmiert: 1 x = 5,3; Hier wird der Variablen x der Wert 5 zugeordnet. Das,3 ist zwar inhaltlicher Müll, aber syntaktisch in Ordnung und wird deshalb - leider - nicht vom Compiler abgewiesen. Wichtig: Bei einigen Compiler kann man länderspezifische Einstellungen vornehmen. Dazu gehört auch das Trennzeichen: Komma oder Punkt. Es ist nicht empfehlenswert dieses zu ändern; der Source Code wird extrem vom Compiler abhängig. Auch wird das Verständnis sinken, da fast alle Programme mit englischer Syntax geschrieben werden und Programmmierer dies auch deshalb so erwarten. Einführung in die Software-Qualitätssicherung 12

13 Fehlende Kommata Zeichenketten werden vom Compiler zusammengefasst, wenn sie nur von Leerzeichen, Tabulatoren oder Zeilenumbrüchen getrennt werden. Dadurch kann Source Code übersichtlicher programmiert werden: 1 printf (" Sie haben eine falsche Eingabe gemacht - " 2 " Druecken Sie irgendeine Taste um fortzufahren\n" ); Beide Strings werden zu einem zusammengefasst. Leider hat dieses feature auch einen Nachteil: 1 char * namen [] = { 2 " Alfred ", 3 " Michael ", 4 " Wilhelm " 5 " Gunther ", 6 " Bernd " 7 }; In Zeile 4 fehlt ein Komma. Dadurch werden die beiden Strings zusammengefasst und kein Array mit 5 Namen, sondern mit 4 Namen erzeugt. Der Befehl: 1 printf ("\n%s", namen [2]); liefert WilhelmGunther. Auch hier ist keine hilfreiche Compilerwarnung oder -fehlermeldung zu erwarten. 2.2 Konstanten 1 x1 = 2000; 2 x2 = 0020; Aufgabe 2.2 Schreiben Sie ein Programm, welches x1 und x2 ausgibt und interpretieren Sie das Ergebnis! 2.3 Kommentare Geschachtelte Kommentare Geschachtelte Kommentare sind nach ANSI-Standard nicht erlaubt. Viele Compiler bieten aber diese Möglichkeit als Feature an, da man für das Debugging gerne Programmteile inklusive der Kommentare ausblenden möchte. Hier ein Beispiel für einen geschachtelten Kommentar: Einführung in die Software-Qualitätssicherung 13

14 1 /* Aus Testzwecken auskommentiert START 2 /* Ermittle die Anzahl der 50-Cent Muenzen */ 3 while ( frest > 0.50) { 4 frest -= 0.50; 5 ianzahl50cent++; 6 } 7 /* Ermittle die Anzahl der 20-Cent Muenzen */ 8 while ( frest > 0.20) { 9 frest -= 0.20; 10 ianzahl20cent++; 11 } 12 Aus Testzwecken auskommentiert ENDE */ 13 /* Ermittle die Anzahl der 10-Cent Muenzen */ 14 while ( frest > 0.10) { 15 frest -= 0.10; 16 ianzahl10cent++; 17 } In Zeile 1 wird ein mehrzeiliger Kommentar geöffnet. Dieser Kommentar soll bis zur Zeile 12 gehen, so dass nur die letzte while-schleife ausgeführt wird. Erlaubt der Complier verschachtelte Kommentare, wird dies auch geschehen. Wechselt man nun zu einem Compiler, der das nicht erlaubt oder wird verlangt, dass der Source Code ANSI-Standards entspricht, wird dieser Source Code nicht mehr compilierbar sein. Der Kommentar wird in Zeile 2 geschlossen und die Zeile 12 wird nicht verstanden. Die Zeile 7 wird als normaler Kommentar interpretiert. Aufgabe 2.3 Wir wird folgender Source Code bei erlaubten und nicht erlaubten verschachtelten Kommentaren interpretiert: 1 /* Initialisierung 2 ok = TRUE; 3 4 /* Suche */ 5 while(ok) { } Geben Sie eine Korrektur an! Um herauszufinden, ob ein Kommentar verschachtelt werden darf, kann man folgenden Source ausführen lassen (Schnupp): 1 int main () { 2 printf (" Geschachtelte Kommentar sind %s.\ n", /*/*/0*/**/1? " erlaubt " : " verboten "); 3 return 0; 4 } Aufgabe 2.4 Implementieren und interpretieren Sie diesen Test! Allgemeiner Hinweis: Sie sollten zum Auskommentieren lieber den Präprozessor verwenden: 1 #define TEST 2 #ifndef TEST 3 /* Ermittle die Anzahl der 50-Cent Muenzen */ 4 while ( frest > 0.50) { 5 frest -= 0.50; Einführung in die Software-Qualitätssicherung 14

15 6 ianzahl50cent++; 7 } 8 /* Ermittle die Anzahl der 20-Cent Muenzen */ 9 while ( frest > 0.20) { 10 frest -= 0.20; 11 ianzahl20cent++; 12 } 13 #endif 14 /* Ermittle die Anzahl der 10-Cent Muenzen */ 15 while ( frest > 0.10) { 16 frest -= 0.10; 17 ianzahl10cent++; 18 } In Zeile 1 auf der vorherigen Seite wird eine mit Hilfe des Präprozessorbefehls #define ein (leeres) C-Symbol (hier TEST 1 ) definiert. Da das Symbol definiert ist, wird die Bedingung der Zeile 2 auf der vorherigen Seite falsch und der Präprozessor schneidet alle Source Code Zeilen von 2 auf der vorherigen Seite bis 13 raus. Würde Zeile 1 auf der vorherigen Seite komplett fehlen, wäre die Bedingung der Zeile 2 auf der vorherigen Seite wahr und die Source Code Zeilen werden nicht rausgeschnitten. Eine Variante: 1 #define TEST 1 2 #if TEST ==0 3 /* Ermittle die Anzahl der 50-Cent Muenzen */ 4 while ( frest > 0.50) { 5 frest -= 0.50; 6 ianzahl50cent++; 7 } 8 /* Ermittle die Anzahl der 20-Cent Muenzen */ 9 while ( frest > 0.20) { 10 frest -= 0.20; 11 ianzahl20cent++; 12 } 13 #endif 14 /* Ermittle die Anzahl der 10-Cent Muenzen */ 15 while ( frest > 0.10) { 16 frest -= 0.10; 17 ianzahl10cent++; 18 } Division mit Zeigern Man betrachte folgenden Source Code sehr genau: 1 x=y/*p; /* y durch *p teilen */ 2 *q ++; Leider wird y nicht durch den Wert des Zeigers p geteilt werden. Es wird vielmehr folgendes kompiliert werden: 1 x=y *q ++; Durch Einfügen einfacher Leerzeichen tritt das Problem nicht mehr auf: 1 Sie müsen nur sicherstellten, dass dieses Symbol von keinem anderen verwendet wird! Einführung in die Software-Qualitätssicherung 15

16 1 x = y / *p; /* y durch *p teilen */ 2 *q ++; Andere Kommentarzeichen Die meisten C-Compiler verstehen auch die C++-Kommentarzeichen (//). Dies hängt damit zusammen, dass die meisten C-Compiler C++-Compiler sind. Leider sind solche Programme nicht mehr ANSI-konform. Verwenden Sie also in C-Programmen nur die C-Kommentarzeichen und in C++ die C++-Kommentarzeichen. 2.4 Zuweisung und Vergleich Leider ist in C ein Programmierfehler von anfang an eingewebt worden: Der Zuweisungsoperator = wird leider oft mit dem Vergleichsoperator == verwechselt. Kommt man aus der Pascalprogrammierung (oder Verwandte) ist dies besonders ärgerlich, da Pascal die Zuweisung mit := durchführt und der Vergleich ein einfaches Gleichheitszeichen (=) ist. Typische Fehler sind: 1 if (x = y) { } oder 1 while( cweiter = j ) { } Die meisten Compiler werfen hier allerdings eine Warnung aus. Beabsichtigt war in beiden Fällen: 1 if (x == y) { } bzw. 1 while( cweiter == j ) { } Soll getestet werden, ob eine Zuweisung geklappt hat, so sollte man dies wie folgt tun: 2 1 if ( TRUE == (x = y)) { } Nun erkennt jeder Programmierer, dass die Zuweisung kein Fehler ist, sondern wirklich gewollt ist. 2 Man muss ggf. das Symbol TRUE selbst definieren: #define TRUE (1==1) Einführung in die Software-Qualitätssicherung 16

17 2.5 Ausführungsreihenfolge Inkrement / Dekrement Die Reihenfolge des Inkrement-/Dekrement-Operators hängt davon ab, ob der Operator vor oder nach der Variablen steht. Aufgabe 2.5 Bestimmen Sie die Bildschirmausgabe des folgenden Programms! 1 int main () { 2 int x, i; 3 4 x = i = 1; 5 6 x = i ++; 7 printf ("\ nx = %i", x ); 8 9 x = ++ i; 10 printf ("\ nx = %i\n", x ); return 0; 13 } Aufgabe 2.6 Bestimmen Sie die Bildschirmausgabe des folgenden Programms! 1 int main () { 2 int x, y; 3 int *p; 4 5 x = y = 2; 6 p = &y; 7 8 x = (* p )++; 9 printf ("\ nx = %i\t*p = %i", x, *p ); x = (* p )++ * *p; 12 printf ("\ nx = %i\t*p = %i", x, *p ); x = *p * (*p )++; 15 printf ("\ nx = %i\t*p = %i", x, *p ); x = *p * *p; 18 (* p )++; 19 printf ("\ nx = %i\t*p = %i\n", x, *p ); return 0; 22 } Aufgabe 2.7 Wie verhält sich dieses Programm, wenn man die Klammern um *p weglassen wrde? Einführung in die Software-Qualitätssicherung 17

18 2.5.2 UND/ODER-Verknpfungen Bei UND/ODER-Verknpfung muss beachtet werden, dass die meisten Compiler eine Optimierung bei der Auswertung einsetzen. Ist bei einer UND-Verknüpfung schon die erste der beiden Teilbedingungen falsch, muss die zweite nicht mehr ausgewertet werden, da die Gesamtbedingung falsch sein muss. Analog ist dieses Argument bei der ODER-Verknüpfung: Ist schon die erste der beiden Teilbedingungen richtig, muss keine weitere mehr ausgewertet werden, da die Gesamtbedingung richtig sein muss. 1 #define TRUE (1==1) 2 #define FALSE (0==1) 3 4 int gibmireinbool(int iwas) { 5 printf (" Ich bin mit %i aufgerufen worden \n", iwas ); 6 return iwas; 7 } 8 9 int main () { 10 if( gibmireinbool( FALSE ) && gibmireinbool( TRUE )) { 11 /* Irgendwas */ 12 } 13 printf ("\ nund (1) getestet " ); 14 if( gibmireinbool( TRUE ) && gibmireinbool( FALSE )) { 15 /* Irgendwas */ 16 } 17 printf ("\ nund (2) getestet " ); 18 if( gibmireinbool( FALSE ) gibmireinbool( TRUE )) { 19 /* Irgendwas */ 20 } 21 printf ("\ noder (1) getestet " ); 22 if( gibmireinbool( TRUE ) gibmireinbool( FALSE )) { 23 /* Irgendwas */ 24 } 25 printf ("\ noder (2) getestet \n"); return 0; 28 } Aufgabe 2.8 Erstellen Sie eine Tabelle, wann welcher Funktionsaufruf erfolgt und wann nicht. Leiten Sie daraus Regeln für die Auswertung ab. Überprfen Sie die Regeln, indem Sie alle Kombinationen mit drei Teilbedingungen programmieren. Der Sinn dieser Optimierung ist klar. Man stelle sich vor, dass anstelle der sehr einfachen Funktion gibmireinbool() ein rechenintensive Auswertung stünde. Diese kann man dann aus Sicht der Auswertung der Bedingung sparen. Problematisch wird das ganze, wenn in einer Teilauswertung eine Operation oder Berechnung durchgeführt wird. Man betrachte dazu folgendes Programm (nach einer Idee aus Boehm) 3. Der Wille des Programmieres ist klar. Er liest zwei Eingaben über die Tastatur zeichenweise ein und gibt diese auf den Bildschirm wieder aus. Das erste mal funktioniert alles wunderbar, aber beim zweiten mal? 3 Unter UNIX und Varianten kann es wegen getchar() dazu kommen, dass hier die Logik nicht funktioniert. Einführung in die Software-Qualitätssicherung 18

19 1 #include < stdio.h > 2 #define MAXSIZE int main () { 5 char arrceinstring[ MAXSIZE ] = { \0 }; 6 unsigned int uzaehler = 0; 7 char czeichen = ; 8 9 while (( czeichen!= \n ) && (( czeichen = getchar ())!= EOF ) && ( uzaehler < 255)) { 10 arrceinstring[ izaehler ] = czeichen ; 11 izaehler ++; 12 } arrceinstring[ uzaehler ] = \0 ; 15 printf (" Eingabe 1:\ n%s\n", arrceinstring); /* Hier passiert super viel! */ uzaehler = 0; 20 while (( czeichen!= \n ) && (( czeichen = getchar ())!= EOF ) && ( uzaehler < 255)) { 21 arrceinstring[ uzaehler ] = czeichen ; 22 uzaehler ++; 23 } arrceinstring[ uzaehler ] = \0 ; 26 printf (" Eingabe 2:\ n%s\n", arrceinstring); return 0; 29 } Aufgabe 2.9 Programmieren Sie das Beispiel, betrachten Sie die Ausgabe und begünden Sie diese. Programmieren Sie dieses Beispiel so um, dass das erwartete Ergebnis erscheint Funktionsparameter ANSI-C legt nicht fest, wie die Parameter eines Funktionsaufrufs ausgewertet werden. So kann folgender Aufruf, je nach verwendeter Hardware oder verwendetem Compiler unterschiedliche Ergebnisse erzeugen: 1 printf ("\n%i %i\n", ++i, ++ i ); Es ist offen, ob zuerst das rechte oder das linke i inkrementiert wird. 2.6 Rechnen Probleme bei ganzen Zahlen Darstellung ganzer Zahlen Grundsätzlich werden Zahlen im Rechner im Binärzahlsystem dargestellt. Dies bedeutet das alle Zahlen zur Basis 2 dargestellt werden. Bei positiven Zahlen ist das einfach. Man überführt die dezimale Zahl mit Hilfe bekannter Algorithmen in die binäre Darstellung. Einführung in die Software-Qualitätssicherung 19

20 Beispiel: 5331 : 2 = 2665 Rest : 2 = 1332 Rest : 2 = 666 Rest : 2 = 333 Rest : 2 = 166 Rest : 2 = 83 Rest 1 83 : 2 = 41 Rest 1 41 : 2 = 20 Rest 1 20 : 2 = 10 Rest 0 10 : 2 = 5 Rest 0 5 : 2 = 2 Rest 1 2 : 2 = 1 Rest 0 1 : 2 = 0 Rest 1 Daraus ergibt sich die binäre Darstellung: = Bei vorzeichenbehafteten Zahlen wird es komplizierter. Im wesentlichen sind 3 Darstellungen in den heutigen CPUs implementiert: Vorzeichenbit, 2er-Komplement und Excess 2 n 1. Die nachfolgenden Beispiele werden der einfachheithalber bzgl. einer Breite von 8 Bits dargestellt. Dies läßt sich leicht auf längere Zahlendarstellungen übertragen. Vorzeichenbit Stehen insgesamt 8 Bits zur Verfügung, wird ein Bit - meist das Bit mit der Nummer 7 oder Breite 1 - zur Kodierung des Vorzeichens verwendet. Das Vorzeichenbit wird so gewählt, dass 1 Vorzeichenbit das gewünschte Vorzeichen ergibt. Bei einer negativen Zahl ist somit das Vorzeichen 1 und bei einer positiven 0. Beispiel: Die Darstellung hat folgende Eigenschaften: Es gibt zwei Darstellungen der 0: und Für arithmetische Operationen müssen die Darstellungen umgewandelt werden. Der Wertebereich bei gegebener Breite B ist: 2 n 1 bis 2 n 1 ; also hier -127 bis Einführung in die Software-Qualitätssicherung 20

21 2er-Komplement Die Kodierung als 2er-Komplement hat eine enge Beziehung zur Subtraktion ganzer binärer Zahlen. Soll beispielsweise a b ausgerechnet werden. Dann wird die Zahl b in das 2er-Komplement umgewandelt und mit a addiert. Die Summe davon ist tatsächlich die Differenz. Somit ist das 2er-Komplement eine Darstellung von b. Beispiel: Wandle die Zahl in ihre positive binäre Darstellung um Bilde das 1er-Komplement, indem die Bits invertiert werden Bilde das 2er-Komplement indem du eine 1 addierst. Mögliche Überträge auf Bit 8 werden ignoriert Diese Darstellung ist der Standard für vorzeichenbehaftete Integer-Datentypen, z.b. für C/C++ oder Pascal. Die Darstellung hat folgende Eigenschaften: Es gibt nur eine Darstellungen der 0: Für arithmetische Operationen muss die Darstellungen nicht umgewandelt werden. Der Wertebereich bei gegebener Breite B ist: 2 n bis 2 n 1 1; also hier -128 bis Bei dieser Darstellung wird für die Zahl a folgende Gleichung nach x auf- Excess 2 n 1 gelöst: a +x = 127x = 127 a Beispiel für a = 51: x = 127 ( 51). Also x = 178. Die Darstellung hat folgende Eigenschaften: Es gibt nur eine Darstellungen der 0: Für arithmetische Operationen muss die Darstellungen nicht umgewandelt werden. Der Wertebereich bei gegebener Breite B ist: 2 n 1 1 bis 2 n ; also hier -127 bis Einführung in die Software-Qualitätssicherung 21

22 Wert Binärzahl Vorzeichen 2-er Komplement Excess / Tabelle 2.1: Unterschiedliche vorzeichenbehaftete Darstellungen bei 4 Bit Breite Über- und Unterlauf Intern werden ganze Zahlen (int) als Dualzahlen in 2 oder 4 Bytes kodiert. Der begrenzte Platz sorgt dafür, dass es sowas wie eine kleinste und eine größte darstellbare Zahl gibt. Dieses Programm 4 setzt beginnt genau 10 Zahlen vor der größten darstellbaren Zahl und erhöht diese nun 20 mal um 1. 1 #include < stdio.h > 2 #include <math.h > 3 4 int main () { 5 unsigned int uzahl = 0; 6 unsigned int uplatz = 0; 7 unsigned int i = 0; 8 9 /* Ermittle die Anzal der Bytes, die ein Integer hat */ 10 uplatz = sizeof(unsigned int); /* Ermittle eine Zahl kurz vor der Grenze */ 13 uzahl = (unsigned int) pow (2, ( uplatz * 8)) - 10; for (i = 0; i < 20; i++, uzahl ++) { 16 printf ("%u\n", uzahl ); 17 } // for Ende return 0; 20 } // main Ende 4 Unter Linux mit -lm bersetzen Einführung in die Software-Qualitätssicherung 22

23 Aufgabe 2.10 Schreiben Sie ein Programm, welches durch stätiges Subtrahieren einen Unterlauf erzeugt. Leider melden weder Compiler noch Laufzeitsystem eine Warnung oder Fehlermeldung, wenn ein Über- oder Unterlauf auftritt. Das Beispiel oben mag noch konstruiert sein, aber wenn in einer Berechnung ein solcher Fehler auftritt, ist dies für den Anwender und Programmierer sehr schwer zu erkennen. 1 int main () { 2 unsigned int ukante1 = 0; 3 unsigned int ukante2 = 0; 4 unsigned int uflaeche = 0; 5 6 /* Flaechenberechnung in Quadratmeter */ 7 8 printf ("\ nbitte geben Sie die erste Kantenlaenge in km an: " ); 9 scanf ("%u", & ukante1 ); printf ("\ nbitte geben Sie die zweite Kantenlaenge in km an : " ); 12 scanf ("%u", & ukante2 ); uflaeche = ( ukante1 * 1000) * ( ukante2 * 1000); printf ("\ ndie Flaeche in Quadratmeter: %u", uflaeche ); return 0; 19 } // main Ende Werden in diesem Programm 70 und 70 eingegeben, ist das Ergebnis schon falsch! * = Aufgabe 2.11 Erstellen Sie ein einfaches Programm, welches aus einer positiven Zahl durch permanentes Addieren eine negative macht! Wenn Sie eine ganze Zahl (mit oder ohne Vorzeichen) verwenden, müssen Sie sich immer überlegen, welches die maximalen oder minimalen Werte sind, die vorkommen können. Dabei spielt es keine Rolle, wie unwahrscheinlich Sie das finden! Auch sollte bedacht werden, dass intern Zahlen in andere Einheiten umgerechnet werden könnten (siehe Beispiel), was auch zu Fehlberechnungen führen kann Rundungsfehler Zahlendarstellung nach IEEE 754 Bei vielen Berechnungen werden Zahlen aus einem großen Zahlenbereich verwendet. So kann beispielsweise eine astronomische Berechnung die Masse eines Elektrons ( g) und 5 Und somit nach Murphy s Law führen wird! Einführung in die Software-Qualitätssicherung 23

24 die Masse der Sonne ( g) beinhalten. Diese beiden Zahlen könnten (dezimal) wie folgt dargestellt werden: Um mit beiden Zahlen rechnen zu künen, müssen beide die gleiche Anzahl von Stellen vor (28) und nach (34) dem Komma haben. Dies würde für das Ergebnis bedeuten, dass es ebenfalls mit 62 Bits dargestellt werden würde. Die Darstellung der Sonnenmasse mit 34 Nachkommastellen ist zum einen: eine ungeheure Verschwendung von Platz und CPU-Rechenzeit und zum anderen falsch, da keine so genaue Messung vorliegt. Die Festlegung der Anzahl von Vor- und Nachkommastellen nennt man auch Festkommadarstellung. Diese Art der Darstellung erzwingt aber diese beiden Nachteile. Es wird also nach einer Darstellungsweise gesucht, die für den Wertebereich einer Zahl die Genauigkeit zur Verfügung stellt, die sinnvoll ist. Also für Sonnenmassen genügend Vorkommastellen und für Elektronen gnügend Nachkommastellen. Die heute in den PCs verwendeten Systeme haben ihren Ursprung in der wissenschaftlichen Darstellung von Zahlen als Mantisse und Exponent und wurde von Konrad Zuse eingeführt: Definition 1 Exponent und Mantisse Sei n eine rationale Zahl und B die Basis eines Zahlensystems, dann läßt sich n wie folgt darstellen: n = f B B e f wird Mantisse zur Basis B und e wird Exponent genannt. Beispiele: B=10 n= : B=2 n=12.375: = Diese Definition ermöglicht nun eine Darstellung von Brüchen indem man zum einen die signifikanten Werte (Mantisse) angibt und zum anderen mit welcher Zahl (Basis hoch Exponent) man die Mantisse multiplizieren muss, um an den ursprünglichen Wert zu kommen. Da das Komma bei dieser Art der Darstellung nicht festliegt, sondern durch den Exponenten dynamisch bestimmt wird, nennt man diese Darstellung Fließkommazahl (floating point number). Die Darstellung in der jetzigen Form ist mehrdeutig, d.h. zu einer Zahl gibt es viele mögliche Darstellungen ( = = ). Um dieses Problem zu beseitigen, wird eine sogenannte Normalisierung eingeführt: Einführung in die Software-Qualitätssicherung 24

25 1. In einem Kontext werden alle Zahlen zur selben Basis dargestellt (hier: B=2). 2. Der Exponent wird so gewählt, dass in der Mantisse nur die erste Stelle vor dem Komma eine 1 ist. Dies bedeutet, dass die zweite und alle weiteren Stellen vor dem Komma gleich 0 sind. Da die erste Stelle vor dem Komma nicht 0 sein kann, sondern immer 1 ist, braucht diese nicht mit gespeichert zu werden. Man muss somit immer 1.0 hinzufügen. 3. Der Exponent wird in Excess-127 (siehe Kapitel auf Seite 21) kodiert. 4. Gerundet wird auf die erste Stelle (Z l+1 ) hinter dem darstellbaren Bereich nach folgender Regel: { Z l = Z l : Z l+1 < B/2 Z l + 1 : Z l+1 B/2 5. Die Zahl 0 wird durch 0 im Exponenten und 0 in der Mantisse dargestellt. Beispiele: V Exponent Mantisse Das Vorzeichenbit ist 0 und kodiert somit eine positive Zahl. Der Exponent kodiert im Excess-127 Code eine 1 ( ). Die Mantisse ist 0. Addiert man die implizite 1, so ergibt sich 1.0 Wert = ( 1) Vorzeichenbit 2 Exponent (Mantisse + 1) Wert = ( 1) (0+1.0) Wert = = 0.5 V Exponent Mantisse Das Vorzeichenbit ist 1 und kodiert somit eine negative Zahl. Der Exponent kodiert im Excess-127 Code eine 1 ( ). Die Mantisse ist = = Addiert man die implizite 1, so ergibt sich Wert = ( 1) Vorzeichenbit 2 Exponent (Mantisse + 1) Wert = ( 1) ( ) Wert = = Einführung in die Software-Qualitätssicherung 25

26 V Exponent Mantisse Das Vorzeichenbit ist 1 und kodiert somit eine negative Zahl. Der Exponent kodiert im Excess-127 Code eine 4 ( ). Die Mantisse ist 0. Addiert man die implizite 1, so ergibt sich 1.0 Wert = ( 1) Vorzeichenbit 2 Exponent (Mantisse + 1) Wert = ( 1) (0+1.0) Wert = = Das folgende C-Programm soll die interne Darstellung einer Zahl vom Datentyp float verdeutlichen. Quelltext 2.1: float.c Teil 1 1 #include< stdio.h > 2 #include< math.h > 3 /*********************************************** 4 * Globale Variablen * 5 ***********************************************/ 6 union { 7 float fzahl ; /* einmal als normales float */ 8 struct { /* Wichtig: Bitfelder werden von Hinten ausgelesen! */ 9 unsigned BIT00 :1; /* Ende Mantisse */ 10 unsigned BIT01 :1; 11 unsigned BIT02 :1; 12 unsigned BIT03 :1; 13 unsigned BIT04 :1; 14 unsigned BIT05 :1; 15 unsigned BIT06 :1; 16 unsigned BIT07 :1; 17 unsigned BIT08 :1; 18 unsigned BIT09 :1; 19 unsigned BIT10 :1; 20 unsigned BIT11 :1; 21 unsigned BIT12 :1; 22 unsigned BIT13 :1; 23 unsigned BIT14 :1; 24 unsigned BIT15 :1; 25 unsigned BIT16 :1; 26 unsigned BIT17 :1; 27 unsigned BIT18 :1; 28 unsigned BIT19 :1; 29 unsigned BIT20 :1; 30 unsigned BIT21 :1; 31 unsigned BIT22 :1; /* Start Mantisse */ 32 unsigned BIT23 :1; /* Ende Exponent */ 33 unsigned BIT24 :1; 34 unsigned BIT25 :1; 35 unsigned BIT26 :1; 36 unsigned BIT27 :1; 37 unsigned BIT28 :1; 38 unsigned BIT29 :1; 39 unsigned BIT30 :1; /* Start Exponent */ 40 unsigned BIT31 :1; /* Vorzeichenbit */ 41 } bzahl ; /* einmal als Bitfolge */ 42 } FLOAT ; /* Name der globalen Variablen */ Einführung in die Software-Qualitätssicherung 26

27 Im ersten Teil wird die globale Variable FLOAT erzeugt. Diese ist eine union aus der normalen float-zahl fzahl und dem Bitfeld bzahl. Die Union ermöglicht, dass die gleichen 32 Bit (oder 4 Byte) im Speicher unter zwei verschiedenen Namen angesprochen werden können. Durch das Bitfeld können einzelne Bits ausgelesen und geschrieben werden. Quelltext 2.2: float.c Teil 2 1 /*********************************************** 2 * Hilfsfunktion fuer Potenzen * 3 ***********************************************/ 4 long unsigned int hoch (unsigned int ubasis, unsigned int uexponent ) { 5 return (long unsigned int) floor ( pow ( ubasis, uexponent )); 6 } /* hoch Ende */ 7 8 /*********************************************** 9 * Ausgabe des float als Bitfolge * 10 ***********************************************/ 11 void show_bits () { 12 printf (" %.10f\t %u ", FLOAT. fzahl, FLOAT. bzahl. BIT31 ); 13 printf ("%u", FLOAT. bzahl. BIT30 ); 14 printf ("%u", FLOAT. bzahl. BIT29 ); 15 printf ("%u", FLOAT. bzahl. BIT28 ); 16 printf ("%u", FLOAT. bzahl. BIT27 ); 17 printf ("%u", FLOAT. bzahl. BIT26 ); 18 printf ("%u", FLOAT. bzahl. BIT25 ); 19 printf ("%u", FLOAT. bzahl. BIT24 ); 20 printf ("%u", FLOAT. bzahl. BIT23 ); 21 printf (" %u", FLOAT. bzahl. BIT22 ); 22 printf ("%u", FLOAT. bzahl. BIT21 ); 23 printf ("%u", FLOAT. bzahl. BIT20 ); 24 printf ("%u", FLOAT. bzahl. BIT19 ); 25 printf ("%u", FLOAT. bzahl. BIT18 ); 26 printf ("%u", FLOAT. bzahl. BIT17 ); 27 printf ("%u", FLOAT. bzahl. BIT16 ); 28 printf ("%u", FLOAT. bzahl. BIT15 ); 29 printf ("%u", FLOAT. bzahl. BIT14 ); 30 printf ("%u", FLOAT. bzahl. BIT13 ); 31 printf ("%u", FLOAT. bzahl. BIT12 ); 32 printf ("%u", FLOAT. bzahl. BIT11 ); 33 printf ("%u", FLOAT. bzahl. BIT10 ); 34 printf ("%u", FLOAT. bzahl. BIT09 ); 35 printf ("%u", FLOAT. bzahl. BIT08 ); 36 printf ("%u", FLOAT. bzahl. BIT07 ); 37 printf ("%u", FLOAT. bzahl. BIT06 ); 38 printf ("%u", FLOAT. bzahl. BIT05 ); 39 printf ("%u", FLOAT. bzahl. BIT04 ); 40 printf ("%u", FLOAT. bzahl. BIT03 ); 41 printf ("%u", FLOAT. bzahl. BIT02 ); 42 printf ("%u", FLOAT. bzahl. BIT01 ); 43 printf ("%u \ n", FLOAT. bzahl. BIT00 ); 44 } /* show_bits Ende */ Der zweite Teil besteht aus zwei Funktionen. Die Funktion hoch() ermöglicht die Potenzierung mit ganzen Zahlen. Dies ist notwendig, da pow() nur auf double-werten arbeitet. Die Funktion show_bits() zeigt die Zahl einmal als float-wert und einmal in Binärform. Quelltext 2.3: float.c Teil 3 1 /*********************************************** 2 * main * 3 ***********************************************/ 4 int main () { 5 6 /* Test1: 7 Es wird angenommen, dass diese Zahl folgende Darstellung hat: Einführung in die Software-Qualitätssicherung 27

28 8 Vorzeichenbit: 1 9 Exponent: (-1 in Excess 127) 10 Mantisse: Es soll nun durch gezielt Veraenderungen nachgewiesen werden, 12 dass die interne Darstellung nach IEEE 754 erfolgt. */ 13 FLOAT. fzahl = -0.5; 14 show_bits (); /* Test2: 17 Das Setzten des Vorzeichenbits soll nur das Vorzeichen aendern */ 18 FLOAT. bzahl. BIT31 = 0; 19 show_bits (); /* Test3: 22 Das Setzten eines Bits im Exponenten sollte eine entsprechend 23 Zweierpotenz hinter dem Komma anzeigen 24 Hier: Exponent -3, dadurch 1*0.125 */ 25 FLOAT. bzahl. BIT24 = 0; 26 show_bits (); 27 FLOAT. bzahl. BIT24 = 1; /* Nur Rueckgaengig */ /* Test4: 30 Das Setzten eines Bits in der Mantisse bedeutet 1 plus den 31 gesetzten Wert. 32 Hier > 1.5 * 0.5 (Exponent) = 0.75 */ FLOAT. bzahl. BIT22 = 1; 35 show_bits (); return 0; 38 } /* main Ende */ Im dritten Teil werden einige Tests durchgeführt, die belegen sollen, dass rechnerintern die Fließkommazahlen nach IEEE754 dargestellt werden. Wie viele Zahlen kann man nun bei festliegender Mantissen und Exponentenlänge darstellen? Dazu ein Beispiel im Dezimalsystem: Die Länge der Mantisse sei 3 und Länge des Exponenten 2. Es können damit Zahlen in folgendem Intervall dargestellt werden: bis Dies ist ein sehr großer Zahlenbereich, der mit nur 5 Bits abgedeckt wird. ABER: Es können zwar Zahlen aus diesem Bereich dargestellt werden, nur nicht alle!!!. Dadurch entstehen Rundungsfehler. Beispiel: Die Werte und der Wert sind darstellbar. Das arithmetische Mittel der beiden hingegen nicht: = = verlangt aber 4 Stellen in der Mantisse. Man ist gezwungen zu runden und das Ergebnis ist nach obiger Rundungsregel Um nun Zahlen miteinander beispielsweise addieren zu können, wird folgender Ablauf von der CPU durchgefhrt (Beispiel: a = und b = ): 1. Bringe beide Summanden auf den höchsten Exponenten: Die Darstellung von ist 2 2 1,875 und von ist Nun werden beide auf den höchsten Exponenten verschoben. Der höchste Exponent ist 2. a muss nicht verändert werden, aber b: b = Einführung in die Software-Qualitätssicherung 28

29 2. Addiere die Mantissen: Mantisse M a = = M b = 0.25 = M a+b = Die Mantisse M a+b hat den Wert von Normalisiere die Summe: Die Mantisse M a+b muss noch mit 2 addiert werden. Eine 1 als Übertrag der Mantissenaddition und die implizite 1 von a. Man erhöht die Zahl 2.125, also = Diese Zahl muss noch normalisiert werden: = Die 1 wird implizit gespeichert, so dass die normalisierte Zahl wie folgt aussieht: V Exponent Mantisse Normalisiere die Summenden Die bedeutet nicht anderes, als die Summanden wieder in ihre ursprüngliche Darstellung zurckzuführen. Aufgabe 2.12 Überprfen Sie diese Rechnung anhand des obigen Programms! Rundungsfehler Werden in einem Rechner zwei Fließkommazahlen addiert, subtrahiert,... so kann im Allgemeinen nicht davon ausgegangen werden, dass die Zahlen und das Rechenergebnis exakt dargestellt werden können. Beispiel: Die Zahl 0.3 soll rechnerintern dargestellt werden. Es ergibt sich eine float-darstellung: V Exponent Mantisse Dummerweise entspricht die Zahl dem Wert: Sei a eine echte Zahl und ā die Darstellung im Rechner. Dann nennt man ε a den Fehler der Zahl a. ε a läßt sich darstellen als ε a = a ā Innerhalb gewisser Grenzen kann dieser Fehler toleriert werden. Schlecht ist aber, wenn durch unglükliche Berechnungen sich dieser Fehler verstärkt. Einführung in die Software-Qualitätssicherung 29

30 Fall 1: Subtraktion sehr ähnlicher Zahlen Nehmen wir die einfache Rechenaufgabe: Sei also a = 0.3 und b = Folgendes kleine C-Programm soll uns weiterhelfen (Die Zeilen 1-89 sind dem obigen Beispiel identisch): Quelltext 2.4: Rundungsfehler Fall 1: Subtraktion sehr ähnlicher Zahlen 1 /*********************************************** 2 * main * 3 ***********************************************/ 4 int main () { 5 6 float a_strich = 0.3; 7 float b_strich = ; 8 9 FLOAT. fzahl = a_strich ; 10 show_bits (); 11 FLOAT. fzahl = b_strich ; 12 show_bits (); FLOAT. fzahl = a_strich - b_strich ; 15 show_bits (); return 0; 18 } Die Ausgabe: Erste Frage, wie hoch sind die Fehler ε a und ε b? ε a = a ā = = ε b = b b = = Es ergibt sich eine Fehlerquote für a von % und für b von %, also sehr kleine Fehler. Zweite Frage, wie hoch ist der Fehler der Berechnung? ε a b = ā b = = Bedenkt man, dass das echte Ergebnis gerade mal ist, so ergibt sich ein Fehler von 297%!!! Einführung in die Software-Qualitätssicherung 30

31 Definition 2 Numerisch instabil Eine mathematische Berechnung heißt numerisch instabil, wenn die Berechnungsergebnisse bei realistischen Eingaben eine Fehlerquote im Ergebnis erzeugt. Welche Fehlerquote akzeptabel ist, muss am Beispiel entschieden werden. Fall 2: Stark abweichende Zahlen Ist eine Zahl sehr viel größer oder kleiner als eine andere und wird dann mit ihr subtrahiert, entstehen große Fehler. Sei hier als Beispiel die Auflösung einer quadratischen Gleichung gewählt. Es gilt hier bei gegebenen a, b und c die Lösungen folgender Gleichung zu finden: ax 2 +bx +c = 0 Es gibt zwei Lösungen: x 1 x 2 = b + b 2 4ac 2a = b b 2 4ac 2a Folgendes kleine Programm bildet diese Formeln ab: Quelltext 2.5: Rundungsfehler Fall 2: Stark abweichende Zahlen 1 #include< stdio.h > 2 #include< math.h > 3 #include< stdlib.h > 4 5 int main (int argc, char * argv []) { 6 7 float a, b, c, x1, x2; 8 9 a = b = c = x1 = x2 = 0.0; printf ("\ nbitte geben Sie a ein : " ); 12 scanf ("%f", &a ); 13 printf (" Bitte geben Sie b ein : " ); 14 scanf ("%f", &b ); 15 printf (" Bitte geben Sie c ein : " ); 16 scanf ("%f", &c ); x1 = ( -1*b + sqrt( pow (b,2) -4* a*c )) / (2* a ); 19 x2 = ( -1*b - sqrt( pow (b,2) -4* a*c )) / (2* a ); printf ("\ nx1 = %f: Gegenprobe = %f \n", x1, a* x1* x1 + b* x1 + c); 22 printf (" x2 = %f: Gegenprobe = %f\n", x2, a*x2 * x2 + b* x2 + c ); return 0; 25 } /* main Ende */ Aufgabe 2.13 Geben Sie in dieses Programm folgende Werte ein, überprfen Sie die Ergebnisse und geben Sie die Fehlerquote in % an! Einführung in die Software-Qualitätssicherung 31

32 a = 1,b = 3,c = 1 a = 0.1,b = 1,c = 0.2 a = 0.1,b = 10,c = 0.2 Aufgabe 2.14 Ermitteln Sie, wo im Programm die numerische Fehlerquelle liegt! Aufgabe 2.15 Programmieren Sie x 2 nach folgender Formel 6 um: x 2 = 2c/( b b 2 4ac) Quelltext 2.6: Rundungsfehler Fall 3: Stark abweichende Zahlen 1 #include< stdio.h > 2 #include< math.h > 3 4 int main () { 5 6 float x1, x2, x3, y1, y2, y3 ; 7 8 x1 = x2 = x3 = y1 = y2 = y3 = 0.0; 9 10 x1 = 1 e7 ; 11 y1 = x1 + 1; 12 x2 = 1 e8 ; 13 y2 = x2 + 1; x3 = x2 ; 16 y3 = x3 + 5; 17 printf ("\ nx1 = %f,\ ty1 = %f :\ tx1 - y1 = %f ", x1, y1, y1 - x1 ); 18 printf ("\ nx2 = %f,\ ty2 = %f :\ tx2 - y2 = %f ", x2, y2, y2 - x2 ); 19 printf ("\ nx3 = %f,\ ty3 = %f :\ tx3 - y3 = %f\n", x3, y3, y3 - x3 ); return 0; 22 } Dieses Programm sollte sehr einfache Ergebnisse liefern, tut es aber nicht. Die Ausgaben sind: x1 = , y1 = : x1 - y1 = x2 = , y2 = : x2 - y2 = x3 = , y3 = : x3 - y3 = Aufgabe 2.16 Ermitteln Sie anhand der IEEE754-Darstellung die Ursache des Fehlers. Neben dem Phänomen des Über- oder Unterlaufs des Exponenten, ergeben sich auch Fehler durch die große Unterschiede selbst. So macht es einen Unterschied, wie man Zahlen addiert: 1 #include < stdio.h > 2 3 int main () { 4 float x [10] = {0.0}; 5 float fzahl = 0.0; 6 unsigned int i = 0; 7 Quelltext 2.7: Rundungsfehler Fall 4: Additionsreihenfolge (1) 6 Folgt aus der Gleichung: x 1 x 2 = c/a Einführung in die Software-Qualitätssicherung 32

33 8 x [0] = 50000; 9 x [1] = 4000; 10 x [2] = 3000; 11 x [3] = 2000; 12 x [4] = 1000; 13 x [5] = 0.001; 14 x [6] = 0.009; 15 x [7] = 0.09; 16 x [8] = 0.9; 17 x [9] = 1; fzahl = 0.0; 21 for (i = 0; i <10; i++) { 22 fzahl += x[i ]; 23 } /* for Ende */ 24 printf (" Vorne anfangen :\ t%f\n", fzahl ); fzahl = 0.0; 27 for (i=0; i <10; i++) { 28 fzahl += x [10 -( i+1)]; 29 } /* for Ende */ 30 printf (" Hinten anfangen :\ t%f\n", fzahl ); return 0; 33 } /* main Ende */ Man erkennt, dass die beiden for-schleifen das Array mal von vorne und mal von hinten aufaddieren. Man erhält folgende Ausgabe: Vorne anfangen: Hinten anfangen: Aufgabe 2.17 Überlegen Sie sich, warum die Ergebnisse so unterschiedlich sind! Aufgabe 2.18 Denken Sie sich ein Programm aus, welches Zahlen zwischen 1 und 1 3 addiert. Überlegen Sie sich, welche mögliche Fehlerquelle dabei zu beachten ist. Wie könnte eine Lösung aussehen? Bei Zahlen, die stark voneinander abweichen, ergibt sich auch eine nicht offensichtliche Eigenschaft der Addition im Computer. Normalerweise ist die Addition assoziativ, d.h.: a + b + c = (a +b)+c = a +(b +c) = (a +c)+b 1 #include < stdio.h > 2 3 int main () { 4 float a, b, c, ab, ac, bc ; 5 6 a = 10000; 7 b = ; 8 c = ; 9 10 ab = a+b; 11 ac = a+c; 12 bc = b+c; 13 Quelltext 2.8: Rundungsfehler Fall 4: Additionsreihenfolge (2) Einführung in die Software-Qualitätssicherung 33