Präzisierung der Daten •

Präzisierung der Daten

•

allgemeine Prinzipien, um Gegenstände durch Datentypen zu modellieren, die maschinell verarbeitet werden können 1. Möglichkeit: “Datenbrei” hinnehmen 2. Möglichkeit: Daten strukturieren, zu

Klassen zusammenfassen

Präzisierung der Daten

Grundbegriffe

•

Strukturierungskriterium: Operationen mit Datentypen

•gleiche oder ähnliche Operationen → gleiche Klasse (Datentyp)

•

Typisierung

•erleichtert Manipulation von Daten

•macht Programme sicherer und nachvollziehbarer.

•ermöglicht automatische Überprüfung durch Übersetzer

Präzisierung der Daten

Definition Datentyp

Definition:

Ein Datentyp, kurz Typ, D ist ein Paar D=

(W,R) bestehend aus einer Wertemenge W und einer Menge R von Operationen, die auf W definiert sind.

Ein elementarer Datentyp ist ein

Datentyp, dessen Wertemenge nicht weiter in Datentypen zerlegt werden kann.

Präzisierung der Daten

Notationen

•

IN, Z und IR

•

A={'a',...'z','A',...,'Z','0',...,'9',',',':','◊'...} Menge der Zeichen

•

IB={true,false} Menge der Wahrheitswerte.

•

elementare Datentypen:

•

(A,{...}) =: char

•

(A*,{•,...}) =: text

•

(IN,{+,-,*,div,mod,=,≠,>,...}) =: nat

•

(Z,{+,-,*,div,mod,=,≠,...}) =: int

•

(IR,{+,-,*,/,=,≠,...}) =: real

•

(IB,{and,or,not}) =: bool

•

Notation: Häufig unterscheiden wir nicht zwischen

Datentyp D=(W,R) und Wertemenge W, z.B. steht int auch schon mal für Z. Und statt x W schreiben wir auch x D.

Leerzeichen

Präzisierung der Daten

Datentypbaukasten

Präzisierung der Daten

Datentypbaukasten

•

Δ Klasse aller Datentypen, Δ_e Klasse elementarer

Datentypen

•

Für i=1,...,n sei

Ki: Δ×...×Δ→Δ

ein Konstruktor, der eine gewisse Anzahl von

Datentypen als Argument benötigt und einen neuen Datentyp erzeugt.

•

Dann ist für K={K1,...,Kn}

B=(Δe,K) ein Datentyp-Baukasten.

Präzisierung der Daten

Standardbaukasten der Informatik

•

^B0=(Δ0,K0):

•

^Δ0={nat,int,real,char,text,bool}

•

^K0={Enumeration, Restriktion,

Aggregation, Generalisation, Rekursion, Potenzmengenbildung, Bildung von

Funktionenräumen}

•

so oder ähnlich in praktisch allen Programmiersprachen integriert

Präzisierung der Daten

Standardbaukasten der Informatik

•

Enumeration: Bildung eines elementaren Datentyps durch Aufzählung aller seiner Elemente

•

Restriktion: Bildung einer Teilmenge eines Datentyps

•

Aggregation: gleichrangiges Zusammensetzen mehrerer Datentypen zu einem einzigen (kartesisches Produkt)

•

Generalisation: Vereinigung von disjunkten Datentypen

•

Rekursion: Übergang zu Datentyp mit abzählbar

unendlich vielen Elementen, gleichartig aus einfacheren Elementen desselben Typs aufgebaut

•

Potenzmengenbildung: Bildung der Menge aller (endlichen) Teilmengen eines Datentyps

•

Bildung von Funktionenräumen: Übergang zu Funktionen zwischen Datentypen

Präzisierung der Daten

Konstruktor - Selektor

•

Konstruktor: Zusammenbau von Datentypen

•

Destruktor/Selektor: Wiederaufspüren von Daten im Konstrukt

•

zu jedem Konstruktor wird ein Selektor implizit mitdefiniert

•

Beispiel: PRO: Konstruktor [ ], z.B.

2, 7, 1 → [2,7,1]

Operationen erstes und rest selektieren, z.B.

7 = erstes(rest ([2,7,1]))

Präzisierung der Daten

Standarddatentypen

•

in Programmiersprachen vordefiniert: int, nat, real, char, bool und text

•

Wertemenge M meist endlich mit linearer Ordnung <, also:

M={m1,m2,m3,...,mn} mit m1<m2<m3<...<mn

•

skalare Datentypen

Präzisierung der Daten

Notation von Funktionen

•

Bezeichnungen: Funktion f: X×Y→Z

“Operation”: Infixnotation xfy, z.B. x+y

“Funktion”: Präfixnotation fxy, f(x,y), z.B. sin(x)

Postfixnotation: xyf, z.B. Fakultät x!

•

Beispiel: (x+2)*(y-z) Präfix: *+x2-yz

Postfix: x2+yz-*

Präzisierung der Daten

Notation von Funktionen

•

Bezeichnungen: Funktion f: X×Y→Z

“Operation”: Infixnotation xfy, z.B. x+y

“Funktion”: Präfixnotation fxy, f(x,y), z.B. sin(x)

Postfixnotation: xyf, z.B. Fakultät x!

•

Beispiel: (x+2)*(y-z) Präfix: *+x2-yz

Postfix: x2+yz-*

Präfix und Postfix klammerfrei !

Präzisierung der Daten

Standardfunktionen

•

auf allen skalaren Datentypen M (Ausnahme:

real):

predecessor pred: M→M partielle Abbildung mi-1, falls i≥2,

pred(mi)=

, falls i=1

successor succ: M→M partielle Abbildung mi+1, falls i≥2,

succ(mi)=

, falls i=n

