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)(