Teil III : Vom Algorithmus zur Programmiersprache

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 heisst
es 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 Marmorkuchen
Zutaten: mehr oder minder eindeutige Eingabeparameter
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.
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ösen
2. Wagen anheben
3. Rad entfernen
4. Reserverad montieren
5. Wagen absetzen
6. 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 ansetzen
2.2 Wagen hochpumpen
3.1 Schrauben entfernen
3.2 Rad abnehmen
Ø
Auch bereits detaillierte Schritte können noch weiter verfeinert werden
2.1.1 Bordbuch holen
2.1.2 Ansatzpunkte für Wagenheber ermitteln
2.1.3 geeigneten Ansatzpunkt auswählen
2.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 angegebenem 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 Hilfe
oder auch
Falls 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 anrufen
Wohnhaus : bitte Anwohner um Hilfe
Tankstelle:
Tankwart um Hilfe bitten
M
ansonsten:
Warten bis jemand vorbeikommt
Wiederholung
Ø
Ø
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 links
sonst 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 links
oder auch
wiederhole
drehe Schraube eine Drehung nach links
bis Schraube nicht mehr mit Nabe verbunden
oder auch
wiederhole immer wieder
drehe Schraube eine Drehung nach links;
falls Schraube nicht mehr mit Nabe verbunden dann höre auf
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 Sprache
festgelegt
Ø 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 Maus
Maus frisst Katze
Semantik:
Maus ist Beutetier von Katzen
Katze jagt Vögel, Mäuse
Definition algorithmischer Sprachen
Ø Syntax
·
·
regelhafte Beschreibung (Festlegung) der äusseren Form einer
Zeichen- oder Wortfolge, die ein legales Konstrukt der algorithmischen Sprache ergibt
Regeln sind abhängig oder unabhängig von der Interpretation formulierbar
Ø 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: Multiplikation
a := 5;
b := 6;
c := a • b
¾®
c = 30
Syntax:
lt. Konstruktionsregeln ein gültiger Ausdruck
Semantik:
Bedeutung: Multiplikation zweier Zahlen a, b
mit bestimmtem Typ (und Wertebereich)
Pragmatik:
Zurückführung der Multiplikation auf einzelne
Additions- 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 Grammatik
festgelegten Regeln
Semantik (Bedeutungslehre): Beschreibung der Wirkung eines Programms
auf 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 Zeichenmengen
S: 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 = S
S2 = S x S
M
Sk = S x S x ... x S (k-fach)
M
Sk: Menge aller Zeichenketten w = s1s2...sk der Länge k über S
S*: Menge aller Zeichenketten endlicher Länge über S incl.
leerem Wort l (S* ist freie Sprache über S)
·
Sprache über S
S* enthält alle, durch beliebige Anordnung von siÎS konstruierbaren 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) mit
SN: Menge der Nichtterminalzeichen
ST: Menge der Terminalzeichen
SN Ç ST = Æ
P = {pi}, |P| = n < ¥: Produktionen (Ersetzungsregeln)
PÍ (SNÈ ST)* x (SNÈ ST)*
pi : a ® b, wenn (a,b) Î P
wS : Startwort, wS Î (SNÈ ST)*, | wS| ³ 0
·
Aus einem Wort u kann ein Wort v dadurch abgeleitet werden,
indem ein a in u durch b 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)
·
Strategien
Top-Down: ausgehend vom Startsymbol wird mittels der
Produktionen (Ersetzungsregeln) abgeleitet, bis die gegebene Folge
„generiert“ ist.
Bottom-Up: umgekehrt (durch „Reduktion“)
·
Beispiel
G = (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)
® 00001A11 ® 0000111
(4)
(2)
(3)
(4)
Kontextfreie Grammatiken und Programmiersprachen
Ø Kontextfreie Grammatik
·
G = (SN, ST, P, Z) mit
SN, ST: wie gehabt
PÍ SN x (SNÈ ST)* , d.h.
pi : A ® b, wenn (A,b) Î 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 ® a | b
als Abkürzung für die Produktionen
A ® a, A ® b
·
Wiederholungen
- 0- oder 1-mal a:
- 0-, 1- oder n-mal a:
·
A ® [a]
A ® {a}
Beispiel von vorne
aus den Produktionen
S ® 0A11, A ® , A ® 0A, A ® 1A
wird in EBNF
S ® 0A11, A ® {0 | 1}
Ø Syntaxdiagramme
·
Graphische Darstellung für kontextfreie Grammatiken
·
Grundbausteine der Diagramme
§
Nicht-terminale Zeichen (Variablen) A
A
(à Platzhalter für ein weiteres Diagramm)
§
Terminalzeichen s
s
(à Zeichen der formalen Sprache)
§
Konkatenationen (Wortkonstruktionen)
(à Übergang von einem Knoten
(
) zum Folgenden)
·
Beispiel Grammatik von vorne
S
0
A
1
1
A
0
1
Ø Zusammenhang: EBNF – Syntaxdiagramm
1.
Alternative
A ® a | B.
2.
B
Verkettung
A ® aB .
3.
a
A
A
a
B
Wiederholungen
0- oder 1-mal a
A ® [a ].
0-, 1- oder n-mal a
A ® {a }.
a
a
2. Programm- und Sprachelemente
• Programmieren und Sprachen
• Erste Schritte in MODULA-2
• Syntaxdiagramme
Programmieren und Sprachen
Entwurf und Notation von Programmen
Programmiersprache
mit
Aufbauregeln (Syntax)
und
Standardinterpretation
(Semantik)
Ziel ist es,
einen Algorithmus zur Lösung eines Problems in einer maschinell
erfassbaren Form zu formulieren
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 des
Problems
Entwicklung eines
Algorithmus
Kodierung mittels
Programmiersprache
Editieren
am Rechner: Compilieren
richtig kodiert?
Ausführen
(Syntax)
... das
Programm
dem
Algorithmus
entspricht?
... der
Algorithmus
das
Problem
löst?
Testen, d.h. prüfen ob ...
falls o.k.
Programm ist fertig und „wahrscheinlich“ korrekt
Testen & beweisbare Korrektheit
reale Phänomene
Modellbildung
Abstraktion
Objekte
Algorithmen &
Datenstrukturen
® Spezifikation
Codierung
Daten
Strukturierung
Datenstrukturen
Algorithmen
Formulierung
® Syntax
Entwurf
Programme
Realisierung am Rechner
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]
IMPORT
Deklarationen 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;
BEGIN
WriteString(“Allgemeine Informatik I");
WriteLn;
WriteString(“Wintersemester 2001/2002");
WriteLn;
END Ueberschrift.
Ausgabe des angegebenen
Texts mit Zeilenvorschub
Kommunikation: Programm - Betriebssystem
Modula-2 Programm
IMPORTs
Bibliotheks-Modul
Bibliotheks-Modul
Bibliotheks-Modul
Bibliotheks-Modul
Anforderungen
Betriebssystem
(hier: UNIX)
Dienste
Ø 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“)
Modula-2
Programm
Modula-2
Compiler
<name>.m2
Fehlermeldungen
(Syntaxfehler)
ausführbarer Code
a.out
UNIX
input
a.out
UNIX
output
Ü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 Datentypen
Eigenschaften 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
Gleitkommazahlen
POINTER
REAL
LONGREAL
COMPLEX
LONGCOMPLEX
ARRAY
STRING
Ganzzahlen und
Ordinaltypen
CARDINAL
INTEGER
BOOLEAN
CHAR
Zeiger Datentypen
Ausschnittstyp/
Unterbereichstyp
(subrange)
Aufzählungstyp
(enumeration)
RECORD
SET,
PACKEDSET
BITSET
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
+
nur beschränkter
Wertebereich verfügbar !!
* Subtraktion
–
* Multiplikation
*
* ganzzahlige Division mit Rest
DIV, MOD
* Vergleiche
=,<>,>=,>,<=,<
· Beachte: Vergleichsoperationen sind zweistellig
* Falsch: x < y < z
Ø 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
Vergleiche
Vorzeichenumkehrung
+
nur beschränkter
–
Wertebereich verfügbar !!
*
DIV, MOD
=,<>,>=,>,<=,<
–
· Konvertierung « Cardinal
VAR
i,int
: INTEGER;
c,card
: CARDINAL;
i:= INTEGER(card);
c:= CARDINAL(int)
Ø 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) =: q
wobei q > 0, if sgn(x)=sgn(y)
q = 0, if abs(x)<abs(y)
q < 0, if sgn(x)¹sgn(y)
· x MOD y =: r
wobei 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
* Konjunktion, logisches UND
* Disjunktion, logisches ODER
NOT
AND
OR
~
&
Rangordnung
* Vergleiche
· Verwendung
* Ergebnis einer Vergleichsoperation
* Ausdruck einer erfüllten oder nicht erfüllten Eigenschaft
* Variablen vom Typ BOOLEAN sollten Eigenschaftsworte sein
· Boolean in Bedingungen:
anstatt:
IF billig THEN ... ELSE ...
IF billig = TRUE THEN ... ELSE ...
anstatt:
IF NOT billig THEN ... ELSE ...
IF billig = FALSE THEN ... ELSE ...
Beispiele zur Aussagenlogik
Wahrheitstabelle:
P
NOT p
FALSE
0
TRUE1
TRUE
1
FALSE
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
1
TRUE
1
TRUE
1
TRUE
1
TRUE1
TRUE
1
FALSE
0
FALSE
0
FALSE
0
FALSE0
FALSE
0
TRUE
1
TRUE
1
TRUE
1
TRUE1
FALSE
0
FALSE
0
TRUE
1
TRUE
1
TRUE1
Ø 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
Dezimalpunkt !!
(beschr. Stellenzahl)
· Deklaration:
CONST pi = 3.1415;
VAR coeff,std,temp: REAL;
· Ein-/Ausgabe:
FROM RealInOut IMPORT
· Operationen:
*
*
*
*
*
*
ReadReal(var),
WriteReal(var,minstellen);
Addition
+
Subtraktion
–
Multiplikation
*
Division
/
Vergleichsoperatoren
=,<>,>=,>,<=,<
alle Op. auf REAL-Werten sind Approximationen
(Genauigkeit von Maschine/Implementierung)
· Konvertierung
* FLOAT:
* TRUNC:
CARDINAL / INTEGER ® REAL
REAL ® CARDINAL / INTEGER
Operationsprinzipien – Anweisungen
Allgemeines
Ø Ein Programm manipuliert Daten
· Operationen ® Datenmanipulation (d.h. Zustandsänderung)
· Aktionen (® Zustandsänderung) werden in Anweisungen (statements)
beschrieben
statement
einfach
((Wert-)Zuweisung)
strukturiert
zusammengesetzt
bedingt
Prozedur
repetetiv
Syntaktische Definition von Anweisungen
Zuweisung und Ausdrücke (1)
Ø Zuweisung („assignment“) :=
· Syntax
· 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 := x
x := y (* x und y haben denselben Wert *)
y := xalt
Zuweisung und Ausdrücke (2)
Ø Ausdruck („expression“)
· Auswerteregeln: links ® rechts, algebraische Regeln
Ausdruck
Operanden
Konstanten Variablen Funktionen
Operatoren
monadisch
(einstellig)
dyadisch
(zweistellig)
Ausdrücke mit mehreren Operatoren:
- (explizit) Klammerungen
- (implizit) durch Sprachregelung festgelegte 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
Û
2*3-4*5
Û
80 / 5 / 3
Û
SQRT(SQR(3) + 11*5) = 8.000
4 = 0
® = FALSE
· Syntax einfacher Ausdrücke
((3.0 * 8.0) / 4.0) * 5.0
(2 * 3) - (4 * 5) = -14
(80 / 5) / 3 = 5.333
Zuweisung und Ausdrücke (4)
Ø Ausdruck („expression“) (cont‘d)
· Rangfolge von Operatoren (ergibt sich aus Syntax)
* Negation und unäres Minus
(in Factor)
* Multiplikationsoperatoren
(in Term)
* Additionsoperatoren
(in SimpleExpression)
* Relationaloperatoren
(in Expression)
· Beispiel
* – 3 – 4 DIV –2 < 7 + 3 * – 2
NOT(~), –
*, /, DIV, MOD, AND(&)
+, – , OR
=, <>, >=, >, <=, <, IN
Rangfolge
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, nicht
als 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 THENAnweisungsfolge ...
* falls logische Bedingung = false ® Abarbeitung der ELSEAnweisungsfolge ...
· Beispiel: Schein oder nicht Schein
IF note <= 4.0
THEN WriteString(“bestanden")
ELSE WriteString("nicht bestanden")
END;
Verzweigungen - Fallunterscheidungen (2)
Ø IF - Anweisung (Cont‘d)
· Struktur: Mehrfachauswahl
IF ... THEN ...
ELSIF ... THEN ...
M
ELSE ... END
· Syntax
· Beispiel:
Notenschlüssel
IF
ELSIF
ELSIF
ELSIF
ELSE
END;
punkte >= 100 THEN
punkte >= 80 THEN
punkte >= 60 THEN
punkte >= 40 THEN
WriteString("Note
WriteString("Note 1")
WriteString("Note 2")
WriteString("Note 3")
WriteString("Note 4")
5 (nicht bestanden!)")
Verzweigungen - Fallunterscheidungen (3)
Ø CASE - Anweisung
· n unabhängige Ausgangssituationen (cases); jede ist mit einer
Aktion verbunden
· Struktur
CASE Ausdruck zur Fallunterscheidung OF
K : ...
¬ Fall 1
K : ...
¬ Fall 2
M
ELSE ... ¬ Fall n oder der „Rest“
END
· Syntax
Verzweigungen - Fallunterscheidungen (4)
Ø CASE - Anweisung (cont‘d)
· Beispiel: Notenschlüssel
CASE
punkte OF
0..39 : WriteString("Note
|40..59 : WriteString("Note
|60..79 : WriteString("Note
|80..99 : WriteString("Note
ELSE
WriteString("Note
END;
5 (nicht bestanden!)")
4")
3")
2")
1")
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;
Aufrufe von Prozeduren
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;
.....
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;
BEGIN
WriteString("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
kopfgesteuert
Anweisung
Schleifenbedingung
Zählschleife
nicht
erfüllt
LOOP
Initialisierung
Anweisung
erfüllt
Schleifenbedingung
nicht
erfüllt
erfüllt
Endstand
erreicht
Anweisung
nein
Anweisung
Veränderung
ja
EXIT
Anweisung
Wiederholungsanweisungen (4)
Ø WHILE-Schleife
· Struktur:
WHILE Bedingung DO
M (*Anweisungsfolge*)
END
· Beispiel: Fakultät (mit „?“ markierter Teil)
WHILE i < n DO
i := i+1; x := x*i
END
· Syntax:
Wiederholungsanweisungen (5)
Ø REPEAT-Schleife
· Struktur:
REPEAT
M (*Anweisungsfolge*)
UNTIL Bedingung
· Beispiel: Fakultät (mit „?“ markierter Teil)
REPEAT
i := i+1; x := x*i
UNTIL i >= n
· Syntax:
Wiederholungsanweisungen (6)
Ø FOR-Schleife
· Struktur:
FOR index:=ausdruck1 TO ausdruck2 BY KonstAusdruck DO
M (*Anweisungsfolge*)
END
· Beispiel: Fakultät (mit „?“ markierter Teil)
FOR k:= 1 TO n BY 1 DO
x := x*k
END
· 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
M (*Anweisungsfolge mit EXIT(s)*)
END (*LOOP*)
· Beispiel: Fakultät (mit „?“ markierter Teil)
LOOP
i := 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 = a
ggT(a,b) = ggT(a-b,b)
falls b < a
ggT(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 = 0
ggT(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 ;
BEGIN
WriteString("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) THEN
WHILE (x <> y) DO
IF (x > y ) THEN x := x - y
ELSE (* y < x *) y := y - x
END (* IF *)
END; (* WHILE *)
WriteString("GGT = ");
WriteCard(x,0)
ELSE
WriteString("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 bedingung
END
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 schalter
REPEAT anweisung UNTIL abbruchbedingung
konvertiert in:
schalter := TRUE;
WHILE schalter DO
anweisung;
schalter := NOT abbruchbedingung
END
Beispiel „FOR“: Normalverteilungswerte
MODULE
FROM
FROM
FROM
Normalverteilung;
RealInOut
IMPORT ReadReal, WriteFloat;
InOut
IMPORT WriteString, WriteLn, WriteInt;
MathLib
IMPORT exp, sqrt;
CONST
pi = 3.141592653589793238462643383;
Max = 10;
VAR
i
std scale, faktor, GaussWert
: INTEGER;
: REAL;
BEGIN
WriteString("Berechnung der Normalverteilung ...);
WriteLn;
WriteString("Eingabe der Standardabweichung: ");
ReadReal(std); WriteLn;
scale := 1.0 / (sqrt(2.0 * pi) * std);
FOR i := -max TO max DO
faktor := -(FLOAT(i) * FLOAT(i)) / (2.0 * std);
GaussWert := scale * exp(faktor);
WriteInt(i, 5); WriteString(" : ");
WriteFloat(GaussWert, 4, 8); WriteLn
END
END Normalverteilung.
Beispiel „LOOP“: Werbeseiten (aus Puchan et al.)
LOOP
EXIT
EXIT
END
Beispiel „LOOP“: Werbeseiten (aus Puchan et al.)
MODULE Werbung;
FROM STextIO
FROM NochzuSchreiben
IMPORT Write, WriteString, WriteLn;
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
EXIT
END(*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
EXIT
END(* IF *);
END(* LOOP *)
END Werbung.
MODULE wcount;
(* counts chars, words and lines from stdin *)
Beispiel „WHILE“:
Wordcount
FROM InOut IMPORT Read, Done, WriteString, WriteLn, WriteCard;
CONST
newline
blank
tab
= 12C;
= 40C;
= 11C;
Steuerzeichen im Text
VAR
chars, words, lines
ch
inword
BEGIN
chars
words
lines
inword
:=
:=
:=
:=
0;
0;
0;
FALSE;
: CARDINAL;
: CHAR;
: BOOLEAN;
Initialisierung der Zähler chars, words und lines,
sowie des „Zustands“ „im Wort“
Einlesen des 1. Zeichens
Read(ch);
WHILE Done DO
chars := chars + 1;
IF inword THEN
CASE ch OF
| blank, tab, newline : inword :=
words :=
ELSE (* nichts *)
END (* CASE *)
ELSE
CASE ch OF
| blank, tab, newline : (* nichts
ELSE
inword :=
END (* CASE *)
END; (* IF *)
FALSE;
words + 1
*)
TRUE
Schleife „arbeitet“ solange Zeichen eingelesen werden.
Analyse aller eingelesenen Zeichen:
Zeichen im Wort?
Wenn nein: neue Zeile, Tab, oder Blank
IF ch = newline THEN
lines := lines + 1
END; (* IF *)
Einlesen des „nächsten“ Zeichens
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.
Ausgabe des Ergebnisses
MODULE numlines;
(* text files with line numbers *)
Beispiel „WHILE“:
Zeilennummerierung
FROM InOut IMPORT Read, Done, Write, WriteString, WriteLn, WriteCard;
CONST
newline = 12C;
VAR
number : CARDINAL;
ch
: CHAR;
first : BOOLEAN;
BEGIN
number := 0;
first := TRUE;
Read(ch);
WHILE Done DO
IF first THEN
number := number + 1;
WriteCard(number,4); WriteString(": ");
first := FALSE
END; (* IF *)
IF ch <> newline THEN
Write(ch)
ELSE WriteLn; first := TRUE
END; (* IF *)
Read(ch)
END (* WHILE *)
END numlines.
Einfache selbstdefinierte Typen
Taxonomie der Datentypen
Einordnung
Datentypen
bisher:
Einfache Datentypen
Strukurierte Datentypen
Gleitkommazahlen
POINTER
REAL
LONGREAL
COMPLEX
LONGCOMPLEX
ARRAY
RECORD
STRING
Ganzzahlen und
Ordinaltypen
CARDINAL
INTEGER
BOOLEAN
CHAR
Zeiger Datentypen
jetzt:
Aufzählungstyp (enumeration)
Ausschnittstyp/
Unterbereichstyp (subrange))
SET,
PACKEDSET
BITSET
Ø 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 Variablendeklaration
VAR
Tag : (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 Typdefinition
TYPE
Wochentag = (Montag, Dienstag, Mittwoch, Donnerstag,
Freitag, Samstag, Sonntag);
FarbPalette = (Weiss, Rot, Blau, Gelb, Gruen, Schwarz);
VAR
Tag
Farbe
: Wochentag;
: FarbPalette;
* wäre BOOLEAN nicht schon Standard
TYPE
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 vorkommen
nicht 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ählungstyp
TYPE
Spielkarte : (Sieben, Acht, Neun, Bube, Dame,
Koenig, Zehn, As);
VAR
Karte : Spielkarte;
BEGIN
...
WriteCard(ORD(MIN(Spielkarte)), 2);
WriteCard(ORD(MAX(Spielkarte)), 2);
Karte := Neun;
WriteCard(ORD(Karte), 2);
= ORD(Sieben) = 1
= ORD(As) = 8
= ORD(Neun) = 3
INC(Karte);
WriteCard(ORD(Karte), 2); WriteLn;
Karte := Bube
DEC(Karte, 2);
WriteCard(ORD(Karte), 2); WriteLn;
Karte := Acht
= ORD(Bube) = 4
= ORD(Acht) = 2
END
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
* Typdefinition
TYPE
Buchstabe
Ziffer
ZahlInt
Wochentag
VL_Tag
BYTE
=
=
=
=
=
=
[“a” .. “z”];
[0 .. 9];
(*Grundtyp CARDINAL*)
INTEGER[1 .. 10];
(Mo, Di, Mi, Do, Fr, Sa, So);
[Mo .. Fr];
[0 .. 255];
* Variablendefinition
VAR
CAPITAL
OktZiffer
: [“A” .. “Z”];
: 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
Wochentage
VAR
= (So, Mo, Di, Mi, Do, Fr, Sa);
= [Mo .. Fr];
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)
=
=
=
=
=
=
=
=
=
=
=
=
=
42
Fehler
Fehler
42
-2
42.0
Fehler
0C
Fehler
FALSE
Fr
Fr
Fehler
Beziehungen mit VAL
CHR(x)
ORD(x)
INT(x)
TRUNC(x)
FLOAT(x)
=
=
=
=
=
VAL(CHAR, x)
VAL(CARDINAL, x)
VAL(INTEGER, x)
VAL(CARDINAL, x)
VAL(REAL, x)
x vom Typ T:
INC(x,n) « x:=VAL(T,VAL(INTEGER,x)+n)
Aufzählungs- und Unterbereichstypen (8)
Ø Kompatibilität (auch für strukturierte Daten)
· Typkompatibilität
strenge 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 den
gleichen Grundtyp
· Zuweisungskompatibilität
Variable 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
Strukturierte Daten
Datenstrukturen
bisher:
Taxonomie der Datentypen
Datentypen
jetzt:
Einfache Datentypen
Strukurierte Datentypen
Gleitkommazahlen
POINTER
REAL
LONGREAL
COMPLEX
LONGCOMPLEX
ARRAY
STRING
Ganzzahlen und
Ordinaltypen
CARDINAL
INTEGER
BOOLEAN
CHAR
Zeiger Datentypen
Ausschnittstyp/
Unterbereichstyp
(subrange)
Aufzählungstyp
(enumeration)
RECORD
SET,
PACKEDSET
BITSET
Ø 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)
· Deklaration
VAR
feld
: 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 Indextypen
TYPE
TAGE
VAR
tabelle
=
(So, Mo, Di, Mi, Do, Fr. Sa);
: ARRAY[CHAR] OF CHAR;
Übersetzung eines Zeichensatzes in einen anderen
speicher
Ordinaltyp
: ARRAY[0 .. 1000] OF INTEGER;
lineares Speichersegment
Ordinaltyp
Unterbereich aus
CARDINAL/INTEGER
freierTag : ARRAY[TAGE] OF BOOLEAN;
arbeitsfreie Wochentage
Ordinaltyp
oben definierter Typ
Aufzählungstyp
matrix
: ARRAY[1 .. 3],[1 .. 5] OF REAL;
3 x 5 Matrix
Ordinaltyp
Unterbereich aus
CARDINAL/INTEGER
ARRAYs (Felder) (3)
Ø Allgemeines (cont‘d)
· Beispiele zu gültigen Vereinbarungen von ARRAYs
CONST
n = 8;
TYPE
Wort
Vektor
Letter
Farbe
Fahne
Muster
Palettel
Palette2
Matrix
Matrixl
=
=
=
=
=
=
=
=
=
=
ARRAY[0..3] OF CHAR;
ARRAY[1..n] OF REAL;
ARRAY["a".."z"] OF INTEGER; nicht typkompatibel
(rot, gelb, blau);
trotz interner identischer Struktur
ARRAY[1..3] OF Farbe;
ARRAY Farbe OF BOOLEAN;
ARRAY[1..n] OF ARRAY Farbe OF BOOLEAN;
ARRAY[1..n], Farbe OF BOOLEAN;
ARRAY[1..n],[1..n] OF REAL;
ARRAY[1..n] OF Vektor;
VAR
name,vorname
feld
feld1
k1Buchst
muster
identity
v
z
:
:
:
:
:
:
:
:
Zuweisungen an Feldelemente
name[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;
Wort;
Matrix;
Matrixl;
Letter;
Muster;
Matrix;
Vektor;
ARRAY[1..n] OF Muster;
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 denselben oder einen durch Typumbenennung (Alias) entstandenen
kompatiblen Typ haben!
ARRAYs (Felder) (5)
Ø Repräsentation
CONST
n = 5;
m = 3;
VAR
vektor : ARRAY[1..n] OF CARDINAL;
matrix : ARRAY[1..n],[1..m] OF CARDINAL;
Intuition:
- 1. Index = Zeile
- 2. Index = Spalte
vektor
(=Adresse)
1
2
3
4
5
matrix
(=Adresse)
1
2
3
4
5
1
2
3
4
5
6
7
8
9
10 11 12
13 14 15
1,1
1,2
1,3
2,1
2,2
2,3
3,1
3,2
3,3
4,1
5,1
matrix
(=Adresse)
1
2
3
4,2
4,3
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 DO
FOR j:=1 TO m DO
matrix[i,j]:= j + (i-1)*m
END
END
1
1
2
2
3
3
4
4
5
5
6
6
7
7
8
8
9
9
10 11 12
10 11 12
13 14 15
13 14 15
1,1
1,2
1,3
2,1
2,2
2,3
3,1
3,2
3,3
4,1
5,1
4,2
4,3
5,2
5,3
* innere Schleife zu 1. Index
FOR j:=1 TO m DO
FOR i:=1 TO n DO
matrix[i,j]:= i + (j-1)*n
END
END
1
1
2
6
3
11
4
2
5 6
7 12
7
3
8 9
8 13
10 11 12
4 9 14
13 14 15
5 10 15
1,1
1,2
1,3
2,1
2,2
3,1
3,2
4,1
5,1
2,3
3,3
4,2
4,3
5,2
5,3
ARRAYs (Felder) (7)
Ø Strings (Zeichenketten)
besonderer ARRAY-Typ für Komponenten vom Typ CHAR
· Struktur
I
f
I
n
f
o
r
m
a
t
i
k
T
h
e
n
U
n
· Deklaration
TYPE
STRING = ARRAY[0..27] OF CHAR;
CONST
s = “string";
leer = “"; (* Leer-String *)
· Operationen
Ein-/Ausgabe
FROM InOut
IMPORT ReadString;
* Schreiben:
U
l
Obere Feldgrenze
Untere Feldgrenze
* Lesen:
i
0C = CHR(0), Nullbyte
m 0C
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)
VAR
artikel: RECORD
nummer
bestand
preis
lager
END
:
:
:
:
CARDINAL;
CARDINAL;
REAL;
RECORD
gang : [‘A‘..‘H'];
regal : [1..7];
ebene : [1..4]
END
RECORDs (Verbunde) (3)
Ø Feste Verbunde (cont‘d)
· Komponenten
RECORD-Komponente besteht aus Selektor und Komponenten-Typ
preis
Selektor
:
REAL
Komponententyp
RECORD- Komponente
· Zugriff auf individuelle Komponenten
<Bezeichner>.<Selektor>
RECORD-Name
Komponentenname
Selektor- Punkt
RECORDs (Verbunde) (4)
Ø Feste Verbunde (cont‘d)
· Beispiel (1) für Zugriff und Zuweisung
VAR
heute, morgen,
datum
: RECORD
tag
: [1..31];
monat : (Jan, Feb, Mar, Apr, Mai, Jun, Jul, Aug,
Sep, Okt, Nov, Dez);
jahr : [1900..2100]
END
BEGIN
...
datum.tag
datum.monat
datum.jahr
...
heute.jahr
morgen.tag
datum
...
END
:= 10;
:= Apr;
:= 2000;
:= 2001;
:= heute.tag + 1;
:= heute;
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)
Beispiel
* bei ARRAYs: elementweise Verarbeitung
WITH datum DO
durch FOR-Anweisung
tag
:= 10;
* bei RECORDs:
monat := Apr;
jahr := 2000
einzelne Elemente i.A. unterschiedlichen Typs
END;
(® unterschiedliche Operationen)
®
Zusammenfassung einer Folge individueller Anweisungen, die
sich auf Komponenten desselben Verbundes beziehen
®
bessere Übersichtlichkeit und Effizienzsteigerung falls (intern!)
* Syntax
RECORDs (Verbunde) (6)
Ø Zuweisung (cont‘d)
· Beispiel (3) Zuweisung
VAR
studenten : 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_dies
ELSE Tue_das
...
END
RECORD im RECORD
RECORDs (Verbunde) (7)
Ø RECORD mit Varianten (Verbunde mit Varianten)
· Verwendung
Möglichkeit mehrere verwandte (nicht ganz identische) RECORDs
unter einem Namen (ein Datentyp!) zu definieren
· Syntax
Das Diagramm Komponente wird durch die CASE-Klausel erweitert
Selektor
RECORDs (Verbunde) (8)
Ø RECORD mit Varianten (cont‘d)
· Deklaration (in TYPE oder VAR)
Programm muss zwischen den verschiedenen Varianten unterscheiden können (® CASE-Klausel)
· Beispiel: komplexe Zahlen (COMPLEX), die entweder kartesisch
oder polar dargestellt werden:
Selektor mit IndexTyp (muss Aufzählungstyp sein)
TYPE
COMPLEX = RECORD
CASE art : (kartesisch, polar) OF;
Auswahl:
kartesisch : re, im : REAL
jeweils ein Wert des
| polar
: r, phi : REAL
ELSE
Selektors aus der
END
Aufzählung.
Damit wird die
Variante bezeichnet
kann auch
entfallen
Zu jeder Variante
müssen die zugehörigen
Komponenten des Verbundes deklariert werden.
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öglichkeit is highly recommended
RECORDs (Verbunde) (10)
Ø RECORD mit Varianten (cont‘d)
· Beispiel „Personalverwaltung“
TYPE
STRING30 = ARRAY[0..29] OF CHAR;
STATUS
= (verh, verw, gesch, ledig);
DATUM
= RECORD
fester RECORD
tag
: [1..31];
monat : (Jan, Feb, Mar, Apr, Mai, Jun, Jul, Aug,
Sep, Okt, Nov, Dez);
jahr : [1900..2100]
END;
PERSON
= RECORD
RECORD mit Varianten
name
: RECORD
nachname, fester RECORD im RECORD
vorname
: STRING30
END;
groesse
: [0..MaxInt]; (* in cm *)
gebDatum : DATUM;
Varianten im RECORD PERSON
CASE MS : STATUS OF
verh, verw : Hdatum : DATUM
| gesch
: Sdatum : DATUM;
ersteS : BOOLEAN
| ledig
:
(* leer *)
END
END;
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 ...
· Zugriff
Kein 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“
SETs (Mengen) (2)
Ø Allgemeines (cont‘d)
· Syntax
vordefiniert
benutzerdefiniert
Syntaxdiagramme aus Puchan et.al.
SETs (Mengen) (3)
Ø Allgemeines (cont‘d)
· Mengenkonstante
explizite Aufzählung der zur Menge gehörigen Elemente in { ... }
(die leere Menge { } ist möglich)
{
Dem Klammerpaar {...} muss
der Grundtyp vorangestellt werden
nicht notwendig bei BITSET
}
SETs (Mengen) (4)
Ø Allgemeines (cont‘d)
· Beispiel „Personenbeschreibung“
TYPE
Eigenschaften
Personenbeschreibung
...
VAR
Taeter
...
= (gross, klein, dick, normal, schlank,
fleissig, ordentlich, baertig);
= SET OF Eigenschaften;
: Personenbeschreibung;
· Beispiel „Farb-Palette“
TYPE
FARBE
...
= (rot, gruen, blau);
CONST
rg
alle
...
= FARBE{rot, gruen};
= FARBE{rot .. blau};
VAR
x
...
: SET OF FARBE;
SETs (Mengen) (5)
Ø Operationen auf Mengen (cont‘d)
· Mengenoperationen (Ergebnistyp = Operandentyp)
* Vereinigung È
* Durchschnitt Ç
* Differenz \
A \ B = A Ç ¬B
® +
® •
® –
* symmetrische Differenz D
A D B = (A È B) \ (A Ç B)
® /
Menge aller Elemente die A und nicht in B enthalten sind
Menge aller Elemente die genau in einer der beiden Mengen A, B enthalten sind
· Vergleichsoperatoren (Ergebnistyp = BOOLEAN)
*
*
*
*
Gleichheit =
Ungleichheit ¹
Inklusion Ê bzw. Í
Element von/aus Î
®=
® <>, #
® >= bzw. <=
® IN
SETs (Mengen) (6)
Ø Operationen auf Mengen (cont‘d)
· Beispiel „Vereinigung“
TYPE
Card
= SET OF [1..4];
...
VAR
m
: 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“
TYPE
Card
= SET OF [1..4];
...
VAR
m
: 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}
1 IN Card{1..3, 4}
Card{1, 2} <= Card{1..4}
Card{1, 2} >= Card{1..4}
Card{1, 2, 3, 4} <> Card{1..4}
Ergebnis: FALSE
Ergebnis: TRUE
Ergebnis: TRUE
Ergebnis: FALSE
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:
* Entfernen:
Ø Implementierung
INCL(menge,element)
Û menge := menge + {Elementwert}
EXCL(menge,element)
Û menge := menge - {Elementwert}
(Vereinigung)
(Differenz)
· 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-)Position
TYPE
menge
...
VAR
x
...
= SET OF ['a' .. 'p'];
: menge;
0
1
a
1
0
b
x := menge ['a','c','k','p'];
2
1
c
3
0
d
4
0
e
5
0
f
6
0
g
7
0
h
8
0
i
9 10 11 12 13 14 15
0 1 0 0 0 0 1
j k l m n o p
4. Zahlendarstellung
• Zahlen und ihre Darstellung in Digitalrechnern
• Gleitkommazahlen: Darstellung und Arithmetik
Zahlen und ihre Darstellung in Digitalrechnern
Grundstrukturen: Speicherorganisation und Zahlenmengen
Ø Linear organisierter Speicher
· zu einer Adresse gehört ein Speicher mit 32 Bit-Zellen
(1 Wort „breit“)
adresse
Linearer Speicher
bit
MSB
31
24 23
16 15
LSB
0
8 7
Halbwort
byte
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)
Ø Basis-Zahlendarstellung:
n
zahl = å ai × b i
i =0
·
·
·
·
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)
Beispiel
100011101
435
285
11D
· Multiplikation/Division mit b: shift der Zahl-Ziffernfolge um 1 Stelle
nach links/rechts
Ganzzahldarstellung (2)
Ø Konvertierung zwischen zwei Basen:
n
zahl = å ai × b i = anb n + an -1b n -1 + K + a1b + a0
i =0
zahl = (L (an b + an -1 ) × b + K) × b + a0
(® Horner-Schema)
· Basis b ® Basis 10
* Eingabe: b, Feld a[0..k]
* Ausgabe: Dezimalzahl
* „vorwärts: von links nach rechts“
· Basis 10 ® Basis b
* Eingabe: Dezimalzahl, neue Basis b
* Ausgabe: Feld a[0..k] (neue Ziffernfolge)
* „rückwärts: von rechts nach links “
zahl := 0;
FOR i:=n TO 0 BY -1 DO;
zahl := zahl*b + a[i]
END;
i := 0;
a[i] := 0;
WHILE zahl>0 DO
a[i] := zahl MOD b;
zahl := zahl DIV b;
i
:= i+1
END;
Ganzzahldarstellung (3)
Ø Konvertierung zwischen zwei Basen: (cont‘d)
· Beispiel: (236)8 ® (?)3
* Schritt 1: (236)8 ® Dezimalzahl
n = 2:
(236)8 = ((0·8 + 2)·8 + 3 )·8 + 6 = 158 = (158)10
* Schritt 2: Dezimalzahl ® (?)3
b=3
(158)10 :
158 / 3 = 52
52 / 3 = 17
17 / 3 = 5
5/3 = 1
1/3 = 0
Rest
Rest
Rest
Rest
Rest
2
1
2
2
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 benachbarten 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:
(100101100) 2 = 1 × 28 + 0 × 27 + 0 × 26 + 1 × 25 + 0 × 2 4 + 1 × 23 + 1× 2 2 + 0 × 21 + 0 × 2 0
100 101 100 = (1 × 2 2 + 0 × 21 + 0 × 20 ) × 26 + (1× 2 2 + 0 × 21 + 1 × 20 ) × 23 + (1 × 2 2 + 0 × 21 + 0 × 2 0 ) × 2 0
100 101 100 = 4 × 8 2 + 5 × 81 + 4 × 80 = (454)8
Ø 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:
falls x < 0, dann:
x®x
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 1
es gibt zwei Nullen: +0 « 0000; -0 « 1000
also: Eine Zahl aber zwei unterscheidbare(!) Bitfolgen
* Problem 2
Bei dieser Darstellung ist ein Addierwerk und ein Subtrahierwerk
notwendig; es gibt keinen Algorithmus, der für diese Darstellung
Subtraktion per Addition erledigt
* Problem 3
Es ist eine Logik erforderlich zur Entscheidung, ob Addition oder
Subtraktion auszuführen ist (4 Vorzeichenfälle)
Negative Zahlen im Binärsystem (3)
Ø 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 noch
es gibt zwei Nullen: +0 « 0000; -0 « 1111
also: Eine Zahl aber zwei unterscheidbare(!) Bitfolgen
* 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 = -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 (4)
Ø 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 (5)
Ø 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)2
Zweier-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 kardinal 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 (6)
Ø 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)2
Ihr 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 negatives
Ergebnis, 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 (7)
Ø 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-KomplementDarstellung bis auf das invertierte linke Bit („Vorzeichen“) identisch
Negative Zahlen im Binärsystem (8)
Ø Vergleich der 4 Systeme (n=4)
Dual
Vorz./Betrag
Einer-Kompl.
Zweier-Kompl.
Exzess
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111
+0
+1
+2
+3
+4
+5
+6
+7
–0
–1
–2
–3
–4
–5
–6
–7
+0
+1
+2
+3
+4
+5
+6
+7
–7
–6
–5
–4
–3
–2
–1
–0
0
+1
+2
+3
+4
+5
+6
+7
–8
–7
–6
–5
–4
–3
–2
–1
–8
–7
–6
–5
–4
–3
–2
–1
0
+1
+2
+3
+4
+5
+6
+7
Negative Zahlen im Binärsystem (9)
Ø Zahlenring (n=8) für Dualzahlen und Zweier-Komplement
Gleitkommazahlen: Darstellung und Arithmetik
Gleitkommazahlen
Ø Zahlenmenge
b
· rationale Zahlen: r = a/b
1
r=a/b
1
a
Zahlenstrahl
· reelle Zahlen: Hinzunahme von nicht-rationalen Zahlen: p, e, Ö2
Die reellen Zahlen in ihrer mathematischen Bedeutung stellen ein
Kontinuum 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
Gleitkommazahlen (2)
Ø Zahlendarstellung (Konrad Zuse, 1937)
zahl = m × b e
0.1 = 1/10 = 1/b ist kleinstmöglicher Mantissenbetrag!
Warum?
Der nächstkleinere Zahlenbetrag wäre: 0.099 • 10-99
wegen normierter Darstellung:
0.099 • 10-99 ® 0.99 • 10-100
Das ist unmöglich wegen zweiziffrigem 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
Gleitkommazahlen (3)
Die Mantisse ist somit um 1Bit
länger als gedacht, weil a1 nicht
gespeichert 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
15
Vorzeichen
8 7
Exponent
0
Mantisse
· 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)
12 13
15 16
0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 1
Vorzeichen
Exponent
* Vorzeichen:
* Exponent e:
* Mantisse m:
Mantisse
0, also +
Breite: 7 Bit
Exzess 64(=27-1) - Darstellung
(1010100)2 = (84)10 ® 84 - 64 = 20
be = 2 20 = 1048576
Breite: 16 Bit
Darstellung der Mantisse:
16
m = å a j × 2 - j = 1× 2 -12 + 1 × 2 -13 + 1× 2 -15 + 1 × 2 -16
j =1
= (1 × 2 +4 + 1× 2 +3 + 1× 2 +1 + 1 × 20 ) × 2 -16
= 27 × 2 -16
* Zahl:
zahl = + 27 • 2-16 • 220 = + 432
Gleitkommazahlen (5)
Ø Beispiel (cont‘d)
· Normalisierung:
zahl = 2 20 × (1 × 2 -12 + 1× 2 -13 + 0 × 2 -14 + 1 × 2 -15 + 1 × 2 -16 )
= 2 20 × (2 -11 × (1× 2 -1 + 1 × 2 -2 + 0 × 2 -3 + 1 × 2 -4 + 1 × 2 -5 )
= 29 × (1× 2 -1 + 1× 2 -2 + 0 × 2 -3 + 1 × 2 -4 + 1 × 2 -5 )
* Vorzeichen:
* Exponent e:
* Mantisse m:
bleibt 0, also +
Breite: 7 Bit
Exzess 64(=27-1) - Darstellung
9 + 64 = 73 ® (73)10 = (1001001)2
Exponent e um 11 dekrementiert
Breite: 16 Bit
Mantisse um 11 Bit nach links geschoben
0 1 0 0 1 0 0 1 1 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0
Vorzeichen
Exponent
* Zahl bleibt erhalten:
Mantisse
zahl = + 27 • 2-5 • 29 = + 432
Gleitkommazahlen (6)
Ø REAL-Zahlen auf dem Zahlenstrahl
· Beispiel: b = 10, Mantisse m: 3 Ziffern, Exponent e: 2 Ziffern
NULL
-0.999 • 1099
ausdrückbare
negative Zahlen
negative
overflow
-10100
negative
underflow
- 0.100 • 10-99
-0.999 • 1099
positive
underflow
0
+0.100 • 10-99
ausdrückbare
positive Zahlen
positive
overflow
+10100
· 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.910
x + (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.000
x • (y+z) = 1100. • 0.001
= 1.100
· Auslöschung
Bei 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)
Ø Rechnerarithmetik
x = mx × 2 ex ,
y = my × 2
· Addition
ex -e y
+ my ) × 2
ex -e y
- my ) × 2
x + y = ( mx × 2
· Subtraktion
x - y = (mx × 2
· Multiplikation
x × y = (mx × m y ) × 2
· Division
ey
ex + e y
x ¸ y = ( mx ¸ m y ) × 2
ex -e y
ey
falls ex £ e y
ey
falls ex £ e y