Teil III : Vom Algorithmus zur Programmiersprache
1. Algorithmen, Programme, Sprachen
2. Programm- und Sprachelemente
3. Modula-2
4. Zahlendarstellung
1. Algorithmen, Programme, Sprachen
• Der Algorithmusbegriff• Merkmale und Eigenschaften von Algorithmen• Nachrichten und Sprachen• Formale Sprachen – Syntax
Der Algorithmusbegriff
Begriffsklärung:Ein Algorithmus ist eine Vorschrift, eine Anleitung zur Lösung einer Aufgabenstellung, die so präzise formuliert ist, dass man sie im Prinzip „mechanisch“ ausführen kann
Das heisstes werden Verarbeitungsvorschriften als Nachrichten formuliert, die interpretiert werden müssen
Randbedingungen� verschiedene Formalismen sind möglich� gemeinsames Sprachverständnis ist Voraussetzung
Der „ganze Alltag“ besteht aus Algorithmen:
� Gebrauchsanweisung, Bedienungsanleitung� Rezepte zur Zubereitung von ...� Anleitungen zum „Basteln“� Vorschriften nach denen man sich richtet (oder auch nicht)� Prozessabläufe (Waschmaschine)
Aha: Algorithmus Reproduzierbarkeit
Beispiel 1: Rezept für MarmorkuchenZutaten:
250g Mehl, 150g Zucker, 120g Butter, 1/2 Päckchen Backpulver, 3 Eier, 1/4 l Milch, 1 Löffel Kakaopulver, eine Prise Salz, gestossene Vanille
Zubereitung:Die Butter mit den Eigelben schaumig rühren, nach und nach abwechselnd Milch, Zucker, das mit Backpulver gesiebte Mehl, Vanille, Salz und zum Schluss den festen Eischnee untermischen. Den Teig halbieren und unter die eine Hälfte den Kakao mischen. Den hellen Teig in eine gefettete, mit Mehl ausgestreute Form füllen, den dunklen Teig darauf verteilen, eine Gabel mehrmals spiralig durch den Teig ziehen. Den Kuchen im vorgeheizten Backofen bei mittlerer Hitze (ca. 180º) backen. Backzeit ca. 50 min.
mehr oder minder eindeutige Eingabeparameter
Beispiel 2: Addieren nach Adam Riese
Beispiel 3: Schaltbild (eines Diodenempfängers mit 2-stufigem NF-Verstärker)
Beispiel 4: Suchen und Finden einer Ehefrau
Beispiel 5: Anleitung Münzfernsprecher
Elementare Eigenschaften eines Algorithmus:� ausführbar und reproduzierbar� aus schrittweise ausführbaren elementarer Operationen
zusammengesetzt� was heisst „elementar“;
Abstraktionsniveau (minimaler Grad an Detaillierung)� endliche Beschreibung� endliche Ausführungszeit (Termination)� unabhängig von Programmiersprache und Computer
Entwicklung eines Algorithmus� schrittweise Verfeinerung mit dem Ziel, die Komplexität zu bewältigen
� Vorgehensweise:� Zunächst Lösung in großen "Einheiten" angeben� Dann jede "Einheit" als gesondertes "Problem" behandeln
Beispiel 6: Radwechsel, da Reifen platt� Lösung: Führe folgende Schritte durch
1. Schrauben lösen2. Wagen anheben3. Rad entfernen4. Reserverad montieren5. Wagen absetzen6. Schrauben festziehen
� Vorteil der Vorgehensweise� "roter Faden"� "großes Problem" wird auf "kleinere Probleme" zurückgeführt
� Einzelne Schritte lassen sich weiter detaillieren:2.1 Wagenheber ansetzen2.2 Wagen hochpumpen3.1 Schrauben entfernen3.2 Rad abnehmen
� Auch bereits detaillierte Schritte können noch weiter verfeinert werden2.1.1 Bordbuch holen2.1.2 Ansatzpunkte für Wagenheber ermitteln2.1.3 geeigneten Ansatzpunkt auswählen2.1.4 Wagenheber am gewählten Ansatzpunkt ansetzen
Grad der Verfeinerung (abhängig davon für wen/was bestimmt)
� für wen: Mensch oder Maschine
� für was: Grobkonzept oder Feinkonzept
Selektion (Auswahl)� ist eine Auswahl unter Anweisungsalternativen; sie erfolgt nach explizit angege-
benem Auswahlkriterium (mit den Werten "wahr" oder "falsch"); eine Auswahl kann u.U. "geschachtelt" auftreten aber auch als Mehrfach-Auswahl.
� Auswahl und ...� bedingte Anweisung:
Falls mindestens 1 Schraube festsitzt dann Rostlöser verwenden� alternative Anweisungen:
Falls Ersatzreifen vorhanden dann wechsle den Reifen sonst hole Hilfeoder auchFalls kein Ersatzreifen vorhanden dann hole Hilfe sonst wechsle den Reifen
� Geschachtelte Anweisungen:Falls Ersatzreifen vorhanden dann falls Ersatzreifen nicht platt dann wechsle Reifen sonst hole Hilfe
� Mehrfach-Auswahl:Falls in der Nähe
Telefonzelle: ADAC anrufenWohnhaus : bitte Anwohner um HilfeTankstelle: Tankwart um Hilfe bitten
�
ansonsten: Warten bis jemand vorbeikommt
� Wiederholte Ausführung einer Einzelanweisung oder einer Folge von Anweisungen
� Wiederholungen ...� in vorbestimmter Anzahl:
wiederhole für Schraube 1 bis Schraube 5:Kreuzschlüssel aufsetzen;Falls Schraube lösbar
dann drehe Schraube eine Drehung nach linkssonst Rostlöser verwenden;
warten;drehe Schraube eine Drehung nach links
� in Abhängigkeit einer Bedingung:während Schraube noch mit Nabe verbunden:
drehe Schraube eine Drehung nach linksoder auchwiederhole
drehe Schraube eine Drehung nach linksbis Schraube nicht mehr mit Nabe verbundenoder auchwiederhole immer wieder
drehe Schraube eine Drehung nach links;falls Schraube nicht mehr mit Nabe verbunden dann höre auf
Wiederholung
Merkmale und Eigenschaften von Algorithmen
� Algorithmen und Objekte können elementar aber auch zusammengesetzt sein
� Operationen auf benannten Objekten
� Ausführung von Algorithmus-Teilen sequentiell/parallell
� � nicht-elementare Unteralgorithmen, die durch ihren„Namen“ aufgerufen werden � Prozedurkonzept
� � bedingte Ausführung von Verarbeitungsschritten
� � Wiederholungsanweisungen � Mehrfachausführungen
� meistens auch:� � Eingabe-Objekte zur Ausführung des Algorithmus� � Ausgabe-Objekte nach Ausführung des Algorithmus
Wiederholungsanweisungen � Mehrfachausführungen
Weitere Eigenschaften
� Sequentialität / Parallelität / Kollateralität (sequentiell oder parallel)
� Termination� terminierender Algorithmus kommt in endlich vielen Schritten zum
Ende
� Determinismus� deterministischer Algorithmus besitzt eindeutig vorgeschriebenen
Verlauf
� Determiniertheit� determinierter Algorithmus führt zu eindeutigem Ergebnis� deterministischer Algorithmus ist immer determiniert (verkörpert also
eine Abbildung)� nicht-deterministischer Algorithmus ist bisweilen determiniert
Aussagen über Algorithmen
� Voraussetzungen� unter welchen Bedingungen arbeitet der Algorithmus?
� Menge aller erlaubten Eingaben� Menge aller möglichen Ausgaben (bei erlaubten Eingaben)
� Was geschieht bei falscher Eingabe
� Terminationsverhalten� endet ein Algorithmus für alle möglichen Eingaben? Beweis!� Ist es möglich, den Algorithmus in einen nicht-endenden Zyklus
zu bringen?
� Korrektheit� „Übereinstimmung“ Algorithmus - Prozess?� liefert der Algorithmus bei Ausführung die richtige Ausgabe als
Funktion der Eingabe?
Aussagen über Algorithmen (cont‘d)
� Aufwand/Effizienz� Speicherplatzbedarf?� Ausführungszeit?� Abhängigkeit der Ausführungszeit von der Eingabe?
Der Korrektheitsbeweis für einen Algorithmus umfasst den Beweis der Termination und den Beweis der Korrektheit!
Urfrage zur Algorithmisierbarkeit/Berechenbarkeit:Was lässt sich algorithmisch lösen (berechnen)?Gibt es einen Algorithmus, der in endlich vielen Schritten mit der Ausgabe = f(Eingabe) stoppt, d.h. die (bekannte) Abbildung f: (Eingabe) ��� (Ausgabe) realisiert?
Nachrichten und Sprachen
� Die Form einer Nachricht wird durch eine Sprachefestgelegt
� Eine Sprache ist hierarchisch aufgebaut
Zeichen ���� Folgen von Zeichen
Wörter ���� Folgen von Wörtern
Sätze ���� Folgen von Sätzen
Sprache
Charakteristika von Sprachen
� Grundelement „Zeichen“� bildet die kleinste Einheit (bzgl. best. Abstraktionsebene)� ist Element einer Grundzeichenmenge („Alphabet“)� Bedeutung ist durch Pragmatik festgelegt
� Zeichenfolgen (= Nachrichten)� werden durch Verkettung gebildet� Regeln für erlaubte/gültige Verkettungen � Syntax
� Interpretation der Zeichenfolgen (= Information)� Feststellung der Bedeutung der Zeichenfolgen � Semantik
Beispiel: Katz und Maus
Pragmatik:(Die Darstellungen von Katze und Maus sind „selbsterklärend“)
Syntax: Katze frisst MausMaus frisst Katze
Semantik: Maus ist Beutetier von KatzenKatze jagt Vögel, Mäuse
Definition algorithmischer Sprachen
� Syntax� regelhafte Beschreibung (Festlegung) der äusseren Form einer
Zeichen- oder Wortfolge, die ein legales Konstrukt der algorith-mischen Sprache ergibt
� Regeln sind abhängig oder unabhängig von der Interpretation for-mulierbar
� Semantik� regelhafte Bedeutungszuweisung zu bestimmten, syntaktisch
korrekten Kombinationen von Wörtern� Voraussetzung: „höhere“ Sprache (Metasprache) zur Erläuterung
der Bedeutung der Programmiersprachenkonstrukte
� Pragmatik� Zurückführung einer in der Sprache als primitiv anzusehenden
Operation auf „elementarere Bestandteile“
Beispiel: Multiplikationa := 5;b := 6;c := a • b �� c = 30
Syntax: lt. Konstruktionsregeln ein gültiger Ausdruck
Semantik: Bedeutung: Multiplikation zweier Zahlen a, bmit bestimmtem Typ (und Wertebereich)
Pragmatik: Zurückführung der Multiplikation auf einzelneAdditions- und Shiftbefehle
Prinzipielle Fragestellungen zu:Formale Sprachen und Compiler � Spezifikation und Analyse von Programmiersprachen
� Wie sieht eine Grammatik für eine (Programmier-)Sprache aus?
� Wie kann die Zugehörigkeit eines Programms zu der durch die Grammatik definierten Sprache überprüft werden und wie sieht ggf. dessen „syntaktische Struktur“ aus?
� Wie kann die Eindeutigkeit der Syntax garantiert werden mit dem Ziel einer eindeutigen Analyse (eindeutige Semantik), deren Ergebnis (ausführbarer Code) dann auf einem Rechner ausgeführt werden kann?Die Konstruktion von Kunstsprachen („formale Sprachen“) und die Analyse ihrer Sprachelemente ist für die Informatik von zentraler Bedeutung!
Formale Sprachen - Syntax
Wiederholung: Syntax und Semantik von Programmiersprachen
Natürliche Sprachen und Programmiersprachen haben feste Regeln für den Aufbau von Sätzen in der Sprache (Syntax = Lehre vom Satzbau)
Programmiersprache: Zusammenfassung aller laut der Syntax korrekten Satzkonstruktionen (Programme)
Syntax: Erzeugung gültiger Satzkonstruktionen mittels der in der Grammatikfestgelegten Regeln
Semantik (Bedeutungslehre): Beschreibung der Wirkung eines Programmsauf den Rechner, d.h. welche Funktion durch das Programm berechnet wird.
Im Folgenden beschäftigen wir uns mit syntaktischen Strukturen, die Semantik bleibt unberücksichtigt.
Grammatiken und (Formale) Sprachen
� Zeichen, Worte, Sprachen
� Zeichen (Symbole) sind Elemente von ZeichenmengenS: endliche, nicht-leere Menge von Symbolen (Alphabet), d.h.S � { }, card(S) = |S| = n < �
� Worte (Symbol-, Zeichenketten, strings)mit den Elementen si�S werden Zeichenketten „über dem Alphabet S“ durch Aneinanderhängen (Konkatenation) gebildet:
S1 = SS2 = S x S�
Sk = S x S x ... x S (k-fach) �
Sk: Menge aller Zeichenketten w = s1s2...sk der Länge k über SS�: Menge aller Zeichenketten endlicher Länge über S incl.
leerem Wort � (S� ist freie Sprache über S)
� Sprache über SS� enthält alle, durch beliebige Anordnung von si�S konstruier-baren Worte
Beschränkung auf „legale“ Konstrukte
L = R(S) Regelsprache aus S�
� d.h. L � S�
Frage: Wie beschreibt man eine Regelsprache?
� Grammatik
� Generierung („Produktion“) einer Sprache mittels einer Grammatik
� G = (SN, ST, P, wS) mitSN: Menge der NichtterminalzeichenST: Menge der Terminalzeichen SN � ST = P = {pi}, |P| = n < �: Produktionen (Ersetzungsregeln)P� (SN ST)� x (SN ST)�pi : � � , wenn (�, ) � PwS : Startwort, wS � (SN ST)�, | wS| � 0
� Aus einem Wort u kann ein Wort v dadurch abgeleitet werden, indem ein � in u durch ersetzt wird und damit aus dem Wort u das Wort v entsteht.
� Ableitung eines Worts
� Problem Es liegt ein Wort w vor; w gehört zur Sprache, also w � R(S)
� StrategienTop-Down: ausgehend vom Startsymbol wird mittels der Produktionen (Ersetzungsregeln) abgeleitet, bis die gegebene Folge „generiert“ ist.Bottom-Up: umgekehrt (durch „Reduktion“)
� BeispielG = (SN,ST,P,wS)G = ( {S,A}, {0,1}, {S � 0A11, A � , A � 0A, A � 1A}, S)
(1) (2) (3) (4)
Problem: Gehört 0000111 zur Sprache?
Top-Down: S � 0A11 � 00A11 � 000A11 � 0000A11 �(1) (3) (3) (3) (4)
� 00001A11 � 0000111(4) (2)
Kontextfreie Grammatiken und Programmiersprachen
� Kontextfreie Grammatik
� G = (SN, ST, P, Z) mitSN, ST: wie gehabt P� SN x (SN ST)� , d.h. pi : A � , wenn (A, ) � P, wobei A � SN
Z : Startsymbol, Z� SN
� Beispiel: siehe letzte Folie
� EBNF (Erweiterte Backus-Naur-Form)� verkürzte Darstellung für kontextfreie Grammatiken� Alternative: A � � |
als Abkürzung für die Produktionen A � �, A �
� Wiederholungen� 0- oder 1-mal �: A � [�]� 0-, 1- oder n-mal �: A � {�}
� Beispiel von vorneaus den Produktionen
S � 0A11, A � , A � 0A, A � 1Awird in EBNF
S � 0A11, A � {0 | 1}
� Syntaxdiagramme� Graphische Darstellung für kontextfreie Grammatiken� Grundbausteine der Diagramme
� Nicht-terminale Zeichen (Variablen) A(� Platzhalter für ein weiteres Diagramm)
� Terminalzeichen s(� Zeichen der formalen Sprache)
� Konkatenationen (Wortkonstruktionen)(� Übergang von einem Knoten
( ) zum Folgenden)
� Beispiel Grammatik von vorne
A
s
0 1 1AS
1
0
A
� Zusammenhang: EBNF – Syntaxdiagramm
1. Alternative
2. Verkettung
3. Wiederholungen
0- oder 1-mal �
0-, 1- oder n-mal �
.| BaA �
.aBA �
� �.��A
� �.��A
A a
B
A a B
�
�
2. Programm- und Sprachelemente
• Programmieren und Sprachen• Erste Schritte in MODULA-2• Syntaxdiagramme
Programmieren und Sprachen
Entwurf und Notation von Programmen
Ziel ist es,einen Algorithmus zur Lösung eines Problems in einer maschinell erfassbaren Form zu formulieren
Programmiersprache mit Aufbauregeln (Syntax) undStandardinterpretation (Semantik)
Hauptaufgabe dabei ist es allerdings,einen (abstrakten) Algorithmus zu konzipieren und verifizieren; Programmieren ist somit eine konstruktive Tätigkeit, mehr als nur Codierung� Spezifikation, Entwurf, Modularisierung, ...
Empfehlenswert ist es,systematisch („vom Problem zur Maschine“) vorzugehen („Programmierzyklus“)
Programmierzyklus (aus Puchan et al., 1994)
Problem
Spezifikation desProblems
Entwicklung einesAlgorithmus
Kodierung mittelsProgrammiersprache
Testen, d.h. prüfen ob ...
EditierenCompilierenAusführen
am Rechner:
falls o.k.
richtig kodiert?(Syntax)
... dasProgrammdemAlgorithmusentspricht?
... derAlgorithmusdasProblemlöst?
Testen & beweisbare KorrektheitProgramm ist fertig und „wahrscheinlich“ korrekt
Entwurf Realisierung am Rechner
Algorithmen & Datenstrukturen
Algorithmen
reale Phänomene
Datenstrukturen
Programme
Objekte
Daten
Codierung
Strukturierung
ModellbildungAbstraktion
� Spezifikation
Formulierung� Syntax
Programmiersprachen - Programmierstile
� imperativ (algorithmisch, prozedural)� PASCAL, MODULA-2, BASIC, ALGOL, COBOL, C, FORTRAN
� funktional� LISP, Gofer, OPAL, Haskell
� objektorientiert� Smalltalk, C++
� prädikativ (logisch)� PROLOG
Bemerkungen• OO-Sprachen enthalten imperativen „Kern“• Imperative Sprachen sind noch stets
Weitesten verbreitet
Erste Schritte in MODULA-2
Grundlegender Aufbau von MODULA-2 Programmen
� Komponenten eines Programms
� Beschreibung von Aktionen� Anweisungen („statements“)� Kontrollkonstrukte� Abstraktion durch Prozeduren
� Beschreibung von Daten� Deklarationen und Definitionen
� Manipulationen auf einfachen und komplexen Daten
� Programmschema
MODULE Name [Priorität]
IMPORTDeklarationen von Konstanten, Typen, Variablen, ...
BEGIN
Initialisierungsteil
Verarbeitungsteil
Ausgabeteil
END Name.
Rumpf
Namen und Symbole
� Namen (auch: Bezeichner, Identifier)
� Frei gewählte (sinnvolle!) Bezeichnungen für „Elemente“
� Zugriff auf die Elemente über ihren Namen
� Aufbau
� Einige reservierte Namen für Modula-2
� Operationssymbole und Begrenzer
Syntaxdiagramme für Modula-2 (1)
Syntaxdiagramme für Modula-2 (2)
Syntaxdiagramme für Modula-2 (3)
Syntaxdiagramme für Modula-2 (4)
Syntaxdiagramme für Modula-2 (5)
Syntaxdiagramme für Modula-2 (6)
Syntaxdiagramme für Modula-2 (7)
Syntaxdiagramme für Modula-2 (8)
Syntaxdiagramme für Modula-2 (9)
Syntaxdiagramme für Modula-2 (10)
3. Modula-2
• Ein erstes Programm• Einfache Datentypen• Operationsprinzipien – Anweisungen• Einfache selbstdefinierte Typen• Strukturierte Daten
Ein erstes Programm
Bibliothek (explizite Nennung)MODULE Ueberschrift;
FROM InOut IMPORT WriteString, WriteLn;
BEGINWriteString(“Allgemeine Informatik I");WriteLn;WriteString(“Wintersemester 2001/2002");WriteLn;
END Ueberschrift.
Ausgabe des angegebenenTexts mit Zeilenvorschub
Kommunikation: Programm - Betriebssystem
DiensteAnforderungen
Bibliotheks-ModulBibliotheks-ModulBibliotheks-ModulBibliotheks-Modul
Modula-2 Programm
IMPORTs
Betriebssystem(hier: UNIX)
� in Modula-2
� Sprachkern ist standardisiert
� Zugriff auf Betriebssystem-Dienste via Bibliotheks-Module� Bibliotheken sind nicht standardisiert� Bibliotheken gehören nicht zum Sprachumfang
� Beurteilung� Nachteil: Unklarheit bzgl. verfügbarer Funktionalität und Struktur der
Bibliotheken� Vorteil: Implementierung der Sprache rechner-/systemunabhängig
� Ulmer Modula-2 Implementierung� Liste und Doku unter:
http://www.mathematik.uni-ulm.de/modula/man/
Gestaltung von Programmen (Grundsätzliches)
� Grundregeln zu Programmaufbau und -gestaltung� jedes Programm besteht aus (mehreren) Modulen� jeder Modul ist ein eigenes Dokument� Quelltext ist zeilenweise organisiert, mit je 1 Anweisung oder
Vereinbarung pro Zeile� Verwendung von Leerzeilen (Absetzen von Blöcken)� Einrücken von Anweisungen (entsprechend „logischer Struktur“)� sinnvolle Verwendung von Kommentaren (* ... *)
� Kommentare� Syntax: beliebiger, in (* ... *) eingeschlossener Text� sinnvoll einsetzen
� Modulanfang: Kurzbeschreibung der Aufgabe� Beschreibung der Ein- und Ausgabegrößen� Erläuterung des logischen Programmablaufs
(grob strukturierter Algorithmus, Invarianten)� Erklärung von Variablen, Typen, .... (falls nötig)� Kennzeichnung von END
� nicht sinnvoll � Unter-, aber auch Überkommentierung� Paraphrasierung des Programmtexts
Ein inakzeptables Programm
MODULE Mehrwertsteuer;FROM RealInOut IMPORT ReadReal, WriteReal, WriteFloat; FROM InOut IMPORT WriteString, WriteLn;CONST M = 0.16;VAR x,y : REAL;
BEGIN (*BEGIN Anweisung *)WriteString("Geben Sie den Preis ein: ");ReadReal(x); (* Einlesen von x *)y := x • M; WriteLn;WriteString("Die MWSt beträgt (Float): ");WriteFloat(MWSt, 8, 2); WriteLn;WriteString("Die Mehrwertsteuer beträgt (Real): ");WriteReal(y, 10);WriteLn; END Mehrwertsteuer.
Übersetzung von Programmen („Compilation“)
Fehlermeldungen(Syntaxfehler)Modula-2
ProgrammModula-2Compiler
ausführbarer Codea.out <name>.m2
UNIX
a.outinput output
UNIX
Übersetzung und Ausführung von Programmen
�Übersetzung � m2c <Name>.m2
� Aufruf des Modula-2 Compilers (Programmstart)� input = <Name>.m2; output = a.out (ausführbares Programm)
� m2c -o <Name> <Name>.m2� -o ist Compileroption� das ausführbare Programm heisst statt a.out jetzt <Name>
�Ausführung� Start mittels ...$ a.out� bzw. Start mittels ...$ <Name>
Einfache DatentypenEigenschaften eines „Typs“
�Grundsätzliches� Der (Daten-)Typ kennzeichnet die aktuelle Wertemenge eines Objekts
(Konstante, Variable, Ausdruck, Funktion, ...)� Typ-Zuordnung durch Vereinbarung (= Deklaration)
�Eigenschaften� Der Datentyp bestimmt die Wertemenge,
� zu der eine Konstante gehört� deren Werte durch eine Variable oder einen Ausdruck angenommen
werden können� deren Werte durch einen Operator oder eine Funktion berechnet werden
können� Der Datentyp ist anhand seiner Notation oder Vereinbarung erkennbar� Jeder Operator bzw. jede Funktion
� erwartet Argumente eines bestimmten Typs� liefert Resultate eines bestimmten Typs
Taxonomie der Datentypen
Datentypen
Einfache Datentypen Strukurierte Datentypen Zeiger Datentypen
GleitkommazahlenREALLONGREALCOMPLEXLONGCOMPLEX
Ganzzahlen undOrdinaltypen
CARDINALINTEGERBOOLEANCHAR
Ausschnittstyp/Unterbereichstyp(subrange)
Aufzählungstyp(enumeration)
ARRAY RECORD SET,PACKEDSET
STRINGBITSET
POINTER
Einfache Standardtypen
�Cardinal� Wertemenge: nicht-negative ganze Zahlen
{0,1, ... ,MaxCard}; MaxCard = 232 - 1� Deklaration:
VAR c,anzahl,monat,hausnummer: CARDINAL;
� Ein-/Ausgabe:FROM InOut IMPORT ReadCard(var),Write(var,breite);
� Operationen:� Addition +� Subtraktion –� Multiplikation *� ganzzahlige Division mit Rest DIV, MOD� Vergleiche =,<>,>=,>,<=,<
� Beachte: Vergleichsoperationen sind zweistellig� Falsch: x < y < z
nur beschränkter Wertebereich verfügbar !!
� Integer� Wertemenge: vorzeichenbehaftete ganze Zahlen
{-2N-1, ... ,2N-1-1}; N = 32� Deklaration:
VAR k, wert,index,faktor: INTEGER;� Ein-/Ausgabe:
FROM InOut IMPORT ReadInt(var),WriteInt(var,breite);� Operationen:
� Addition +� Subtraktion –� Multiplikation *� ganzzahlige Division mit Rest DIV, MOD� Vergleiche =,<>,>=,>,<=,<� Vorzeichenumkehrung –
� Konvertierung � CardinalVAR i,int : INTEGER;
c,card : CARDINAL;i:= INTEGER(card);c:= CARDINAL(int)
nur beschränkter Wertebereich verfügbar !!
�Definition von DIV und MOD � (x,y) � (q,r) mit x,y,q,r � N (oder Z)
wobei x DIV y � q („Quotient“)x MOD y � r („Rest“)
� x DIV y = floor(x/y) =: qwobei q > 0, if sgn(x)=sgn(y)
q = 0, if abs(x)<abs(y)q < 0, if sgn(x)�sgn(y)
� x MOD y =: rwobei r = x - (x DIV y)�y, if r � 0
r = x - (x DIV y)�y + y, if r < 0� „DIV-MOD“ - Identität
(x DIV y)�y + (x MOD y) = x
logisch:„abgerundeter“ Quotient • Nenner + Rest = Zähler
�Boolean� Wertemenge: Wahrheitswerte {FALSE,TRUE}, auch {0,1}� Deklaration:
VAR present,billig,laut,gefunden : BOOLEAN;� Ein-/Ausgabe:
keine!� Operationen:
� Negation, Verneinung NOT ~� Konjunktion, logisches UND AND &� Disjunktion, logisches ODER OR� Vergleiche
� Verwendung� Ergebnis einer Vergleichsoperation� Ausdruck einer erfüllten oder nicht erfüllten Eigenschaft� Variablen vom Typ BOOLEAN sollten Eigenschaftsworte sein
� Boolean in Bedingungen: IF billig THEN ... ELSE ...
anstatt: IF billig = TRUE THEN ... ELSE ...
IF NOT billig THEN ... ELSE ...anstatt: IF billig = FALSE THEN ... ELSE ...
Rangordnung
Beispiele zur AussagenlogikWahrheitstabelle:
P NOT p
FALSE TRUE
TRUE FALSE
P NOT p
0 1
1 0
Wahrheitstabelle:
p q p AND q p OR q
1 1 1 1
1 0 0 1
0 1 0 1
0 0 0 0
Beispiele zur Aussagenlogik
de Morgan‘sche Regeln
NOT (p AND q) = (NOT p) OR (NOT q)
NOT (p OR q) = (NOT p) AND (NOT q)
Vergleiche:
p q p < q p <= q p > q p >= q
1 1 0 1 0 1
1 0 0 0 1 1
0 1 1 1 0 0
0 0 0 1 0 1
Beispiele zur Aussagenlogik
Implikation:
p q p � q p <= q NOTp OR q
TRUE TRUE TRUE TRUE TRUE
TRUE FALSE FALSE FALSE FALSE
FALSE TRUE TRUE TRUE TRUE
FALSE FALSE TRUE TRUE TRUE
p q p � q p <= q NOTp OR q
1 1 1 1 1
1 0 0 0 0
0 1 1 1 1
0 0 1 1 1
�Character� Standardisierter Zeichensatz
� Festlegung einer rechnerinternen Darstellung von Zeichen (Bitmuster)� Festlegung einer Ordnung über der Zeichenmenge� Beispiel: ASCII (American Standard Code for Information Interchange)
� Deklaration: VAR ch1,ch2,ch3 : CHAR;
� Zuweisung:ch1 := "a";ch2 := 'b';ch3 := 65C; (65C ist ASCII-Oktal-Code für das Zeichen 5)
� Ein-/Ausgabe:FROM InOut IMPORT Read,Write;
� Operationen: Vergleiche auf Basis der ASCII-Ordnung� ORD(ch) liefert den ASCII-Wert (Ordnungsnr.) des Characters ch
– Z.B. ORD(M) = 33; ORD(!) = 77� CHR(z) liefert den Character zum ASCII-Wert z (0 � z < 128)� Es gilt: CHR(ORD(ch)) = ch und ORD(CHR(z)) = z
�Real� Wertemenge: darstellbare reelle Zahlen
(beschr. Stellenzahl)� Deklaration:
CONST pi = 3.1415;VAR coeff,std,temp: REAL;
� Ein-/Ausgabe:FROM RealInOut IMPORT ReadReal(var),
WriteReal(var,minstellen);� Operationen:
� Addition +� Subtraktion –� Multiplikation *� Division /� Vergleichsoperatoren =,<>,>=,>,<=,<� alle Op. auf REAL-Werten sind Approximationen
(Genauigkeit von Maschine/Implementierung)� Konvertierung
� FLOAT: CARDINAL / INTEGER � REAL� TRUNC: REAL � CARDINAL / INTEGER
Dezimalpunkt !!
Operationsprinzipien – AnweisungenAllgemeines
� Ein Programm manipuliert Daten� Operationen � Datenmanipulation (d.h. Zustandsänderung)� Aktionen (� Zustandsänderung) werden in Anweisungen (statements)
beschrieben
einfach((Wert-)Zuweisung) strukturiert Prozedur
zusammengesetzt bedingt repetetiv
statement
Syntaktische Definition von Anweisungen
Zuweisung und Ausdrücke (1)
� Bedeutung, Wirkung� Auswertung des Ausdrucks
� Wert des Ausdrucks muss vom Typ der Variable sein (zumindest typverträglich)
� Zuweisung des Ergebniswertes an die Variable� alter Wert der Variable wird überschrieben (Zustandsänderung)
� Beispiele� inkrementieren: zaehler := zaehler + 1� dekrementieren: zaehler := zaehler - 1� Werte zweier Variablen x,y tauschen
xalt := xx := y (* x und y haben denselben Wert *)y := xalt
�Zuweisung („assignment“) :=� Syntax
Zuweisung und Ausdrücke (2)
�Ausdruck („expression“)� Auswerteregeln: links � rechts, algebraische Regeln
Ausdruck
Operatoren
monadisch(einstellig)
dyadisch(zweistellig)
Operanden
Konstanten Variablen Funktionen
Ausdrücke mit mehreren Operatoren:- (explizit) Klammerungen- (implizit) durch Sprachregelung festge-
legte Ausführungsreihenfolge(z.B. „Punkt vor Strich“)siehe Syntax-Diagramme !
Zuweisung und Ausdrücke (3)
� Ausdruck („expression“) (cont‘d)� Beispiele:
� 3.0 � 8.0 / 4.0 � 5.0 � ((3.0 � 8.0) / 4.0) � 5.0� 2 � 3 - 4 � 5 � (2 � 3) - (4 � 5) = -14� 80 / 5 / 3 � (80 / 5) / 3 = 5.333� SQRT(SQR(3) + 11�5) = 8.000� 4 = 0 � = FALSE
� Syntax einfacher Ausdrücke
Zuweisung und Ausdrücke (4)
�Ausdruck („expression“) (cont‘d)
� Rangfolge von Operatoren (ergibt sich aus Syntax)� Negation und unäres Minus NOT(~), –
(in Factor)� Multiplikationsoperatoren �, /, DIV, MOD, AND(&)
(in Term)� Additionsoperatoren +, – , OR
(in SimpleExpression)� Relationaloperatoren =, <>, >=, >, <=, <, IN
(in Expression)
Rangfolge
� Beispiel� – 3 – 4 DIV –2 < 7 + 3 � – 2
Leere Anweisungen und Anweisungsfolgen
�Leere Anweisung („empty statement“)� Anweisung ohne Wirkung für Programmstellen, an denen
syntaktisch eine Anweisung vorkommen muss, jedoch keine Aktion stattfinden soll
�Anweisungsfolgen� Aneinanderreihung von Anweisungen� Klammerung
� explizit: BEGIN ... END bei Moduln, Prozeduren� implizit: Auswahl, Wiederholung, ...
Das ; dient lediglich der Trennung von Anweisungen, nichtals deren Abschluss. ; ist nicht Teil der Anweisung
Verzweigungen - Fallunterscheidungen (1)
� IF - Anweisung� Struktur: Einfachauswahl
IF logische Bedingung THEN ... ELSE ... END� falls logische Bedingung = true � Abarbeitung der THEN-
Anweisungsfolge ...� falls logische Bedingung = false � Abarbeitung der ELSE-
Anweisungsfolge ...
� Beispiel: Schein oder nicht Schein
IF note <= 4.0THEN WriteString(“bestanden")ELSE WriteString("nicht bestanden")
END;
Verzweigungen - Fallunterscheidungen (2)� IF - Anweisung (Cont‘d)
� Struktur: Mehrfachauswahl IF ... THEN ...ELSIF ... THEN ...
�
ELSE ... END� Syntax
� Beispiel: Notenschlüssel
IF punkte >= 100 THEN WriteString("Note 1")ELSIF punkte >= 80 THEN WriteString("Note 2")ELSIF punkte >= 60 THEN WriteString("Note 3")ELSIF punkte >= 40 THEN WriteString("Note 4")ELSE WriteString("Note 5 (nicht bestanden!)")END;
Verzweigungen - Fallunterscheidungen (3)
�CASE - Anweisung� n unabhängige Ausgangssituationen (cases); jede ist mit einer
Aktion verbunden� Struktur
CASE Ausdruck zur Fallunterscheidung OF � : ... � Fall 1� : ... � Fall 2�
ELSE ... � Fall n oder der „Rest“END
� Syntax
Verzweigungen - Fallunterscheidungen (4)
�CASE - Anweisung (cont‘d)
� Beispiel: NotenschlüsselCASE punkte OF
0..39 : WriteString("Note 5 (nicht bestanden!)")|40..59 : WriteString("Note 4")|60..79 : WriteString("Note 3")|80..99 : WriteString("Note 2")
ELSE WriteString("Note 1")END;
besser:CASE punkte OF
0..39 : WriteString("Note 5 (nicht bestanden!)") |40..59 : WriteString("Note 4")|60..79 : WriteString("Note 3")|80..99 : WriteString("Note 2")|100..105 : WriteString("Note 1")
ELSE WriteString("unzulässige Punktezahl")END;
ELSE sollte (obwohl optional) in CASE nie fehlen, um unvorhergesehene Fälle aufzufangen
Verzweigungen - Fallunterscheidungen (5)
�CASE - Anweisung (cont‘d)
� Beispiel: Einfache Menüsteuerung
....VAR ch : CHAR;....(* einfache Menuesteuerung zur Bibliotheksverwaltung *)WriteString("Eingabezeichen (Kommando): ");Read(ch); WriteLn;
CASE ch OF"S", "s" : SucheTitel(Bliste)
| "N", "n" : NeuerTitel(Bliste)| "E", "e" : EntferneTitel(Bliste)| "A", "a" : Ausgabe(Bliste)| "W", "w" : (* leere Anweisung *)| "X", "x" : EXIT
ELSE WriteString("unzulässiges Kommando")END;.....
Aufrufe von Prozeduren
Wiederholungsanweisungen (1)�Motivation
� Wiederholte Durchführung von Berechnungsschritten
�Beispiel: Fakultätsfunktion� Definition: n! =def 1, falls n = 0 und 1 � 2 � ... � (n-1) � n sonst� Lösung:
MODULE Fakultät; (* Fakultät einer Zahl n *)FROM InOut IMPORT ReadCard, WriteCard,WriteString, WriteLn;
VAR n,i,x: CARD;
BEGINWriteString("Geben Sie n ein: ");ReadCard(n); WriteLn;i := 0; x : = 1;
WriteString("Die Fakultät von (");WriteCard(n, 0);WriteString(") ist : ");WriteCard(x, 0);WriteLn;
END Fakultät.
- Prinzip:Wiederholte Multiplikation mit Abbruch
-Verschiedene Realisierungen?
Wiederholungsanweisungen (2)
Verschiedene Realisierungen für
�WHILE ... DO ...... END� vorangestellte Bedingung (kopfgesteuerte Schleife)� solange Bedingung gilt, führe Anweisungsfolge aus
�REPEAT ...... UNTIL ...� nachgestellte Bedingung (fußgesteuerte Schleife)� führe Anweisungsfolge aus, bis (Abbruch-)Bedingung erfüllt ist
�FOR ... TO ... [BY ...] DO ...... END� feste Zählschleife (kopfgesteuerte Schleife)� führe Anweisungsfolge aus, solange der Index sequentiell verändert
wird.
�LOOP ...... END� einfache Schleife (loop)� führe Anweisungsfolge aus, solange bis Schleife per EXIT verlassen
wird.
Wiederholungsanweisungen (3)
fußgesteuert
Anweisung
Schleifen-bedingung
nichterfüllt
erfüllt
kopfgesteuert
Anweisung
Schleifen-bedingung
erfüllt
nichterfüllt
Zählschleife
Anweisung
Initialisierung
Endstanderreicht
Veränderung
nein
ja
LOOP
Anweisung
EXIT
Anweisung
Wiederholungsanweisungen (4)
�WHILE-Schleife� Struktur:
WHILE Bedingung DO� (*Anweisungsfolge*)END
� Beispiel: Fakultät (mit „?“ markierter Teil)WHILE i < n DOi := i+1; x := x*i
END
� Syntax:
Wiederholungsanweisungen (5)
�REPEAT-Schleife� Struktur:
REPEAT� (*Anweisungsfolge*)UNTIL Bedingung
� Beispiel: Fakultät (mit „?“ markierter Teil) REPEAT
i := i+1; x := x*iUNTIL i >= n
� Syntax:
Wiederholungsanweisungen (6)�FOR-Schleife
� Struktur:FOR index:=ausdruck1 TO ausdruck2 BY KonstAusdruck DO� (*Anweisungsfolge*)END
� Beispiel: Fakultät (mit „?“ markierter Teil) FOR k:= 1 TO n BY 1 DO
x := x*kEND
� Syntax:
Wiederholungsanweisungen (7)
�FOR-Schleife (cont‘d)
� Hinweise:� Die Anweisungsfolge wird mit fest vorgegebener Wertefolge durchlaufen� index = Zählvariable (Laufvariable); Ausdruck1 = Startwert von index� Ausdruck2 = Endwert der Iteration� KonstAusdruck = Schrittweite der Laufvariable (= 1 falls nichts angegeben)� Ausdruck1, Ausdruck2, KonstAusdruck dürfen in der Anweisungsfolge
nicht verändert werden (ggf. WHILE bzw. REPEAT verwenden)� index ist nach Abarbeitung der FOR-Anweisung undefiniert!
� Beispiel: Fakultät� Variable i ist nun überflüssig
Wiederholungsanweisungen (8)
�Loop-Anweisung� Struktur:
LOOP� (*Anweisungsfolge mit EXIT(s)*)END (*LOOP*)
� Beispiel: Fakultät (mit „?“ markierter Teil)LOOPi := i+1; IF i > n THEN EXIT ELSE x := x*i END
END (*LOOP*)
� Syntax:
� Verwendung:„gewollte Endlosschleife“ mit Ausstieg(en) an beliebiger(/n) Stelle(n) innerhalb der Schleife
Beispiel „WHILE“: ggT (1)
�größter gemeinsamer Teiler (ggT)� Der ggT(a,b) zweier ganzer Zahlen a und b ist die größte ganze
Zahl, durch die sowohl a als auch b teilbar ist.� Beispiel: ggT(16,36) = 4� Anwendung: optimales Kürzen� Es gilt:
ggT(a,a) = a falls b = aggT(a,b) = ggT(a-b,b) falls b < aggT(a,b) = ggT(a,b-a) falls b > a� iteratives Programm zur Berechnung des ggT
� effizienter: Euklid‘scher Algorithmus für a � b:ggT(a,b) = b falls a MOD b = 0ggT(a,b) = ggT(b, a MOD b) sonst
Beispiel „WHILE“: ggT (2)MODULE ggT;(* Berechnung des groessten gemeinsamen Teilers * zweier positiver ganzer Zahlen *)
FROM InOut IMPORT WriteString, WriteLn, WriteCard, ReadCard
VAR x, y : CARDINAL ;
BEGINWriteString("Bestimmung des GGT"); WriteLn;WriteString("=================="); WriteLn;WriteString("Erste positive Zahl eingeben: ");ReadCard(x); WriteLn;WriteString("Zweite positive Zahl eingeben: ");ReadCard(y); WriteLn;
IF (x > 0) AND (y > 0) THENWHILE (x <> y) DOIF (x > y ) THEN x := x - yELSE (* y < x *) y := y - xEND (* IF *)
END; (* WHILE *)WriteString("GGT = ");WriteCard(x,0)
ELSEWriteString("fehlerhafte Eingabe!")
END; (* IF *)END ggT.
ggT
Konvertierung: WHILE � REPEAT (1)
� ... im Prinzip durch Negierung der Schleifenbedingung� beachte bei logisch (mit und / oder) zusammengesetzten Bedingungen
die de Morgan‘schen Regeln!� Beispiel:
Bedingung: q OR (i = n)negierte Bedingung: (NOT q) AND (NOT(i=n))
also: (NOT q) AND (i<>n)
�Beispiel: WHILE � REPEAT (nicht zu empfehlen)WHILE bedingung DO anweisung END
konvertiert in:IF bedingung THEN
REPEAT anweisung UNTIL NOT bedingungEND
Konvertierung: WHILE � REPEAT (2)
�Beispiel: REPEAT � WHILE� mit Code-Verdopplung
REPEAT anweisung UNTIL abbruchbedingung
konvertiert in:anweisung;WHILE NOT abbruchbedingung DO anweisung END
� mit Schaltervariable schalterREPEAT anweisung UNTIL abbruchbedingung
konvertiert in:schalter := TRUE;WHILE schalter DO anweisung;schalter := NOT abbruchbedingung
END
Beispiel „FOR“: NormalverteilungswerteMODULE Normalverteilung;FROM RealInOut IMPORT ReadReal, WriteFloat;FROM InOut IMPORT WriteString, WriteLn, WriteInt;FROM MathLib IMPORT exp, sqrt;
CONSTpi = 3.141592653589793238462643383;Max = 10;
VARi : INTEGER;std scale, faktor, GaussWert : REAL;
BEGINWriteString("Berechnung der Normalverteilung ...);WriteLn;WriteString("Eingabe der Standardabweichung: ");ReadReal(std); WriteLn;
scale := 1.0 / (sqrt(2.0 * pi) * std);
FOR i := -max TO max DOfaktor := -(FLOAT(i) * FLOAT(i)) / (2.0 * std);GaussWert := scale * exp(faktor);
WriteInt(i, 5); WriteString(" : ");WriteFloat(GaussWert, 4, 8); WriteLn
ENDEND Normalverteilung.
Beispiel „LOOP“: Werbeseiten (aus Puchan et al.)
LOOP
END
EXIT
EXIT
Beispiel „LOOP“: Werbeseiten (aus Puchan et al.)
MODULE Werbung;
FROM STextIO IMPORT Write, WriteString, WriteLn;FROM NochzuSchreiben IMPORT eingabein30s,(*geeignete Warteroutine*) CLS; (*löscht den Bildschirm *)BEGIN
LOOP(* Ausgabe 1. Bildschirmseite mit Werbung *)CLS(); (* Bildschirm löschen *)WriteString("Schauen Sie sich diesen Rechner an.");WriteLn;WriteString("Es gibt nichts, was der nicht kann.");WriteLn;IF eingabein30s() THEN
EXITEND(*IF*);
(* Ausgabe z. Bildschirmseite mit Werbung *)CLS () ;WriteString("Drum sollten Sie ihn rasch erwerben,");WriteLn;WriteString("Dann freuen sich auch Ihre Erben!!");IF eingabein30s() THEN
EXITEND(* IF *);
END(* LOOP *)END Werbung.
MODULE wcount;(* counts chars, words and lines from stdin *)
FROM InOut IMPORT Read, Done, WriteString, WriteLn, WriteCard;
CONSTnewline = 12C;blank = 40C;tab = 11C;
VARchars, words, lines : CARDINAL;ch : CHAR;inword : BOOLEAN;
BEGINchars := 0;words := 0;lines := 0;inword := FALSE;
Read(ch);WHILE Done DO
chars := chars + 1;
IF inword THEN CASE ch OF | blank, tab, newline : inword := FALSE;
words := words + 1 ELSE (* nichts *) END (* CASE *)
ELSE CASE ch OF | blank, tab, newline : (* nichts *) ELSE
inword := TRUE END (* CASE *) END; (* IF *)
IF ch = newline THEN lines := lines + 1
END; (* IF *)
Read(ch)
END; (* WHILE *)
WriteCard(chars,14); WriteString(" character(s)"); WriteLn;WriteCard(vords,14); WriteString(" vord(s)"); WriteLn;WriteCard(lines,14); WriteString(" line(s)"); WriteLn
END vcount.
Steuerzeichen im Text
Initialisierung der Zähler chars, words und lines, sowie des „Zustands“ „im Wort“ Einlesen des 1. Zeichens
Ausgabe des Ergebnisses
Schleife „arbeitet“ solange Zeichen eingelesen werden.Analyse aller eingelesenen Zeichen:
Zeichen im Wort?Wenn nein: neue Zeile, Tab, oder Blank
Einlesen des „nächsten“ Zeichens
Beispiel „WHILE“: Wordcount
MODULE numlines;(* text files with line numbers *)
FROM InOut IMPORT Read, Done, Write, WriteString, WriteLn, WriteCard;
CONST newline = 12C;
VARnumber : CARDINAL;ch : CHAR;first : BOOLEAN;
BEGINnumber := 0;first := TRUE;
Read(ch);WHILE Done DOIF first THEN number := number + 1; WriteCard(number,4); WriteString(": "); first := FALSE
END; (* IF *)
IF ch <> newline THENWrite(ch)
ELSE WriteLn; first := TRUEEND; (* IF *)
Read(ch)END (* WHILE *)
END numlines.
Beispiel „WHILE“: Zeilennummerierung
Einfache selbstdefinierte Typen
jetzt:
bisher:
Einordnung Taxonomie der DatentypenDatentypen
Einfache Datentypen Strukurierte Datentypen Zeiger Datentypen
GleitkommazahlenREALLONGREALCOMPLEXLONGCOMPLEX
Ganzzahlen undOrdinaltypen
CARDINALINTEGERBOOLEANCHAR
Aufzählungstyp (enumeration)
Ausschnittstyp/Unterbereichstyp (subrange))
ARRAY RECORD SET,PACKEDSET
STRINGBITSET
POINTER
�Syntax
�Syntax (cont‘d)
Aufzählungs- und Unterbereichstypen (1)
�Allgemein: Ordinal-Datentypen (geordnet)� bisher: vordefinierte Datentypen mit interner Ordnung� jetzt: explizite Definition von Wertemengen durch
� Aufzählung (Reihenfolge = Ordnung) � Selektion von Teilmengen (Unterbereiche)
�Aufzählungstyp (“enumeration”)� eine geordnete Menge von Werten wird spezifiziert durch Aufzählung
(konstanter Identifikatoren)� Beispiele:
� mit VariablendeklarationVARTag : (Montag, Dienstag, Mittwoch, Donnerstag,
Freitag, Samstag, Sonntag);
Farbe : (Weiss, Rot, Blau, Gelb, Gruen, Schwarz);
Aufzählungs- und Unterbereichstypen (2)
�Aufzählungstyp (“enumeration”) (cont‘d)
� Beispiele:� mit TypdefinitionTYPE
Wochentag = (Montag, Dienstag, Mittwoch, Donnerstag, Freitag, Samstag, Sonntag);
FarbPalette = (Weiss, Rot, Blau, Gelb, Gruen, Schwarz);
VARTag : Wochentag;Farbe : FarbPalette;
� wäre BOOLEAN nicht schon StandardTYPE
BOOLEAN = (FALSE, TRUE)
Aufzählungs- und Unterbereichstypen (3)
�Aufzählungstyp (“enumeration”) (cont‘d)� Bemerkungen
� Elemente müssen eindeutig definiert sein, dürfen also nicht in 2 Typen vorkommen
� Bezeichner dürfen nur in einer festgelegten Bedeutung vorkommennicht erlaubt:
Karte : (7, 8, 9, Bube, Dame, König, 10, As)Tag : (MO, DI, MI, DO, FR, SA, SO)
aber erlaubt:Tag : (Mo, Di, Mi, Do, Fr, Sa, So)
� die Elemente einer Aufzählung erhalten analog ihrer Position in der Aufzählung eine Ordnungszahl zugeordnet
� Operationen und Aktionen� Wertzuweisung wie gewohnt: Tag := Dienstag; Farbe := Blau;
� durch die Def. der Ordnung sind Vergleiche möglich {=,<>,<,<=,>,>=}� Funktionen
– Minimum, Maximum: MIN(T) = a0 , MAX(T) = an � Typ T = (a0,a1,...,an)– Ordnungszahl- und Wertfunktion: ORD(...), VAL(...) mit: ORD(x) =
VAL(CARDINAL,x)– Nachfolger und Vorgänger: INC(...), DEC(...)
Aufzählungs- und Unterbereichstypen (4)
�Aufzählungstyp (“enumeration”) (cont‘d)
� Bsp: MIN, MAX, ORD, INC, DEC bei einem AufzählungstypTYPESpielkarte : (Sieben, Acht, Neun, Bube, Dame,
Koenig, Zehn, As);VARKarte : Spielkarte;
BEGIN ...WriteCard(ORD(MIN(Spielkarte)), 2);WriteCard(ORD(MAX(Spielkarte)), 2);
Karte := Neun;WriteCard(ORD(Karte), 2);
INC(Karte);WriteCard(ORD(Karte), 2); WriteLn;
DEC(Karte, 2);WriteCard(ORD(Karte), 2); WriteLn;
END
= ORD(Sieben) = 1
= ORD(As) = 8
= ORD(Neun) = 3
Karte := Bube
= ORD(Bube) = 4
Karte := Acht
= ORD(Acht) = 2
Aufzählungs- und Unterbereichstypen (5)
�Unterbereichstyp (“subrange”)� Festlegung eines Unterbereichs des Definitionsbereichs eines ...
� vordefinierten Typs� eigens definierten (Ordinal-)Typs
� der Grundtyp ist der “Träger (host type)”� Syntax
Syntaxdiagramme aus Puchan et.al.
Aufzählungs- und Unterbereichstypen (6)�Unterbereichstyp (“subrange”) (cont‘d)
� Beispiele� TypdefinitionTYPE
Buchstabe = [“a” .. “z”];Ziffer = [0 .. 9]; (*Grundtyp CARDINAL*)ZahlInt = INTEGER[1 .. 10];Wochentag = (Mo, Di, Mi, Do, Fr, Sa, So);VL_Tag = [Mo .. Fr];BYTE = [0 .. 255];
� VariablendefinitionVAR
CAPITAL : [“A” .. “Z”]; OktZiffer : Ziffer[0 .. 7];
� Hinweise� der Trägerdatentyp bestimmt die Menge der erlaubten Operationen� bei Operationen auf Unterbereichstypen dürfen die Ergebnisse den
Wertebereich nicht verlassen� Unterbereiche auf REAL nicht erlaubt
Aufzählungs- und Unterbereichstypen (7)�Funktion VAL(T,x)
Vereinbarungen:TYPE Tage = (So, Mo, Di, Mi, Do, Fr, Sa);
Wochentage = [Mo .. Fr];
VAR i, j, z : INTEGER;r : REAL
Wertzuweisungen:i := 42; j := -1; z := 0; r := -2.7;
VAL liefert folgende Ergebnisse:VAL(CARDINAL, i) =VAL(CARDINAL, j) =VAL(CARDINAL, r) =VAL(INTEGER, i) =VAL(INTEGER, r) =VAL(REAL, i) =VAL(REAL, TRUE) =VAL(CHAR, z) =VAL(CHAR, r) =VAL(BOOLEAN, 0) =VAL(Tage, 5) =VAL(Wochentage, 5) =VAL(Wochentage, z) =
Beziehungen mit VALCHR(x) = VAL(CHAR, x) ORD(x) = VAL(CARDINAL, x) INT(x) = VAL(INTEGER, x) TRUNC(x) = VAL(CARDINAL, x) FLOAT(x) = VAL(REAL, x)
x vom Typ T:INC(x,n) � x:=VAL(T,VAL(INTEGER,x)+n)
42FehlerFehler42-242.0Fehler0CFehlerFALSEFrFrFehler
Aufzählungs- und Unterbereichstypen (8)
�Kompatibilität (auch für strukturierte Daten)
� Typkompatibilitätstrenge Regeln bzgl. der Verträglichkeit von verschiedenen Typen in Ausdrücken und Zuweisungen!� 2 Typen sind identisch, wenn sie in einer Typdefinition gleichgesetzt
werden� 2 Typen haben den gleichen Grundtyp, wenn sie Unterbereiche des
gleichen Typs sind.� Ausdruckskompatibilität
Alle Operanden in einem Ausdruck haben den gleichen Typ oder dengleichen Grundtyp
� ZuweisungskompatibilitätVariable W sei vom Typ V, Ausdruck A von Typ E; Zuweisung W := A ist möglich, falls (Auswahl):
� V und E sind gleich oder haben gleichen Grundtyp� V hat Grundtyp CARDINAL, E hat Grundtyp INTEGER oder umgekehrt� V hat Grundtyp CHAR und E ist einelem. oder leere Stringkonstante
jetzt:bisher:DatenstrukturenStrukturierte Daten
Taxonomie der DatentypenDatentypen
Einfache Datentypen Strukurierte Datentypen Zeiger Datentypen
GleitkommazahlenREALLONGREALCOMPLEXLONGCOMPLEX
Ganzzahlen undOrdinaltypen
CARDINALINTEGERBOOLEANCHAR
Ausschnittstyp/Unterbereichstyp(subrange)
Aufzählungstyp(enumeration)
ARRAY RECORD SET,PACKEDSET
STRINGBITSET
POINTER
�Unterscheidungsmerkmale� Typ der Komponenten
� alle Komponenten vom selben Typ (homogene Struktur)� Komponenten sind i.A. unterschiedlichen Typs (heterogene Struktur)� übrigens: Komponenten können selbst strukturierte Objekte sein
� Anzahl der Komponenten� fest vorgegeben, schon zur Übersetzungszeit bekannt,
bleibt während der Programmlaufzeit konstant� nicht fest vorgegeben; wird während der Programmlaufzeit einmal
bestimmt, bleibt für den Rest der Programmlaufzeit konstant� variabel, kann sich während der Programmlaufzeit beliebig ändern
(dynamische Liste)
� Zugriff auf die Komponenten� sequentiell, d.h. nur in bestimmter Reihenfolge (� Dateien)� direkt über Index (Zahl, Nummer) oder Komponenten-Bezeichner (Name)� Zugehörigkeitstest (m � M? � true/false); Komponenten nicht direkt
ansprechbar
ARRAYs (Felder) (1)
�Allgemeines� Verwendung:
Gruppierungsmöglichkeit (Struktur!) einer fest definierten Anzahl von Variablen derselben Charakteristik (=(Daten-)Typ)
� DeklarationVARfeld : ARRAY[Typ 1] OF Typ 2;
� Typ 1: Indextyp, muss Ordnungstyp sein� Typ 2: jeder beliebige, auch selbstdefinierte Typ
� Komponenten von Feldern können selbst wieder strukturiert sein, also z.B. Felder� a : ARRAY[1..N] OF
ARRAY[1..N] OF REAL
kann abgekürzt werden zu:a : ARRAY[1..N],[1..N] OF REAL
Einrückung zeigt Hierarchie
ARRAYs (Felder) (2)�Allgemeines (cont‘d)
� Beispiele zu den IndextypenTYPETAGE = (So, Mo, Di, Mi, Do, Fr. Sa);
VARtabelle : ARRAY[CHAR] OF CHAR;
speicher : ARRAY[0 .. 1000] OF INTEGER;
freierTag : ARRAY[TAGE] OF BOOLEAN;
matrix : ARRAY[1 .. 3],[1 .. 5] OF REAL;
Ordinaltyp
OrdinaltypUnterbereich aus CARDINAL/INTEGER
Ordinaltypoben definierter Typ Aufzählungstyp
OrdinaltypUnterbereich aus CARDINAL/INTEGER
Übersetzung eines Zeichensatzes in einen anderen
lineares Speichersegment
arbeitsfreie Wochentage
3 x 5 Matrix
ARRAYs (Felder) (3)�Allgemeines (cont‘d)
� Beispiele zu gültigen Vereinbarungen von ARRAYsCONST
n = 8;TYPE
Wort = ARRAY[0..3] OF CHAR;Vektor = ARRAY[1..n] OF REAL;Letter = ARRAY["a".."z"] OF INTEGER;Farbe = (rot, gelb, blau);Fahne = ARRAY[1..3] OF Farbe;Muster = ARRAY Farbe OF BOOLEAN;Palettel = ARRAY[1..n] OF ARRAY Farbe OF BOOLEAN;Palette2 = ARRAY[1..n], Farbe OF BOOLEAN;Matrix = ARRAY[1..n],[1..n] OF REAL;Matrixl = ARRAY[1..n] OF Vektor;
VARname,vorname : Wort;feld : Matrix;feld1 : Matrixl;k1Buchst : Letter;muster : Muster;identity : Matrix;v : Vektor;z : ARRAY[1..n] OF Muster;
Zuweisungen an Feldelementename[1] := "w";klBuchst["f"] := 17;muster[blau] := TRUE;feld[1,3] := 2.7;feld[1][3] := 2.7;z[7, gelb] := TRUE;z[7][gelb] := TRUE;
nicht typkompatibeltrotz interner identischer Struktur
ARRAYs (Felder) (4)
�Zuweisung, Kompatibilität� Elementweise Zuweisung kompatibler Typen (z.B. REAL)
m[i,j] := 5.0;A[i] := B[j];
FOR i : = 1 TO n DO FOR j := 1 TO n DO IF i = j THEN identity[i,j] := 1.0 ELSE identity[i,j] := 0.0 END (* IF *) END (* FOR j *)END; (* FOR i *)
� Sind die Elemente vom selben Typ und sind die Längen der beiden (Teil-)Felder identisch dann ist erlaubt:
A := B;
2 Felder können nur einander zugewiesen werden, wenn sie densel-ben oder einen durch Typumbenennung (Alias) entstandenen kompatiblen Typ haben!
ARRAYs (Felder) (5)
�RepräsentationCONST
n = 5;m = 3;
VARvektor : ARRAY[1..n] OF CARDINAL;matrix : ARRAY[1..n],[1..m] OF CARDINAL;
Intuition:- 1. Index = Zeile- 2. Index = Spalte
1 2 3 4 5vektor(=Adresse)
1 2 3 4 5123
matrix(=Adresse)
matrix(=Adresse)
13 14 151 2 3 4 5 6 7 8 9 10 11 12
1,1 1,2 1,3 2,1 2,2 2,3 3,1 3,2 3,3 4,1 4,2 4,3 5,1 5,2 5,3
ARRAYs (Felder) (6)
�Zugriff auf Feldelemente� mit Hilfe von Zählschleifen� Möglichkeiten (abhängig von Zugriffsreihenfolge)
� innere Schleife zu 2. Index
FOR i:=1 TO n DOFOR j:=1 TO m DO
matrix[i,j]:= j + (i-1)*mEND
END13 14 151 2 3 4 5 6 7 8 9 10 11 12
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
� innere Schleife zu 1. Index
FOR j:=1 TO m DOFOR i:=1 TO n DO
matrix[i,j]:= i + (j-1)*nEND
END13 14 151 2 3 4 5 6 7 8 9 10 11 12
1 6 11 2 7 12 3 8 13 4 9 14 5 10 151,1 1,2 1,3 2,1 2,2 2,3 3,1 3,2 3,3 4,1 4,2 4,3 5,1 5,2 5,3
1,1 1,2 1,3 2,1 2,2 2,3 3,1 3,2 3,3 4,1 4,2 4,3 5,1 5,2 5,3
ARRAYs (Felder) (7)
�Strings (Zeichenketten)besonderer ARRAY-Typ für Komponenten vom Typ CHAR� Struktur
0C = CHR(0), NullbyteI f I n f o r m a T h e n U n i U l mt i k 0C
Obere FeldgrenzeUntere Feldgrenze
� DeklarationTYPESTRING = ARRAY[0..27] OF CHAR;
CONSTs = “string";leer = “"; (* Leer-String *)
� OperationenEin-/Ausgabe� Lesen: FROM InOut
IMPORT ReadString;
� Schreiben: FROM InOut IMPORT WriteString;
RECORDs (Verbunde) (1)
�Feste Verbunde ((Daten-)Verbunde, in anderen Sprachen: „structure“)� Verwendung
Zusammenfassung von Objekten verschiedener Datentypen unter einem Namen (ein Komplex)
� Syntax
RECORDs (Verbunde) (2)
�Feste Verbunde (cont‘d)
� Deklaration (in TYPE oder VAR)gegeben sei ein strukturiertes Objekt (artikel) mit seinen Attributen/Komponenten (nummer, bestand, preis, lager), wobei eine Komponente wiederum strukturiert sein kann (lager � gang, regal, ebene)
VARartikel: RECORD
nummer : CARDINAL;bestand : CARDINAL;preis : REAL;lager : RECORD
gang : [‘A‘..‘H'];regal : [1..7];ebene : [1..4]
ENDEND
RECORDs (Verbunde) (3)
�Feste Verbunde (cont‘d)
� KomponentenRECORD-Komponente besteht aus Selektor und Komponenten-Typ
preis : REAL
Selektor Komponententyp
RECORD- Komponente
� Zugriff auf individuelle Komponenten
<Bezeichner>.<Selektor>
KomponentennameRECORD-Name
Selektor- Punkt
RECORDs (Verbunde) (4)
�Feste Verbunde (cont‘d)
� Beispiel (1) für Zugriff und ZuweisungVARheute, morgen, datum : RECORD
tag : [1..31];monat : (Jan, Feb, Mar, Apr, Mai, Jun, Jul, Aug,
Sep, Okt, Nov, Dez); jahr : [1900..2100]
ENDBEGIN
...datum.tag := 10;datum.monat := Apr; datum.jahr := 2000;...heute.jahr := 2001;morgen.tag := heute.tag + 1; datum := heute; ...
END
Zuweisung eines ganzen RECORDs
RECORDs (Verbunde) (5)
�Zuweisung und WITH-Anweisung � Standard
� Zuweisung an einzelne Elemente eines RECORD� Zuweisung ganzer RECORDs
� Wiederholungs-Konstrukt (� WITH-Klausel)� bei ARRAYs: elementweise Verarbeitung
durch FOR-Anweisung� bei RECORDs:
einzelne Elemente i.A. unterschiedlichen Typs (� unterschiedliche Operationen)� Zusammenfassung einer Folge individueller Anweisungen, die
sich auf Komponenten desselben Verbundes beziehen� bessere Übersichtlichkeit und Effizienzsteigerung falls (intern!)
� Syntax
BeispielWITH datum DO
tag := 10;monat := Apr; jahr := 2000
END;
RECORDs (Verbunde) (6)
�Zuweisung (cont‘d)
� Beispiel (3) Zuweisung VARstudenten : ARRAY[0..199] OF PERSON;k : CARDINAL;...
BEGIN...
studenten[50].name := "Klaus Murmann";studenten[50].gebdatum.monat := Jan;
...
IF studenten[33].name[0] = “A“THEN tue_diesELSE Tue_das
...
END
RECORD im RECORD
RECORDs (Verbunde) (7)
Selektor
�RECORD mit Varianten (Verbunde mit Varianten)� Verwendung
Möglichkeit mehrere verwandte (nicht ganz identische) RECORDs unter einem Namen (ein Datentyp!) zu definieren
� SyntaxDas Diagramm Komponente wird durch die CASE-Klausel erweitert
RECORDs (Verbunde) (8) �RECORD mit Varianten (cont‘d)
� Deklaration (in TYPE oder VAR)Programm muss zwischen den verschiedenen Varianten unter-scheiden können (� CASE-Klausel)
� Beispiel: komplexe Zahlen (COMPLEX), die entweder kartesisch oder polar dargestellt werden:
TYPECOMPLEX = RECORD
CASE art : (kartesisch, polar) OF;kartesisch : re, im : REAL
| polar : r, phi : REALELSE
END
Selektor mit IndexTyp (muss Aufzählungstyp sein)
Auswahl: jeweils ein Wert des Selektors aus der Aufzählung. Damit wird die Variante bezeichnet Zu jeder Variante
müssen die zugehörigen Komponenten des Ver-bundes deklariert werden.
kann auch entfallen
RECORDs (Verbunde) (9)
�RECORD mit Varianten (cont‘d)
� Bemerkungen� Varianten können geschachtelt (in Hierarchien) auftreten� die Werte des Selektors implizieren verschiedene Arten und Anzahl der
Komponenten� der Compiler reserviert Speicherplatz für die Komponenten mit dem
größten Bedarf� aktuelle Wert des Selektors � aktuelle Variante
� Achtung:die Flexibilität durch die Möglichkeit Varianten deklarieren zu können/dürfen ist eine Quelle häufiger Fehler!���� sorgfältiger Umgang mit dieser Strukturierungsmög-
lichkeit is highly recommended
RECORDs (Verbunde) (10)
fester RECORD im RECORDRECORD mit Varianten
�RECORD mit Varianten (cont‘d)� Beispiel „Personalverwaltung“
TYPESTRING30 = ARRAY[0..29] OF CHAR;STATUS = (verh, verw, gesch, ledig); DATUM = RECORD
tag : [1..31];monat : (Jan, Feb, Mar, Apr, Mai, Jun, Jul, Aug,
Sep, Okt, Nov, Dez); jahr : [1900..2100]END;
PERSON = RECORDname : RECORD
nachname,vorname : STRING30END;
groesse : [0..MaxInt]; (* in cm *)gebDatum : DATUM;CASE MS : STATUS OFverh, verw : Hdatum : DATUM
| gesch : Sdatum : DATUM;ersteS : BOOLEAN
| ledig : (* leer *)ENDEND;
Varianten im RECORD PERSON
fester RECORD
SETs (Mengen) (1)
�Allgemeines� Verwendung: Zusammenfassung von Elementen desselben
Grundtyps und Behandlung der Werte als Mengen� In Modula-2 gibt es 2 Arten von Mengen (beide homogen, statisch)
� vordefinierte Mengen, Datentyp BITSET� benutzerdefinierte Mengen, Datentyp SET OF ...
� ZugriffKein direkter Zugriff auf die Elemente, nur Zugehörigkeitstests und Mengenoperationen
� Hinweise� als Element-Typen eines SETs sind erlaubt:
– Aufzählungstypen (incl. BOOLEAN)– Unterbereich der nicht-negativen ganzen Zahlen
� max. Anzahl der Elemente darf aus höchstens W Elementen bestehen(W maschinenabhängig � Wortlänge: W = 16, 32, ..., „Ulm“)
� BITSET = SET OF CARDINAL[0 .. W-1]� Bestimme W „rechtzeitig“
�Allgemeines (cont‘d)� Syntax
SETs (Mengen) (2)
vordefiniert benutzerdefiniert
Syntaxdiagramme aus Puchan et.al.
SETs (Mengen) (3) �Allgemeines (cont‘d)
� Mengenkonstanteexplizite Aufzählung der zur Menge gehörigen Elemente in { ... }(die leere Menge { } ist möglich)
}{
nicht notwendig bei BITSET
Dem Klammerpaar {...} muss der Grundtyp vorangestellt werden
SETs (Mengen) (4) �Allgemeines (cont‘d)
� Beispiel „Personenbeschreibung“TYPEEigenschaften = (gross, klein, dick, normal, schlank,
fleissig, ordentlich, baertig); Personenbeschreibung = SET OF Eigenschaften;...
VARTaeter : Personenbeschreibung;...
� Beispiel „Farb-Palette“TYPEFARBE = (rot, gruen, blau);...
CONSTrg = FARBE{rot, gruen};alle = FARBE{rot .. blau}; ...
VARx : SET OF FARBE;...
SETs (Mengen) (5) �Operationen auf Mengen (cont‘d)
� Mengenoperationen (Ergebnistyp = Operandentyp)� Vereinigung � � +� Durchschnitt � � •� Differenz \ � –
A \ B = A � ¬B Menge aller Elemente die A und nicht in B enthalten sind
� symmetrische Differenz � � /A � B = (A � B) \ (A � B)Menge aller Elemente die genau in einer der beiden Mengen A, B enthalten sind
� Vergleichsoperatoren (Ergebnistyp = BOOLEAN)� Gleichheit = � =� Ungleichheit � � <>, #� Inklusion � bzw. � � >= bzw. <=� Element von/aus � � IN
SETs (Mengen) (6) �Operationen auf Mengen (cont‘d)
� Beispiel „Vereinigung“TYPECard = SET OF [1..4]; ...
VARm : Card;...m := Card{1..2};m := m + Card{2..4}; Ergebnis: m = {1, 2, 3, 4}
� Beispiel „Durchschnitt“(* Vereinbarungen wie oben *)...m := Card{1, 2, 3};m := m * Card{2..4}; Ergebnis: m = {2, 3}
� Beispiel „Differenz“(* Vereinbarungen wie oben *)...m := Card{1, 2, 3};m := m - Card{2..4}; Ergebnis: m = {1}
SETs (Mengen) (7) �Operationen auf Mengen (cont‘d)
� Beispiel „ Symmetrische Differenz“TYPECard = SET OF [1..4]; ...
VARm : Card;...m := Card{1, 2, 3};m := m / Card{2..4}; Ergebnis: m = {1, 4}
� Beispiel „ Vergleiche“(* Vereinbarungen wie oben *)...Card{1, 2} = Card{3, 4} Ergebnis: FALSE1 IN Card{1..3, 4} Ergebnis: TRUECard{1, 2} <= Card{1..4} Ergebnis: TRUECard{1, 2} >= Card{1..4} Ergebnis: FALSECard{1, 2, 3, 4} <> Card{1..4} Ergebnis: FALSE
� Beispiel zur Verwendung von SETs(* Vereinbarungen *)...IF c IN CHAR{'a','e','i','o','u'} THEN ... END
� CASE c OF 'a','e','i','o','u' : ... END
SETs (Mengen) (8) �Operationen auf Mengen
� Hinzufügen/Entfernen von Elementen� Hinzufügen: INCL(menge,element)
menge := menge + {Elementwert} (Vereinigung)
� Entfernen: EXCL(menge,element) menge := menge - {Elementwert} (Differenz)
� Implementierung� der Basistyp ist geordnet, das erste Element wird mit Index 0
gezählt� ein Objekt wird abgebildet auf ein oder mehrere Speicherworte� Zuordnung eines Elements zu einer Menge durch Setzen des Bits
an der entsprechenden (Bit-)PositionTYPEmenge = SET OF ['a' .. 'p'];...
VARx : menge;...
x := menge ['a','c','k','p'];
13 14 151 2 3 4 5 6 7 8 9 10 11 120
b c d e f g h i j k l m n o pa0 1 0 0 0 0 0 0 0 1 0 0 0 0 11
4. Zahlendarstellung
• Zahlen und ihre Darstellung in Digitalrechnern• Gleitkommazahlen: Darstellung und Arithmetik
Zahlen und ihre Darstellung in DigitalrechnernGrundstrukturen: Speicherorganisation und Zahlenmengen�Linear organisierter Speicher
� zu einer Adresse gehört ein Speicher mit 32 Bit-Zellen (1 Wort „breit“)
MSB0781516232431
LSB
bit
byteHalbwort
Linearer Speicheradresse
Grundstrukturen: Speicherorganisation und Zahlenmengen
�Zahlenmengen (No � Z � Q � R � C)� natürliche Zahlen� ganze Zahlen = natürliche Zahlen und negative ganze Zahlen� rationale Zahlen = ganze Zahlen und gebrochene zahlen� reelle Zahlen = rationale Zahlen und irrationale Zahlen� komplexe Zahlen = reelle Zahlen und „echt imaginäre“ Zahlen
Ganzzahldarstellung (1)i
n
ii bazahl ���
�0
�Basis-Zahlendarstellung:
� die Basis b � 2 ist aus den natürlichen Zahlen� die Ziffer ai ist aus den natürlichen Zahlen 0 � ai � b-1� die Darstellung ist eindeutig� Schreibweise:
zahl = (an ... a0)b
Beispiel: (1024)10 = 1•103 + 0•102 + 2•101 + 4•100
� gebräuchliche Zahlenbasen:� 2 (Binär-System)� 8 (Oktal-System)� 10 (Dezimal-System)� 16 (Hexadezimal-System)
� Multiplikation/Division mit b: shift der Zahl-Ziffernfolge um 1 Stelle nach links/rechts
Beispiel 100011101
43528511D
Ganzzahldarstellung (2)�Konvertierung zwischen zwei Basen:
01
011
10
))(( abbabazahl
ababababazahl
nn
nn
nn
in
ii
������
�������
�
�
�
�
�
��
�
(� Horner-Schema)
� Basis b � Basis 10� Eingabe: b, Feld a[0..k]� Ausgabe: Dezimalzahl� „vorwärts: von links nach rechts“
zahl := 0;FOR i:=n TO 0 BY -1 DO;
zahl := zahl�b + a[i]END;
i := 0;a[i] := 0;WHILE zahl>0 DOa[i] := zahl MOD b;zahl := zahl DIV b;i := i+1
END;
� Basis 10 � Basis b� Eingabe: Dezimalzahl, neue Basis b � Ausgabe: Feld a[0..k] (neue Ziffernfolge)� „rückwärts: von rechts nach links “
Ganzzahldarstellung (3)�Konvertierung zwischen zwei Basen: (cont‘d)
� Beispiel: (236)8 � (?)3
� Schritt 1: (236)8 � Dezimalzahln = 2:(236)8 = ((0·8 + 2)·8 + 3 )·8 + 6 = 158 = (158)10
� Schritt 2: Dezimalzahl � (?)3b = 3(158)10 : 158 / 3 = 52 Rest 2
52 / 3 = 17 Rest 117 / 3 = 5 Rest 2
5 / 3 = 1 Rest 21 / 3 = 0 Rest 1
also: (158)10 = ((((0·3 + 1)·3 + 2)·3 + 2)·3 + 1)·3 + 2 = (12212)3
wobei: ( ... ) = 52, ( ... ) = 17, ( ... ) = 5, ( ... ) = 1,
Ganzzahldarstellung (4)�Spezialfall: Konvertierung zwischen Basen 2 � 2k
� von rechts nach links: Zusammenfassen von jeweils k benachbar-ten Ziffern
� Beispiel mit der Zahl (300)10 : Die Darstellung zur Basis b=2 soll in die zur Basis b=8 umgewandelt werden, d.h. k=3:
0123456782 202021212021202021)100101100( ������������������
001230126012 2)202021(2)212021(2)202021(100101100 ���������������������
8012 )454(848584100101100 �������
�Spezialfall: Konvertierung zwischen Basen 2k� 2
� selbst nachdenken!
Negative Zahlen im Binärsystem (1)�Allgemeines
� Die Anzahl der darstellbaren Zahlen ist beschränkt!(abhängig von der Wortlänge)� Wortlänge = 8bit � N = 28 = 256 versch. 0/1-Kombinationen
� 256 verschiedene Zahlen darstellbar, z.B. 0 ... 255 (= N - 1)
� Unser Rechner kann nur addieren, besitzt lediglich ein Addierwerk, kein Subtrahierwerk; letztlich heisst das, auch Multiplikationen und Divisionen muss das Addierwerk erledigen!
� Frage: Kann man sich im Bereich der Dezimalzahlen einen Algorithmus vorstellen, der mittels Addition eine Subtraktion durchführt?(unter der Nebenbedingung, dass die Anzahl der darstellbaren Zahlen beschränkt ist)� Idee: falls x > 0, dann nix: x � x
falls x < 0, dann: x � N - |x|
Negative Zahlen im Binärsystem (2)�4 Möglichkeiten der Darstellung
� Vorzeichen und Betrag („signed magnitude“)� Bit ganz links als Vorzeichen: 0 � + ; 1 � – ;
restliche Bits stellen den Betrag der Zahl dar� Beispiel: Wortlänge n = 4 Bit � N = 24 = 16 versch. 0/1-Kombinationen � 16 verschiedene Zahlen darstellbar, bisher (kardinal) 0 ... 15 (= N - 1), jetzt (integer) -7 ... +7, also -(2n-1 - 1) ... +(2n-1 - 1)
� Problem 1es gibt zwei Nullen: +0 � 0000; -0 � 1000also: Eine Zahl aber zwei unterscheidbare(!) Bitfolgen
� Problem 2Bei dieser Darstellung ist ein Addierwerk und ein Subtrahierwerknotwendig; es gibt keinen Algorithmus, der für diese Darstellung Subtraktion per Addition erledigt
� Problem 3Es ist eine Logik erforderlich zur Entscheidung, ob Addition oder Subtraktion auszuführen ist (4 Vorzeichenfälle)
�4 Möglichkeiten der Darstellung (cont‘d)� Einer-Komplement (One‘s Complement)
� gebildet durch stellenweises Invertieren der Originalzahl: 0 � 1, 1 � 0� addiert man zur Originalzahl ihr Einer-Komplement (= Invertierte) so
ergibt sich immer eine Folge von Einsen� Eine Folge von Einsen ist nichts anderes als (die Invertierte der) Null,
also -0 (+0 � Folge von Nullen), d.h. man hat zur Originalzahl deren „Negatives addiert“
� Beispiel: Wortlänge n = 4 Bit � N = 24 = 16 versch. 0/1-Kombinationen � 16 verschiedene Zahlen darstellbar, bisher (kardinal) 0 ... 15 (= N - 1), jetzt (integer) -7 ... +7, also -(2n-1 - 1) ... +(2n-1 - 1)
� Problem 1: besteht noches gibt zwei Nullen: +0 � 0000; -0 � 1111also: Eine Zahl aber zwei unterscheidbare(!) Bitfolgen
� Problem 2: ist gelöstBei dieser Darstellung genügt ein Addierwerk; Subtraktion bedeutet Addition des Negativen
� Problem 3 (Logik): stellt sich nicht mehr� Problem 4: 1011 = -4 oder +11 ?? durch beschränkten Zahlenbereich -7
.. .. +7 gelöst. Bit ganz links: 1 � negative Zahl, 0 � positive Zahl
Negative Zahlen im Binärsystem (3)
�4 Möglichkeiten der Darstellung (cont‘d)
� Zweier-Komplement (Two‘s Complement)� gebildet durch das Einer-Komplement mit nachfolgender Addition von 1� addiert man zur Originalzahl ihr Zweier-Komplement (= Invertierte + 1) so
ergibt sich immer eine 1 mit nachfolgenden Nullen; die Anzahl der Stellen ist um eine gewachsen
� Streicht man die führende 1, so sind die nachfolgenden Nullen nichts anderes als Null, man hat zur Originalzahl deren „Negatives addiert“
� Beispiel: Wortlänge n = 4 Bit � N = 24 = 16 versch. 0/1-Kombinationen � 16 verschiedene Zahlen darstellbar, bisher (kardinal) 0 ... 15 (= N - 1), jetzt (integer) -8 ... +7, also -(2n-1) ... +(2n-1 - 1)
� Problem 1: besteht nicht mehr: 0000 � 0; 1111 � -1� Problem 2 ist gelöst
Bei dieser Darstellung genügt ein Addierwerk; Subtraktion bedeutet Addition des Negativen
� Problem 3 (Logik): stellt sich nicht mehr� Problem 4: 1011 = -5 oder +11 ?? durch beschränkten Zahlenbereich -8
.. .. +7 gelöst. Bit ganz links: 1 � negative Zahl, 0 � positive Zahl
Negative Zahlen im Binärsystem (4)
�4 Möglichkeiten der Darstellung (cont‘d)
� Zweier-Komplement (cont‘d)
� übrigens: Im Zweier-Komplement stimmt die Dualdarstellung von -5 mit der von 24 - 5 = 16 - 5 = 11 überein:
(5)10 = (0101)2Zweier-Komplement von (5)10: (1010)2 + 1 = (1011)2 = (11)10
� Beispiel mit Dezimalzahlen (b = 10)– Es sei n = 2 � N = 102 = 100 verschiedene Dezimalzahlen, entweder kar-
dinal 0 ... 99 (= N - 1) oder (integer) -50 ... +49, also -5·10n-1 ... + 5·10n-1 -1– Originalzahl sei (z.B.): 23
Ihr Zehner-Komplement: 102 - 23 = 77 . 77 ist nicht im Zahlenbereich -50 ... +49; 77 ist die Darstellung von -23 im Zehner-Komplement (x<0: x � N - |x|)
– addiert man zur Originalzahl ihr Zehner-Komplement, so ergibt sich immer eine 1 mit nachfolgenden Nullen (hier 100); die Anzahl der Stellen ist um eine gewachsen
– Streicht man die führende 1, so sind die nachfolgenden Nullen nichts anderes als Null, man hat zur Originalzahl deren „Negatives addiert“, also eine Darstellung von -23
– � Statt (z.B) 36 - 23 = 13 kann man auch rechnen: 36 + 77 = 113� Statt (z.B) 14 - 23 = - 9 kann man auch rechnen: 14 + 77 = 91 =100 - 9
Negative Zahlen im Binärsystem (5)
�4 Möglichkeiten der Darstellung (cont‘d)
� Zweier-Komplement (cont‘d)
� häufigst genutzte rechnerinterne Darstellung negativer ganzer Zahlen
� Beispiel mit Dualzahlen (b = 2):– Dual zu berechnen: 85 - 103 = -18 (85)10 = (01010101)2– Es sei n = 8 � N = 28 = 256 verschiedene Dezimalzahlen: -128 ... +127– Aus der Subtraktion -103 soll eine Addition werden:
Originalzahl ist: (103)10 = (01100111)2Ihr Zweier-Komplement: 10011000 + 1 = 10011001
– Subtraktion � Addition: 01010101 + 10011001 = 11101110– Anzahl der Stellen nicht gewachsen
� Keine Streichung der führenden 1, die 1 ganz links zeigt ein negativesErgebnis, d.h. Ergebnis liegt als Zweier-Komplement vor
� Übersetzung = Bildung Zweier-Komplement: 11101110 � 00010001 +1 = 00010010 = (18)10
� Das negative Ergebnis lautet -18
Negative Zahlen im Binärsystem (6)
�4 Möglichkeiten der Darstellung (cont‘d)
� Exzess 2n-1
� der gesamte darstellbare Zahlenbereich (positive und negative Halbachse) wird auf die positive Halbachse abgebildet
exzess-zahl = zahl + 2n-1
� Beispiel mit n = 8, d.h. Exzess = „Shift“ = 28-1 = 27
(-3)10 � -3 + 128 = (125)10 = (01111101)2
� Die Darstellungen sind mit denjenigen der Zweier-Komplement-Darstellung bis auf das invertierte linke Bit („Vorzeichen“) identisch
Negative Zahlen im Binärsystem (7)
�Vergleich der 4 Systeme (n=4) Negative Zahlen im Binärsystem (8)
Dual Vorz./Betrag Einer-Kompl. Zweier-Kompl. Exzess
0000 + 0 + 0 0 – 80001 + 1 + 1 + 1 – 70010 + 2 + 2 + 2 – 60011 + 3 + 3 + 3 – 50100 + 4 + 4 + 4 – 40101 + 5 + 5 + 5 – 30110 + 6 + 6 + 6 – 20111 + 7 + 7 + 7 – 11000 – 0 – 7 – 8 01001 – 1 – 6 – 7 + 11010 – 2 – 5 – 6 + 21011 – 3 – 4 – 5 + 31100 – 4 – 3 – 4 + 41101 – 5 – 2 – 3 + 51110 – 6 – 1 – 2 + 61111 – 7 – 0 – 1 + 7
Negative Zahlen im Binärsystem (9)�Zahlenring (n=8) für Dualzahlen und Zweier-Komplement
Gleitkommazahlen: Darstellung und ArithmetikGleitkommazahlen�Zahlenmenge
� rationale Zahlen: r = a/b
Zahlenstrahla
b
1
1r=a/b
� reelle Zahlen: Hinzunahme von nicht-rationalen Zahlen: �, e, �2Die reellen Zahlen in ihrer mathematischen Bedeutung stellen einKontinuum dar (jedes beliebig große Intervall auf dem Zahlenstrahl enthält unendlich viele Werte)
Gleitkommazahlen (1)
�Zahlenmenge (cont‘d)
� Wertebereich REAL (Gleitkommazahlen) im Rechner stellt eine endliche Menge von Repräsentanten von Intervallen des Kontinuums dar � Diskretisierung� numerische Darstellung � Verarbeitung von Daten des Typs REAL
nicht exakt (� numerische Mathematik)
Gleitkommazahlen � mathematisch reelle Zahlen� mathematisch rationale Zahlen
�Zahlendarstellung (Konrad Zuse, 1937)
Gleitkommazahlen (2)
ebmzahl ��
0.1 = 1/10 = 1/b ist kleinstmög-licher Mantissenbetrag!Warum?Der nächstkleinere Zahlen-betrag wäre: 0.099 • 10-99
wegen normierter Darstellung: 0.099 • 10-99
� 0.99 • 10-100
Das ist unmöglich wegen zwei-ziffrigem Exponent! � m : Mantisse , -M < m < +M
Normalform: 1/b � |m| < 1 oder m = 0� b : Basis, z.B. 10, aber auch kleine Potenz von 2: 2, 4, 8, 16� e : Exponent, -E � e � +E, auch -E1 � e � +E2� alle Werte M, b, E sind rechnerabhängig� Aufbau:
zahl = ± 0.a1a2...aµ • be mit a1 � 0 (normalisierte Darstellung)und 0 � ai � b-1
� Beispiel: b = 10, Mantisse m: 3 Ziffern, Exponent e: 2 Ziffern� Mantisse: 1/10 � |m| < 1 oder 0� Exponent: -99 � e � +99� darstellbarer Bereich: – 0.999 • 1099 ... – 0.100 • 10-99
+0.100 • 10-99 ... +0.999 • 1099
� Multiplikation/Division mit b: shift der Zahl-Ziffernfolge um 1 Stelle nach links/rechts oder e � e+1 / e � e-1
Die Mantisse ist somit um 1Bit länger als gedacht, weil a1 nichtgespeichert werden muss!�Normalisierung
� Darstellung der Mantisse in Normalform: 1/b � |m| < 1� eine Mantisse mit gesetztem Führungsbit a1 heisst normalisiert
zahl = ± 0.a1a2...aµ • be mit a1 = 1 � durch die Normalisierung wird die Gleitpunktdarstellung eindeutig
�Rechnerinterne Repräsentation� der verfügbare Platz (hier 2 Byte) wird in Felder aufgeteilt
Gleitkommazahlen (3)
07815
MantisseExponentVorzeichen
� Für arithmetische Operationen muss bei hardwaremäßiger Realisierung hoher Aufwand betrieben werden, daher� Software-Realisierung� Spezialprozessoren� Leistungsdaten: MIPS, FLOPS
Gleitkommazahlen (4)
�Beispiel einer 3 Byte breiten Zahlendarstellung (Basis b = 2)
MantisseExponentVorzeichen
1612 15130 0 0 0 0 0 0 0 0 0 1 1 0 1 100 1 0 1 0 1 0 0
� Vorzeichen: 0, also +� Exponent e: Breite: 7 Bit
Exzess 64(=27-1) - Darstellung(1010100)2 = (84)10 � 84 - 64 = 20be = 2 20 = 1048576
� Mantisse m: Breite: 16 BitDarstellung der Mantisse:
1615131216
1
212121212 �����
�
�����������j
jjam
160134 2)21212121( ����
���������
16227 �
��
� Zahl: zahl = + 27 • 2-16 • 220 = + 432
Gleitkommazahlen (5)�Beispiel (cont‘d)
� Normalisierung:
)2121202121(2(2 543211120 ������
������������
)2121202121(2 543219 �����
�����������
)2121202121(2 161514131220 �����
�����������zahl
� Vorzeichen: bleibt 0, also +� Exponent e: Breite: 7 Bit
Exzess 64(=27-1) - Darstellung9 + 64 = 73 � (73)10 = (1001001)2Exponent e um 11 dekrementiert
� Mantisse m: Breite: 16 BitMantisse um 11 Bit nach links geschoben
MantisseExponentVorzeichen1 0 0 1 1 0 0 0 0 0 0 0 0 0 010 1 0 0 1 0 0 1
� Zahl bleibt erhalten: zahl = + 27 • 2-5 • 29 = + 432
Gleitkommazahlen (6)
�REAL-Zahlen auf dem Zahlenstrahl� Beispiel: b = 10, Mantisse m: 3 Ziffern, Exponent e: 2 Ziffern
0-10100 - 0.100 • 10-99 +10100+0.100 • 10-99
negative overflow
positive overflow
negative underflow
positive underflow
NULLausdrückbarenegative Zahlen
ausdrückbarepositive Zahlen
-0.999 • 1099 -0.999 • 1099
� jede REAL-Zahlen repräsentiert ein Intervall der reellen Zahlen;das Intervall wächst mit zunehmendem Betrag der Zahl, d.h. die Dichte der Repräsentation nimmt mit zunehmendem Betrag der Zahl ab
� Eine Abschätzung des Einflusses der Ungleichverteilung der Repräsentanten auf die rechenoperationen ist nicht trivial
� Behandlung von overflow/underflow, Null, „undefiniert“? � IEEE Floating-Point Standard 754 (1985) (siehe A.S. Tanenbaum)
Gleitkommazahlen (7)
�Probleme� Test: Assoziativgesetz (Beispiel mit 4-stelliger Arithmetik)
x = 9.900, y = 1.000, z = -0.999(x+y) + z = 10.90 + (-0.999) = 9.910x + (y+z) = 9.900 + 0.001 = 9.901
� Test: Distributivgesetz (Beispiel mit 4-stelliger Arithmetik)x = 1100., y = -5.000, z = 5.001(x•y) + (x•z) = (-5500) + 5501 = 1.000x • (y+z) = 1100. • 0.001 = 1.100
� AuslöschungBei der Subtraktion zweier fast gleich großer Werte heben sich die signifikanten Ziffern auf und die Differenz verliert dadurch an Signifikanz (z.B. Differenzenquotient)
� Überlaufgefahr... bei Division durch kleine Werte
Gleitkommazahlen (8)
�Rechnerarithmetikyx e
ye
x mymx 2,2 ����
� Addition
yxe
yee
x eefallsmmyx yyx������
� 2)2(� Subtraktion
eeeyxyx eefallsmmyx yyx
������� 2)2(
� Multiplikationee yx
yx mmyx �
���� 2)(� Division
ee yxyx mmyx �
���� 2)(