{

{

Präzisierung der Daten

Standardfunktionen

•

Ordinalfunktion ord: M→IN mit ord(mi)=i

•

weitere Operationen: Vergleichsoperationen

Präzisierung der Daten

elementarer Typ - bool

•

Wertemenge: zwei Elemente false (dt.

falsch) und true (dt. wahr):

false < true

•

pred(true)=false, succ(false)=true, ord(false)

=1 und ord(true)=2

•

false und true heißen auch Boolesche Werte oder Wahrheitswerte

•

Operationen and und or (2-stellig), not (1- stellig)

Präzisierung der Daten

elementarer Typ - bool

x y x and y x or y not x

false false false false true

false true false true true

true false false true false

true true true true false

Präzisierung der Daten

elementarer Typ - bool

x y x and y x or y not x

false false false false true

false true false true true

true false false true false

true true true true false

true dann und nur dann, wenn x=true und y=true

Präzisierung der Daten

elementarer Typ - bool

x y x and y x or y not x

false false false false true

false true false true true

true false false true false

true true true true false

true dann und nur dann, wenn x=true oder y=true

Präzisierung der Daten

elementarer Typ - bool

x y x and y x or y not x

false false false false true

false true false true true

true false false true false

true true true true false

true dann und nur dann, wenn nicht x=true

Präzisierung der Daten

elementarer Typ - bool

•

Vergleichsoperationen D×D→bool:

<, ≤, ≥, >, =, ≠

•

^Beispiele:

•

12≠3 → true,

•

12≠12 → false,

•

3≤2 → false,

•

false<true → true,

•

true<false → false.

Präzisierung der Daten

elementarer Typ - int

•

Wertemenge: endliche Teilmenge der ganzen Zahlen in Form eines symmetrischen Intervalls um den Nullpunkt, d.h.

M={x Z | -maxint ≤ x ≤ maxint}

•

maxint computer- und sprachabhängig:

•

Kleincomputer: 2¹⁵-1=32767

•

Großcomputer: 2³¹-1=2.147.483.647

•

Konstanten: übliche Dezimaldarstellung als Folge von Ziffern mit oder ohne Vorzeichen + oder -

Präzisierung der Daten

elementarer Typ - int

•

Standardoperationen: +, -, *, div (ganzzahlige Division ohne Rest), mod (Restbildung bei ganzzahliger Division)

•

^Beispiele:

•

7 div 2=3, 7 mod 2=1

•

14 div 3=4, 14 mod 3=2,

•

-14 div 3=-4, -14 mod 3=-2

•

Wertebereichsüberschreitung: Fehler

Präzisierung der Daten

elementarer Typ - int

Vorsicht: Rechengesetze nicht mehr gültig:

Beispiel: maxint=100

(60+50)-30 → Fehler: Überlauf (Overflow) 60+(50-30)=80

Assoziativgesetz verletzt

Präzisierung der Daten

elementarer Typ - nat

•

Wertemenge 0..maxint

•

Eigenschaften und Operationen von int übertragen sich

Präzisierung der Daten

elementarer Typ - real

•

Wertemenge: eigentlich alle reellen Zahlen

•

Endlichkeit des Rechners: Einschränkung auf Zahlen in sog. Gleitpunktdarstellung näherungsweise Darstellung von reellen Zahlen in halblogarithmischer Form

Präzisierung der Daten

Gleitpunktdarstellung

•

Sei z IR positiv reell

•

z kann man in der Form schreiben:

z=m^.b^e, b IN, e Z, b≥2, 1/b≤m<1.

•

negative reelle Zahlen: Minuszeichen.

•

z=0: setze m=0

•

1/b≤m<1 (Normalisierung): Darstellung eindeutig

•

b Basis. In der Praxis: b=2, 10 oder 16

•

e Exponent: Größenordnung der Zahl

•

m Mantisse: Zahlenwert (Folge der gültigen Ziffern)

Präzisierung der Daten

Gleitpunktdarstellung

•

Sei z IR positiv reell

•

z kann man in der Form schreiben:

z=m^.b^e, b IN, e Z, b≥2, 1/b≤m<1.

•

negative reelle Zahlen: Minuszeichen.

•

z=0: setze m=0

•

1/b≤m<1 (Normalisierung): Darstellung eindeutig

•

b Basis. In der Praxis: b=2, 10 oder 16

•

e Exponent: Größenordnung der Zahl

•

m Mantisse: Zahlenwert (Folge der gültigen Ziffern)

1. Stelle nach dem Komma ≠0

Präzisierung der Daten

Gleitpunktdarstellung

•

Sei z IR positiv reell

•

z kann man in der Form schreiben:

z=m^.b^e, b IN, e Z, b≥2, 1/b≤m<1.

•

negative reelle Zahlen: Minuszeichen.

•

z=0: setze m=0

•

1/b≤m<1 (Normalisierung): Darstellung eindeutig

•

b Basis. In der Praxis: b=2, 10 oder 16

•

e Exponent: Größenordnung der Zahl

•

m Mantisse: Zahlenwert (Folge der gültigen Ziffern)

Präzisierung der Daten

Gleitpunktdarstellung - Beispiele

•

Normalisierte Gleitpunktdarstellungen zur Basis 10:

•

189,217 = 0.189217^.10³

•

-2,4 = -0.24^.10¹

•

-0,0013 = -0.13^.10^-2

Präzisierung der Daten

Gleitpunktdarstellung - Beispiele

•

Normalisierte Gleitpunktdarstellungen zur Basis 10:

•

189,217 = 0.189217^.10³

•

-2,4 = -0.24^.10¹

•

-0,0013 = -0.13^.10^-2

1. Stelle nach dem Komma ≠0,

1/10≤m<1

Präzisierung der Daten

Gleitpunktdarstellung - Effekte

•

Mantisse, Exponent endlich

•

nur endliche Menge von reellen Zahlen darstellbar

•

jede darstellbare Zahl ist rationale Zahl, sogar endliche Dezimalzahl (falls b=10)

•

Rechenregeln außer Kraft

Präzisierung der Daten

Gleitpunktdarstellung - Effekte

•

Beispiel: Mantisse 4, Exponent 2 Stellen; Basis 10.

•

2000+0.7-2000 auf zwei Arten:

(2000+0.7)-2000 = (0.2000^.10⁴+0.7000^.10⁰)-0.2000^.10⁴ = (0.2000^.10⁴+0.0000^.10⁴)-0.2000^.10⁴ = 0

(2000-2000)+0.7 = (0.2000^.10⁴-0.2000^.10⁴)+0.7000^.10⁰ = 0.0000^.10⁰+0.7000^.10⁰ = 0.7000^.10⁰ = 0.7

•

Addition und Subtraktion zweier real-Zahlen nur, wenn beide gleichen Exponenten haben;

Exponentenangleichung Auslöschung kleinerer Zahlen (Rundungsfehler).

Präzisierung der Daten

Gleitpunktdarstellung - Konstanten

•

Dezimaldarstellung als Folge von Ziffern mit oder ohne Dezimalpunkt, gefolgt vom

Exponententeil, eingeleitet durch Buchstabe E.

•

Beispiele: Konstanten vom Typ real sind:

-1, 2.5, 3.7E4, -0.2E-2, 0.0072E+2.

Präzisierung der Daten

Gleitpunktdarstellung - Konstanten

•

Dezimaldarstellung als Folge von Ziffern mit oder ohne Dezimalpunkt, gefolgt vom

Exponententeil, eingeleitet durch Buchstabe E.

•

Beispiele: Konstanten vom Typ real sind:

-1, 2.5, 3.7E4, -0.2E-2, 0.0072E+2.

3.7^.10⁴ 37000

Präzisierung der Daten

Gleitpunktdarstellung - Konstanten

•

Dezimaldarstellung als Folge von Ziffern mit oder ohne Dezimalpunkt, gefolgt vom

Exponententeil, eingeleitet durch Buchstabe E.

•

Beispiele: Konstanten vom Typ real sind:

-1, 2.5, 3.7E4, -0.2E-2, 0.0072E+2.

Präzisierung der Daten

Gleitpunktdarstellung - Konstanten

•

Dezimaldarstellung als Folge von Ziffern mit oder ohne Dezimalpunkt, gefolgt vom

Exponententeil, eingeleitet durch Buchstabe E.

•

Beispiele: Konstanten vom Typ real sind:

-1, 2.5, 3.7E4, -0.2E-2, 0.0072E+2.

-0.2^.10^-2 -0.002

Präzisierung der Daten

Gleitpunktdarstellung - Konstanten

•

Dezimaldarstellung als Folge von Ziffern mit oder ohne Dezimalpunkt, gefolgt vom

Exponententeil, eingeleitet durch Buchstabe E.

•

Beispiele: Konstanten vom Typ real sind:

-1, 2.5, 3.7E4, -0.2E-2, 0.0072E+2.

Präzisierung der Daten

Gleitpunktdarstellung - Konstanten

•

Dezimaldarstellung als Folge von Ziffern mit oder ohne Dezimalpunkt, gefolgt vom

Exponententeil, eingeleitet durch Buchstabe E.

•

Beispiele: Konstanten vom Typ real sind:

-1, 2.5, 3.7E4, -0.2E-2, 0.0072E+2.

0.0072^.10² 0.72

Präzisierung der Daten

Gleitpunktdarstellung - Operationen

•

arithmetischen Operationen +, -, * und /

•

Vergleichsoperationen

•

Standardfunktionen:

•

^abs(x) (Absolutbetrag)

•

^{sqr(x) (Quadrat)}

•

^sin(x) (Sinus) ... (s. Skript)

•

abs und sqr liefern int-Werte, wenn die Argumente vom Typ int sind

Präzisierung der Daten

Gleitpunktdarstellung - Operationen

•

arithmetischen Operationen +, -, * und /

•

Vergleichsoperationen

•

Standardfunktionen:

•

^abs(x) (Absolutbetrag)

•

^{sqr(x) (Quadrat)}

•

^sin(x) (Sinus) ... (s. Skript)

•

abs und sqr liefern int-Werte, wenn die Argumente vom Typ int sind

Sollen ganze und

Dezimalzahlen verknüpft werden, muß man

Typkonversionen einsetzen

Präzisierung der Daten

char und text

•

char: Wertebereich: alle darstellbaren Zeichen des Zeichensatzes einer Programmiersprache incl.

Steuerzeichen

•

text: Wertebereich char*, meist beschränkt auf vorgegebene feste Länge (meist 2⁸ oder 2¹⁶)

•

Konstanten: Hochkommata (bei char) oder Anführungszeichen (bei text)

•

Hochkomma (Anführungszeichen) selbst: verdoppeln

•

Konstanten vom Typ char: 'a', '9', 'B', '?', ' ', ''''

•

Konstanten vom Typ text sind: "Auto", "9", "Wer ist da?", "Er sagte: ""Hier bin ich""".

Präzisierung der Daten

char und text - Operationen

•

pred, succ, ord, Vergleiche lexikographische Ordnung:

"Auto"<"Autobahn"

•

chr: int→char mit chr(i)=c falls ord(c)=i.

•

Beispiel: ord('A')=65 chr(65)='A'

•

stets chr(ord(c))=c und ord(chr(i))=i

•

Konkatenation • zweier Texte:

"Baum"•"Haus"="BaumHaus".

Präzisierung der Daten

char und text - Operationen

•

pred, succ, ord, Vergleiche lexikographische Ordnung:

"Auto"<"Autobahn"

•

chr: int→char mit chr(i)=c falls ord(c)=i.

•

Beispiel: ord('A')=65 chr(65)='A'

•

stets chr(ord(c))=c und ord(chr(i))=i

•

Konkatenation • zweier Texte:

"Baum"•"Haus"="BaumHaus".

Wert der ord-Funktion richtet sich nach interner Verschlüsselung der Zeichen:

üblich ASCII-Code

Präzisierung der Daten

char und text - Operationen

•

pred, succ, ord, Vergleiche lexikographische Ordnung:

"Auto"<"Autobahn"

•

chr: int→char mit chr(i)=c falls ord(c)=i.

•

Beispiel: ord('A')=65 chr(65)='A'

•

stets chr(ord(c))=c und ord(chr(i))=i

•

Konkatenation • zweier Texte:

"Baum"•"Haus"="BaumHaus".

Präzisierung der Daten

Probleme der Typisierung

Motivation:

•

100 real, 100 int

•

aber: 100 kann Gasverbrauch Stromverbrauch

Nummer eines IC-Zugs

Teil eines Autokennzeichens sein

Präzisierung der Daten

Probleme der Typisierung

Motivation:

•

100 real, 100 int

•

aber: 100 kann Gasverbrauch Stromverbrauch

Nummer eines IC-Zugs

Teil eines Autokennzeichens sein

Addition von Gasverbräuchen

Präzisierung der Daten

Probleme der Typisierung

Motivation:

•

100 real, 100 int

•

aber: 100 kann Gasverbrauch Stromverbrauch

Nummer eines IC-Zugs

Teil eines Autokennzeichens sein

Präzisierung der Daten

Probleme der Typisierung

Motivation:

•

100 real, 100 int

•

aber: 100 kann Gasverbrauch Stromverbrauch

Nummer eines IC-Zugs

Teil eines Autokennzeichens sein

Addition von Stromverbräuchen

Präzisierung der Daten

Probleme der Typisierung

Motivation:

•

100 real, 100 int

•

aber: 100 kann Gasverbrauch Stromverbrauch

Nummer eines IC-Zugs

Teil eines Autokennzeichens sein

Präzisierung der Daten

Probleme der Typisierung

Motivation:

•

100 real, 100 int

•

aber: 100 kann Gasverbrauch Stromverbrauch

Nummer eines IC-Zugs

Teil eines Autokennzeichens sein

Liefere Gegenzug

Präzisierung der Daten

Probleme der Typisierung

Motivation:

•

100 real, 100 int

•

aber: 100 kann Gasverbrauch Stromverbrauch

Nummer eines IC-Zugs

Teil eines Autokennzeichens sein

Präzisierung der Daten

Probleme der Typisierung

Motivation:

•

100 real, 100 int

•

aber: 100 kann Gasverbrauch Stromverbrauch

Nummer eines IC-Zugs

Teil eines Autokennzeichens sein

Liefere nächste freie Nummer

Präzisierung der Daten

Probleme der Typisierung

Motivation:

•

100 real, 100 int

•

aber: 100 kann Gasverbrauch Stromverbrauch

Nummer eines IC-Zugs

Teil eines Autokennzeichens sein

Präzisierung der Daten

Probleme der Typisierung

Motivation:

•

100 real, 100 int

•

aber: 100 kann Gasverbrauch Stromverbrauch

Nummer eines IC-Zugs

Teil eines Autokennzeichens sein

Objekte gleicher Gestalt können zu unterschiedl.

Typen gehören und mit unterschiedl. Operationen bearbeitet werden.

Präzisierung der Daten

Probleme der Typisierung

•

Maschine soll jeweils entscheiden, ob die angewendeten Operationen erlaubt sind oder nicht und ggf. mit Fehlermeldung abbrechen

•

zwei zueinander konträre Verfahren

•

strenge Typisierung: “erlaubt ist, was darf”

•

schwache Typisierung: “erlaubt ist, was geht”

Präzisierung der Daten

strenge u. schwache Typisierung

Definition:

Eine Programmiersprache heißt streng typisiert, wenn in jedem Programm der

Sprache alle Größen zu genau einem Datentyp gehören, andernfalls schwach typisiert.

Präzisierung der Daten

strenge u. schwache Typisierung

•

streng typisiert: Wertemengen aller Datentypen paarweise disjunkt

•

Ausnahme: Typen, die durch gewisse Konstruktoren (vor allem Restriktion, s.u.) aus einem anderen Typ hervorgegangen sind

•

strenge Typisierung erhöht bei Software-

Entwicklung i.a. die Sicherheit, da Typverletzungen durch Übersetzer erkannt und entsprechende Programme vom System abgewiesen werden

•

Erhöhung der Portabilität, da kein Bezug auf rechnerinterne Darstellungen

Präzisierung der Daten

Typisierung - Beispiel

•

strenge Typisierung:

sin(7), da sin: real→real

x+true, da die Addition int×int→int oder real×real→real; bei schwacher Typisierung erlaubt, wenn + möglich

17*12.5, da Multiplikation int×int→int oder real×real→real (Typkonversion)

Präzisierung der Daten

Typkonversionen - Casting

• ^17*12.5

makeint: real→int

17*makeint(12.5) makereal: int → real

makereal(17)*12.5

• Einige Programmiersprachen enthalten

automatische Typkonversionen

Präzisierung der Daten

statische/dynamische Typisierung

Definition:

Eine Programmiersprache heißt statisch typisiert, falls alle oder die meisten

Typüberprüfungen zur Übersetzungszeit durchgeführt werden können.

Werden die Typprüfungen während der Laufzeit des Programms durchgeführt, so spricht man von dynamischer Typisierung.

Hier immer: strenge, statische Typisierung

Präzisierung der Daten

Konstruktoren

•

^Erinnerung

Datentypbaukasten B0=(Δ0,K0):

•

^Δ0={nat,int,real,char,text,bool}

•

^K0={Enumeration, Restriktion,

Aggregation, Generalisation, Rekursion, Potenzmengenbildung, Bildung von

Funktionenräumen}

Präzisierung der Daten

Konstruktoren

•

^Erinnerung

Datentypbaukasten B0=(Δ0,K0):

•

^Δ0={nat,int,real,char,text,bool}

•

^K0={Enumeration, Restriktion,

Aggregation, Generalisation, Rekursion, Potenzmengenbildung, Bildung von

Funktionenräumen}

✓

Präzisierung der Daten

Enumeration

•

Einführung neuer elementarer Datentypen als

endliche linear geordnete Mengen durch Aufzählung der zugehörigen Elemente (Aufzählungstyp)

•

^Schema:

typ D {d1,d2,...,dn}.

•

lineare Ordnung: d1<d2<...<dn (skalarer Datentyp)

•

Operationen: pred, succ, Vergleiche

•

^Beispiel:

•

typ farbe {rot, grün, blau}

•

rot<grün<blau

•

succ(rot)=grün, succ(succ(rot))=blau, pred(grün)

=rot

Präzisierung der Daten

Enumeration - Typisierungsprobleme

•

strenge Typisierung: D neuer Typ D disjunkt von allen übrigen Typen

•

^di aus D' beide Elemente verschieden

•

^{Da man di} nicht ansehen kann, aus welchem

Datentyp es stammt, fordert man, daß die Elemente eines Aufzählungstyps verschieden von allen

übrigen Datentypen gewählt werden

•

typ D {'x', 2.0, Otto, false} meist nicht zulässig, weil real-, bool- und char-Elemente enthalten

Präzisierung der Daten

Restriktion

•

Übergang zu (endlichen oder unendlichen) Teilmengen eines bereits definierten Datentyps

•

Allgemeinster Fall

Prädikat P: M→{true, false}

Schema: typ D' D {x | P(x)}

D': Menge aller x vom Typ D, die P erfüllen

•

Sonderfall: P=true ( Umbenennung) typ Zahl int {x | true}

•

D' kein neuer Typ (trotz strenger Typisierung): Operationen übertragen sich, sofern Wertemenge nicht verlassen wird

•

Beispiel: typ D' int {x | x mod 2=0} (gerade Zahlen)

Präzisierung der Daten

Restriktion

•

Restriktion in voller Allgemeinheit meist nicht zugelassen

•

Übliche Einschränkungen:

•

Restriktion durch Intervallbildung, falls D skalar:

zusammenhängendes Intervall D'={x | a≤x≤b}

typ D' D [a ..b]

•

Beispiel: typ Lottozahlen int [1..49]

•

Restriktion durch Enumeration: Aufzählung der Elemente

typ D' D {d1,d2,...,dn}

•

Beispiel: typ LottoHeute Lottozahlen {2,7,13,17,22,49}.

Präzisierung der Daten

Potenzmengenbildung

schematisch:

typ D 2^D'. Beispiele:

1) typ zahlen 2^int.

Wertemenge: Menge aller Teilmengen von int.

2) typ grundfarbe {rot,gelb,blau}

typ farben 2^grundfarbe.

{rot,gelb}, {gelb}, {rot,blau,gelb}, farben

Wertemenge: “Mischfarben” aus rot, gelb, blau.

Präzisierung der Daten

Potenzmengenbildung

•

Universelle Konstante: .

•

Mengenoperationen:

•

^{: D×D→D}(Vereinigung)

•

^{: D×D→D}(Durchschnitt)

•

^{\: D×D→D} (Differenz)

•

| . |: D→IN (Kardinalität),

•

: D×D→{true, false}(Teilmenge)

•

: D'×D→{true, false}(Element-Beziehung)

•

In Programmiersprachen oft nur endliche Grundmengen zulässig.

Präzisierung der Daten

Aggregation

•

Tupelbildung, kartesisches Produkt

•

schematisch

typ D (D1,D2,...,Dn).

•

^D1,...,Dn Komponenten von D

•

Elemente (d1,d2,...,dn) n-Tupel mit di Di

•

^D1=D2=...=Dn: homogene Aggregation, anderenfalls inhomogen

•

^Beispiel:

typ Datum (int [1..31], int [1..12], int [1900..1999]) d=(17,10,1989) Datum

Präzisierung der Daten

Aggregation

•

Tupelbildung, kartesisches Produkt

•

schematisch

typ D (D1,D2,...,Dn).

•

^D1,...,Dn Komponenten von D

•

Elemente (d1,d2,...,dn) n-Tupel mit di Di

•

^D1=D2=...=Dn: homogene Aggregation, anderenfalls inhomogen

•

^Beispiel:

typ Datum (int [1..31], int [1..12], int [1900..1999]) d=(17,10,1989) Datum

Präzisierung der Daten

Aggregation

•

Tupelbildung, kartesisches Produkt

•

schematisch

typ D (D1,D2,...,Dn).

•

^D1,...,Dn Komponenten von D

•

Elemente (d1,d2,...,dn) n-Tupel mit di Di

•

^D1=D2=...=Dn: homogene Aggregation, anderenfalls inhomogen

•

^Beispiel:

typ Datum (int [1..31], int [1..12], int [1900..1999]) d=(17,10,1989) Datum

Präzisierung der Daten

Aggregation - Selektoren

•

gegeben: D (D1,D2,...,Dn). Selektor:

πi,n: D→Di mit πi,n(d) = di

•

mathematisch: πi,n Projektion von d auf i-te Komponente.

•

^Axiome:

•

Konstruktionsaxiom

(π1,n(d),π2,n(d),...,πn,n(d))=d für alle d D

•

Selektionsaxiom

•

^{πi,n(d1,d2,...,dn)=di} für alle di Di, i=1,...,n.

Präzisierung der Daten

Aggregation - iterierte Selektoren

•

Bei aggregierten Typen als Komponenten

iterierte Selektion: Komposition von Selektoren πi ,n ° ... ° πi ,n ° πi ,n

•

Beispiel: Schulzeit mit Einschulungs- und Abgangsdatum

typ Schulzeit (Datum,Datum).

•

Abgangstag: doppelte Selektion π1,3 ° π2,2.

•

für d=((17,8,1960),(22,4,1976)) Schulzeit:

π1,3(π2,2(d))=π1,3(22,4,1976)=22.

1 1 2

2 k k

Präzisierung der Daten

Aggregation - parallele Selektion

•

parallele Selektion: gleichzeitige Anwendung mehrerer Selektoren auf das gleiche Element

(πi ,n, πi ,n, ..., πi ,n)(d)= (di , di , ..., di ).

•

Anwendung: Durchlaufen aller Komponenten d1,d2,d3,... eines Objektes d D.

Nötig: Nachfolgerfunktion N auf der Menge der Selektoren, also

N: {πi,n | n IN, 1≤i≤n}→{πi,n | n IN, 1≤i≤n} mit N(πi,n) = πi+1,n für 1≤i<n.

1 2 k 1 2 k

Präzisierung der Daten

Aggregation - parallele Selektion

•

Beispiel: Drucken aller Komponenten des Objektes d vom Typ D:

π←π1,n;

solange π definiert tue zeige(π(d));

π←N(π) ende

•

In üblichen Programmiersprachen steht N nicht zur Verfügung

Präzisierung der Daten

Aggregation - Verbund/Record

•

Verbund/Record: Zugriff auf

Komponenten über Bezeichner statt über Projektionen

•

schematisch:

typ T (t1 : T1, t2 : T2, ..., tn : Tn).

•

Wertemenge: Menge aller n-Tupel (a1,...,an) mit ai vom Datentyp Ti und ansprechbar

über Bezeichner ti.

Präzisierung der Daten

Aggregation - Verbund/Record

•

Verbund/Record: Zugriff auf

Komponenten über Bezeichner statt über Projektionen

•

schematisch:

typ T (t1 : T1, t2 : T2, ..., tn : Tn).

•

Wertemenge: Menge aller n-Tupel (a1,...,an) mit ai vom Datentyp Ti und ansprechbar

über Bezeichner ti.

t1,...,tn paarweise

verschiedene (!) Bezeichner (Selektoren)

Präzisierung der Daten

Aggregation - Verbund/Record

•

Verbund/Record: Zugriff auf

Komponenten über Bezeichner statt über Projektionen

•

schematisch:

typ T (t1 : T1, t2 : T2, ..., tn : Tn).

•

Wertemenge: Menge aller n-Tupel (a1,...,an) mit ai vom Datentyp Ti und ansprechbar

über Bezeichner ti.

Präzisierung der Daten

Aggregation - Verbund/Record

•

Verbund/Record: Zugriff auf

Komponenten über Bezeichner statt über Projektionen

•

schematisch:

typ T (t1 : T1, t2 : T2, ..., tn : Tn).

•

Wertemenge: Menge aller n-Tupel (a1,...,an) mit ai vom Datentyp Ti und ansprechbar

über Bezeichner ti.

T1,...,Tn bel.

Datentypen

Präzisierung der Daten

Aggregation - Verbund/Record

•

Verbund/Record: Zugriff auf

Komponenten über Bezeichner statt über Projektionen

•

schematisch:

typ T (t1 : T1, t2 : T2, ..., tn : Tn).

•

Wertemenge: Menge aller n-Tupel (a1,...,an) mit ai vom Datentyp Ti und ansprechbar

über Bezeichner ti.

Präzisierung der Daten

Aggregation - Verbund/Record

•

Beispiel: Personaldaten:

typ personal (name : text, gebdat : (nat[1..31], nat[1..12], nat), gehalt : real, geschlecht: {m,w}).

•

Erweiterung: Definiere

gebdat : (tag: nat[1..31], monat: nat[1..12], jahr: nat)

•

Einfügen in Typ personal:

typ personal (name : text, gebdat : (tag: nat

[1..31], monat: nat[1..12], jahr: nat), gehalt : real;

geschlecht: {m,w}).

Präzisierung der Daten

Aggregation - Verbund/Record

•

Selektion: dot-Notation: Gegeben Variable v und Verbundtyp T wie oben:

v.ti

i-te Komponente des Verbunds.

•

v meist nur einzelner Bezeichner aber kein Ausdruck.

•

^ti kann wiederum dot-Ausdruck sein

Präzisierung der Daten

Aggregation - Verbund/Record

•

Beispiel: Betrachte personal. Erzeugung eines Angestellten angest und Belegung mit Werten:

def angest: personal;

angest.name ← "MEIER";

angest.gebdat.tag ← 14;

angest.gebdat.monat ← 3;

angest.gebdat.jahr ← 1936;

angest.gehalt ← 2783.24;

angest.geschlecht ← w;

angest.gehalt ← angest.gehalt + 200.

Präzisierung der Daten

Aggregation - Verbund/Record

•

Vereinfachung: inspect ... tue ... (“Öffnen” eines Verbunds)

angest.name ← "MEIER";

angest.gebdat.tag ← 14;

angest.gebdat.monat ← 3;

angest.gebdat.jahr ← 1936;

angest.gehalt ← 2783.24;

angest.geschlecht ← w;

angest.gehalt ← angest.gehalt + 200.

Präzisierung der Daten

Aggregation - Verbund/Record

•

Vereinfachung: inspect ... tue ... (“Öffnen” eines Verbunds)

angest.name ← "MEIER";

angest.gebdat.tag ← 14;

angest.gebdat.monat ← 3;

angest.gebdat.jahr ← 1936;

angest.gehalt ← 2783.24;

angest.geschlecht ← w;

angest.gehalt ← angest.gehalt + 200.

inspect angest tue

ende

Präzisierung der Daten

Aggregation - Verbund/Record

•

Vereinfachung: inspect ... tue ... (“Öffnen” eines Verbunds)

angest.name ← "MEIER";

angest.gebdat.tag ← 14;

angest.gebdat.monat ← 3;

angest.gebdat.jahr ← 1936;

angest.gehalt ← 2783.24;

angest.geschlecht ← w;

angest.gehalt ← angest.gehalt + 200.

inspect angest tue

ende

Präzisierung der Daten

Aggregation - Verbund/Record

•

Vereinfachung: inspect ... tue ... (“Öffnen” eines Verbunds)

angest.name ← "MEIER";

angest.gebdat.tag ← 14;

angest.gebdat.monat ← 3;

angest.gebdat.jahr ← 1936;

angest.gehalt ← 2783.24;

angest.geschlecht ← w;

angest.gehalt ← angest.gehalt + 200.

inspect angest tue

ende

inspect gebdat tue

ende

Präzisierung der Daten

Aggregation - Verbund/Record

•

Vereinfachung: inspect ... tue ... (“Öffnen” eines Verbunds)

angest.name ← "MEIER";

angest.gebdat.tag ← 14;

angest.gebdat.monat ← 3;

angest.gebdat.jahr ← 1936;

angest.gehalt ← 2783.24;

angest.geschlecht ← w;

angest.gehalt ← angest.gehalt + 200.

inspect angest tue

ende

inspect gebdat tue

ende

Präzisierung der Daten

homogene Aggregation - Array

•

Erscheinungsform: Array - Feld

Zusammenfassung vorher festzulegender Anzahl von Daten

Zugriff über Index, endlich skalar, meist Restriktion

•

^Schema:

typ A array I of T.

Hier: I={i1,i2,...,in} Indextyp mit Ordnung i1<i2<...<in.

•

Wertemenge von A: Menge aller n-Tupel (ai , ai , ..., ai ) mit ai T.

Ein Objekt vom Typ A besitzt eines dieser Tupel als Wert (oder ist undefiniert).

1 2 n j

Präzisierung der Daten

homogene Aggregation - Array

Beispiel:

typ A array nat[4..9] of int .

Jedes Objekt a des Typs A kann Werte aus der Menge aller 6-Tupel

(a4, a5, ..., a9)

mit ganzen Zahlen a4, a5, ..., a9 annehmen.

Präzisierung der Daten

homogene Aggregation - Array

•

Selektion: Schreibweise: a(i) statt ai

•

Sei E Ausdruck, mit Wert i in der Wertemenge des Indextyps I. Dann:

a(E)

das zu i gehörende Element des Tupels, also ai.

•

i = k-tes Element der Aufzählung, dann a(E) (=a(i)) sog. k-te Komponente von a.

•

Beispiel: a(3*3-2)=Element a7; a(7) ist das vierte Element des Feldes a.

•

Statt runder Klammern a(E) oft eckige Klammern a [E], je nach Programmiersprache.

Präzisierung der Daten

homogene Aggregation - Beispiel 1

Beispiel 1:

Deklaration zwei Felder a und b mit je fünf Elementen vom Typ int. Anschließend komponentenweise Addition und Ausgabe (Vektoraddition).

Spezifikation:

spec vektoradd: Z⁵×Z⁵→Z⁵ with vektoradd(a,b)=c where

pre a=(a1,...,a5) und b=(b1,...,b5) mit ai,bi Z für 1≤i≤5 post c=(c1,...,c5) mit ci=ai+bi für 1≤i≤5.

Präzisierung der Daten

homogene Aggregation - Beispiel 1

Programm:

typ feld array nat[1..5] of int;

def a,b: feld;

def i: int;

i←1;solange i≤5 tue

lies(a(i)); lies(b(i));

zeige(a(i)+b(i));

i←i+1 ende.

Präzisierung der Daten

homogene Aggregation - Beispiel 2

Beispiel 2: Einlesen eines Textes mit 100 Buchstaben.

Ausgabe der Häufigkeit für jeden Buchstaben a, b, c, d oder e.

Spezifikation:

spec such: A*→(A×IN0)⁵ with such(w)=z where

pre |w|=100

post z=((c1,n1),...,(c5,n5)) mit c1='a', c2='b', c3='c', c4='d', c5='e' und ni=#ci(w) für 1≤i≤5, wobei

0, falls w=ε,

#c(w)= 1+#c(w'), falls w=cw',

#c(w'), falls w=xw' und x≠c.

{

Präzisierung der Daten

homogene Aggregation - Beispiel 2

typ buchstaben char['a'..'e'];

def anzahl : array buchstaben of int;

def ch : char;

def i : int;

ch ← 'a';

solange ch≠'f' tue anzahl(ch) ← 0;

ch ← succ(ch) ende;

i :=1;

solange i≤100 tue lies (ch);

wenn ch {'a','b','c','d','e'} dann anzahl(ch)← anzahl(ch)+1 sonst

ende;

i← i+1 ende;

ch ← 'a';

solange ch≠'f' tue zeige(ch);

zeige(anzahl(ch));

ch ← succ(ch) ende.

Präzisierung der Daten

homogene Aggregation - Beispiel 2

typ buchstaben char['a'..'e'];

def anzahl : array buchstaben of int;

def ch : char;

def i : int;

ch ← 'a';

solange ch≠'f' tue anzahl(ch) ← 0;

ch ← succ(ch) ende;

i :=1;

solange i≤100 tue lies (ch);

wenn ch {'a','b','c','d','e'} dann anzahl(ch)← anzahl(ch)+1 sonst

ende;

i← i+1 ende;

ch ← 'a';

solange ch≠'f' tue zeige(ch);

zeige(anzahl(ch));

ch ← succ(ch) ende.

Initialisierung

Präzisierung der Daten

homogene Aggregation - Beispiel 2

typ buchstaben char['a'..'e'];

def anzahl : array buchstaben of int;

def ch : char;

def i : int;

ch ← 'a';

solange ch≠'f' tue anzahl(ch) ← 0;

ch ← succ(ch) ende;

i :=1;

solange i≤100 tue lies (ch);

wenn ch {'a','b','c','d','e'} dann anzahl(ch)← anzahl(ch)+1 sonst

ende;

i← i+1 ende;

ch ← 'a';

solange ch≠'f' tue zeige(ch);

zeige(anzahl(ch));

ch ← succ(ch) ende.

Präzisierung der Daten

homogene Aggregation - Beispiel 2

typ buchstaben char['a'..'e'];

def anzahl : array buchstaben of int;

def ch : char;

def i : int;

ch ← 'a';

solange ch≠'f' tue anzahl(ch) ← 0;

ch ← succ(ch) ende;

i :=1;

solange i≤100 tue lies (ch);

wenn ch {'a','b','c','d','e'} dann anzahl(ch)← anzahl(ch)+1 sonst

ende;

i← i+1 ende;

ch ← 'a';

solange ch≠'f' tue zeige(ch);

zeige(anzahl(ch));

ch ← succ(ch) ende.

Einlesen von Zeichen, Zählkomponente erhöhen

Präzisierung der Daten

homogene Aggregation - Beispiel 2

typ buchstaben char['a'..'e'];

def anzahl : array buchstaben of int;

def ch : char;

def i : int;

ch ← 'a';

solange ch≠'f' tue anzahl(ch) ← 0;

ch ← succ(ch) ende;

i :=1;

solange i≤100 tue lies (ch);

wenn ch {'a','b','c','d','e'} dann anzahl(ch)← anzahl(ch)+1 sonst

ende;

i← i+1 ende;

ch ← 'a';

solange ch≠'f' tue zeige(ch);

zeige(anzahl(ch));

ch ← succ(ch) ende.

Präzisierung der Daten

homogene Aggregation - Beispiel 2

typ buchstaben char['a'..'e'];

def anzahl : array buchstaben of int;

def ch : char;

def i : int;

ch ← 'a';

solange ch≠'f' tue anzahl(ch) ← 0;

ch ← succ(ch) ende;

i :=1;

solange i≤100 tue lies (ch);

wenn ch {'a','b','c','d','e'} dann anzahl(ch)← anzahl(ch)+1 sonst

ende;

i← i+1 ende;

ch ← 'a';

solange ch≠'f' tue zeige(ch);

zeige(anzahl(ch));

ch ← succ(ch) ende.

Ausgabe von Zeichen und Zähler

Präzisierung der Daten

homogene Aggregation - Beispiel 2

typ buchstaben char['a'..'e'];

def anzahl : array buchstaben of int;

def ch : char;

def i : int;

ch ← 'a';

solange ch≠'f' tue anzahl(ch) ← 0;

ch ← succ(ch) ende;

i :=1;

solange i≤100 tue lies (ch);

wenn ch {'a','b','c','d','e'} dann anzahl(ch)← anzahl(ch)+1 sonst

ende;

i← i+1 ende;

ch ← 'a';

solange ch≠'f' tue zeige(ch);

zeige(anzahl(ch));

ch ← succ(ch) ende.

Präzisierung der Daten

homogene Aggregation

•

Verallgemeinerung: Grundtyp wieder Array-Typ:

typ A array I1 of array I2 of

...

array In of T

•

Abkürzung: array (I1,I2,...,In) of T

•

n-dimensionales Array

•

Selektion: a(E1,E2,...,En) statt a(E1)(E2) ... (En)

Präzisierung der Daten

Generalisation

•

Vereinigung von disjunkten Datentypen zu einem neuen Datentyp

•

Schematisch:

typ D D1 | D2 | ... | Dn

wobei Di Dj= für alle 1≤i<j≤n gilt.

D1,D2,...,Dn: Varianten von D.

Sonderfall: n=1 → Umbenennung eines Datentyps.

Präzisierung der Daten

Generalisation

•

Vereinigung von disjunkten Datentypen zu einem neuen Datentyp

•

Schematisch:

typ D D1 | D2 | ... | Dn

wobei Di Dj= für alle 1≤i<j≤n gilt.

D1,D2,...,Dn: Varianten von D.

Sonderfall: n=1 → Umbenennung eines Datentyps.

Präzisierung der Daten

Generalisation

•

Vereinigung von disjunkten Datentypen zu einem neuen Datentyp

•

Schematisch:

typ D D1 | D2 | ... | Dn

wobei Di Dj= für alle 1≤i<j≤n gilt.

D1,D2,...,Dn: Varianten von D.

Sonderfall: n=1 → Umbenennung eines Datentyps.