WS 2011/2012. Georg Sauthoff 1. October 18, 2011
|
|
|
- Kilian Kruse
- vor 7 Jahren
- Abrufe
Transkript
1 in in WS 2011/2012 Georg 1 AG Praktische Informatik October 18, gsauthof@techfak.uni-bielefeld.de
2 Neue Übungsgruppen in neue Übungsgruppen neue Tutoren
3 Sprechstunden in GZI-Arbeitsraum (V2-240) Tutoren-Sprechstunden (V2-228) lehre/audiws11/#ueb de/gzi-tutoren.html
4 seit 1990 benannt nach dem Logiker Curry Beeinflusst von ML Miranda funktional (pure) lazy evaluation stark typisiert notationelles Juwel Typinferenz Die wichtigsten Implementierungen Hugs GHC in
5 Schlüsselwörter 1 case class data default deriving do else 2 if import in infix infixl infixr instance 3 let module newtype of then type where _ in
6 Schlüsselwörter 1 case class data default deriving do else 2 if import in infix infixl infixr instance 3 let module newtype of then type where _ Vergleich Sprache 21 Scheme 23 C (C89) 32 Java 50 Ada 72 C++ 74 #Keywords in
7 Ausdrücke in keine Statements in
8 Ausdrücke in keine Statements in da funktionale Programmiersprache
9 Ausdrücke in keine Statements in da funktionale Programmiersprache (Ausnahme: Monaden)
10 Bedingter Audruck 1 if expr1 then expr2 else expr3 in
11 Bedingter Audruck 1 if expr1 then expr2 else expr3 Kein If-Statement if expr1 then expr2? in
12 Bedingter Audruck 1 if expr1 then expr2 else expr3 Kein If-Statement if expr1 then expr2? Fehler! sonst wäre Ausdruck im else-zweig nicht definiert in
13 Bedingter Audruck 1 if expr1 then expr2 else expr3 Kein If-Statement if expr1 then expr2? Fehler! sonst wäre Ausdruck im else-zweig nicht definiert Vergleichbar mit dem Bedingungsoperator in C/Java: cond_expr? expr2 : expr3 in
14 Bedingter Audruck 1 if expr1 then expr2 else expr3 Kein If-Statement if expr1 then expr2? Fehler! sonst wäre Ausdruck im else-zweig nicht definiert Vergleichbar mit dem Bedingungsoperator in C/Java: cond_expr? expr2 : expr3 in Example 1 func a b = if a <= b then a else b
15 Operatoren Boolsche Operatoren vordefiniert: oder && und not Vergleichsoperatoren: < <= == /=... reguläre Funktionen in in
16 Operatoren Boolsche Operatoren vordefiniert: oder && und not Vergleichsoperatoren: < <= == /=... reguläre Funktionen in in Example Hugs> :t (&&) (&&) :: Bool -> Bool -> Bool
17 Beispiel in 1 > allequal a b c = 2 > if a == b && b == c then True else False
18 Beispiel in 1 > allequal a b c = 2 > if a == b && b == c then True else False Eleganter 1 > allequal a b c = a == b && b == c
19 Case-Ausdruck vielfache Fallunterscheidung statt verschachtelte If-Expressions überall wo ein Ausdruck stehen kann Pattern matching in
20 Case-Ausdruck vielfache Fallunterscheidung statt verschachtelte If-Expressions überall wo ein Ausdruck stehen kann Pattern matching 1 case expr of 2 pat1 guard1 - > expr1 3 pat2 guard2 - > expr2 4 pat3 guard3 - > expr in
21 Case-Ausdruck vielfache Fallunterscheidung statt verschachtelte If-Expressions überall wo ein Ausdruck stehen kann Pattern matching 1 case expr of 2 pat1 guard1 - > expr1 3 pat2 guard2 - > expr2 4 pat3 guard3 - > expr Pattern kann leer sein statt pat True -> gilt auch die Konvention pat -> otherwise als default in
22 Case-Ausdruck in Example 1 > laststr xs = case reverse xs of 2 > [] -> " leer " 3 > (l:ls) l == 1 -> " eins " 4 > (l:ls) l == 2 -> " zwei " 5 > otherwise - > " ganz viele "
23 Let Expression 1 let decl1 2 decl in expr in
24 Let Expression 1 let decl1 2 decl in expr Kann überall dort stehen wo ein Ausruck stehen kann lokaler Scope (Sichtbarkeitsbereits) in
25 Let Expression 1 let decl1 2 decl in expr Example Kann überall dort stehen wo ein Ausruck stehen kann lokaler Scope (Sichtbarkeitsbereits) 1 > func a b = let square x = x * x 2 > plus a b = a + b 3 > in plus ( square a) ( square b) in
26 Let Expression 1 let decl1 2 decl in expr Example Kann überall dort stehen wo ein Ausruck stehen kann lokaler Scope (Sichtbarkeitsbereits) 1 > func a b = let square x = x * x 2 > plus a b = a + b 3 > in plus ( square a) ( square b) Versus: 1 > square x = x * x 2 3 > plus a b = a + b 4 5 > func a b = plus ( square a) ( square b) in
27 Fehlerbehandlung in mehrere Möglichkeiten Fehler zu behandeln in Programmen (mindestens 8) einfachster Mechanismus: error Signature: error :: String -> a weitere Mechanismen in folgenden Vorlesungen
28 Fehlerbehandlung in mehrere Möglichkeiten Fehler zu behandeln in Programmen (mindestens 8) einfachster Mechanismus: error Signature: error :: String -> a weitere Mechanismen in folgenden Vorlesungen Example 1 > divide a b = 2 > if b == 0 then error " divide by zero " 3 > else div a b
29 in Modulname erster Buchstabe großgeschrieben Modulname == Dateiname Datentypnamen: Beginn mit Großbuchstaben Datentyp-Konstrukturen: Beginn mit Großbuchstaben (z.b. Datentype Bool Konstruktoren: True und False Funktionsnamen: Beginn mit Kleinbuchstaben Operatorzeichen Infix Sonstige Funktionsnamen: Prefix Prioritätive und Assoziation definierbar
30 Modul-Aufbau Modulname Imports Definitionen in
31 Modul-Aufbau Modulname Imports Definitionen 1 > module Meinmodul 2 > where 3 4 > import Data. List 5 in 6 > splits n = [ splitat k [1.. n] k <- [1..n -1] ]
32 Modul-Aufbau Modulname Imports Definitionen 1 > module Meinmodul 2 > where 3 4 > import Data. List 5 in 6 > splits n = [ splitat k [1.. n] k <- [1..n -1] ] Main> splits 5 [ ( [1 ],[ 2,3,4,5] ), ( [1,2 ],[ 3,4,5] ), ( [1,2,3 ],[ 4,5] ), ( [1,2,3,4 ],[ 5] ) ]
33 Where- lokale Definitionen in
34 Where- lokale Definitionen bei Funktionsdefinitionen case-ausdrücken in
35 Where- lokale Definitionen bei Funktionsdefinitionen case-ausdrücken Module-Definition... in
36 Where- Example lokale Definitionen bei Funktionsdefinitionen case-ausdrücken Module-Definition... 1 > f x = square x + square x 2 > where 3 > square x = x * x in
37 Where- Example lokale Definitionen bei Funktionsdefinitionen case-ausdrücken Module-Definition... 1 > f x = square x + square x 2 > where 3 > square x = x * x in vs. let Ausdruck notationelle Betonung syntaktischer Zucker where kann nicht überall stehen
38 Where- in Schachtelungen auch möglich: 1 > foo x =... f... 2 > where 3 > f x =... g... 4 > where 5 > g x =...
39 Guards 1 > fn pat1 pat > guard1 = expr1 3 > guard2 = expr2 4 >... in
40 Guards 1 > fn pat1 pat > guard1 = expr1 3 > guard2 = expr2 4 >... syntaktische Zucker für Funktionsdefinitionen ersetzt geschachtelte if-anweisungen guards (Wächter) sind Ausdrücke (vom Typ Bool) in
41 Guards 1 > fn pat1 pat > guard1 = expr1 3 > guard2 = expr2 4 >... syntaktische Zucker für Funktionsdefinitionen ersetzt geschachtelte if-anweisungen guards (Wächter) sind Ausdrücke (vom Typ Bool) in Example 1 howmanyequal n m p 2 (n == m) && (m == p) = 3 3 (n == m) (m == p) (n == p) = 2 4 otherwise = 0
42 Layout -Programme sind Whitespace-sensitive Verzicht auf Trennzeichen wie ; {} es gilt die Offside-Rule (Abseitsregel) die Einrückung ist entscheident in
43 Layout -Programme sind Whitespace-sensitive Verzicht auf Trennzeichen wie ; {} es gilt die Offside-Rule (Abseitsregel) die Einrückung ist entscheident explizite Verwendung ; {} ist möglich in
44 Layout -Programme sind Whitespace-sensitive Verzicht auf Trennzeichen wie ; {} es gilt die Offside-Rule (Abseitsregel) die Einrückung ist entscheident explizite Verwendung ; {} ist möglich Example (Fehler) in 1 > laststr xs = case reverse xs of 2 > [] -> " leer " 3 > (l:ls) l == 1 -> " eins " 4 > (l:ls) l == 2 -> " zwei " 5 > otherwise - > " ganz viele "
45 Layout Example 1 > laststr xs = case reverse xs of { 2 > [] -> " leer " ; 3 > (l:ls) l == 1 -> " eins " ; 4 > (l:ls) l == 2 -> " zwei " ; 5 > otherwise - > " ganz viele " } in
46 Layout Example 1 > laststr xs = case reverse xs of { 2 > [] -> " leer " ; 3 > (l:ls) l == 1 -> " eins " ; 4 > (l:ls) l == 2 -> " zwei " ; 5 > otherwise - > " ganz viele " } Example 1 > f x = g x + h x 2 > where { g x = x * x ; h x = x + x } in
47 Layout Example 1 > laststr xs = case reverse xs of { 2 > [] -> " leer " ; 3 > (l:ls) l == 1 -> " eins " ; 4 > (l:ls) l == 2 -> " zwei " ; 5 > otherwise - > " ganz viele " } Example 1 > f x = g x + h x 2 > where { g x = x * x ; h x = x + x } in Vorteile Nachteile
48 Prefix/Infix- Funktionen Operatoren in
49 Prefix/Infix- Funktionen Operatoren fn konvertiert nach Infix (op) koverniert nach Prefix in
50 Prefix/Infix- Example Funktionen Operatoren fn konvertiert nach Infix (op) koverniert nach Prefix Main> Main> (+) Test> div Test> 69 div 3 23 in
51 Prefix/Infix- in Flexible Anwendung von Funktionen Deklaration von Prioritäten
52 Pattern matching Pattern Matching auf natürlichen Zahlen Werten Datentyp-Konstruktoren Joker auf der linken Seite von Funktionsdefinitionen in case-ausdrücken in
53 Pattern matching Pattern Matching auf natürlichen Zahlen Werten Datentyp-Konstruktoren Joker auf der linken Seite von Funktionsdefinitionen in case-ausdrücken in Example 1 > take :: Int -> [a] -> [a] 2 > take ( n + 1) ( a : as) = a : take n as 3 > take = []
54 Pattern matching in Example 1 > f (a:b:c:d:ds) =... 2 > f (a:as) =... 3 > f (a :[]) =... 4 > f [a] = > g 0 =... 7 > g 1 =... 8 > g _ =...
55 Datentypen Ein Datentyp ist eine Mengen von Werten, worauf Operationen (Funktionen) definiert werden können. in
56 Datentypen Ein Datentyp ist eine Mengen von Werten, worauf Operationen (Funktionen) definiert werden können. Eingebaute Datentypen in sind zum Beispiel: Ganze Zahlen (Integer, Int) Funktionen darauf sind z.b.: +, div, square Fließkommazahlen (Float, Double) +, /, square Wahrheitswerte (Bool): True, False &&, Listen ([a]) ++, reverse, take Zeichen (Char) Zeichenketten (String), wobei String = [Char] in
57 Datentypen in Ausdrücke haben Typen: 1 42 :: Int :: Int :: Float 4 True :: Bool 5 " Hallo Welt!" :: String -- bzw. [ Char ] 6 [1,2,3] :: [ Int ]
58 Datentypen In der Shell (z.b. Hugs) Typ-Inferenz von Ausdrücken: Hugs> :t (1+2) :: Num a => a Hugs> :t (4.2) 4.2 :: Fractional a => a Hugs> :t 2/3 2 / 3 :: Fractional a => a in
59 Datentypen In der Shell (z.b. Hugs) Typ-Inferenz von Ausdrücken: Hugs> :t (1+2) :: Num a => a Hugs> :t (4.2) 4.2 :: Fractional a => a Hugs> :t 2/3 2 / 3 :: Fractional a => a Typen Einschränken: Hugs> (2::Int) / (3::Int) ERROR - Cannot infer instance *** Instance : Fractional Int *** Expression : 2 / 3 in
60 Datentypen In der Shell (z.b. Hugs) Typ-Inferenz von Ausdrücken: Hugs> :t (1+2) :: Num a => a Hugs> :t (4.2) 4.2 :: Fractional a => a Hugs> :t 2/3 2 / 3 :: Fractional a => a Typen Einschränken: Hugs> (2::Int) / (3::Int) ERROR - Cannot infer instance *** Instance : Fractional Int *** Expression : 2 / 3 in Hugs> (2::Int) div (3::Int) 0
61 Typklassen In sind Typen in Klassen organisiert. Typen sind dabei Instanzen von Klassen. in
62 Typklassen In sind Typen in Klassen organisiert. Typen sind dabei Instanzen von Klassen. Beispiele für Typklassen Eq Überprüfung auf Gleichheit. In der Klasse Eq sind die Operationen == und /= definiert. Instanzen z.b.: Int, Float, Double, String in
63 Typklassen In sind Typen in Klassen organisiert. Typen sind dabei Instanzen von Klassen. Beispiele für Typklassen Eq Überprüfung auf Gleichheit. In der Klasse Eq sind die Operationen == und /= definiert. Instanzen z.b.: Int, Float, Double, String Ord Ordnungsrelation. In der Klasse Ord sind die Operationen <,>,<=,>= definiert. Instanzen z.b.: Int, Float, Double, String in
64 Typklassen In sind Typen in Klassen organisiert. Typen sind dabei Instanzen von Klassen. Beispiele für Typklassen Eq Überprüfung auf Gleichheit. In der Klasse Eq sind die Operationen == und /= definiert. Instanzen z.b.: Int, Float, Double, String Ord Ordnungsrelation. In der Klasse Ord sind die Operationen <,>,<=,>= definiert. Instanzen z.b.: Int, Float, Double, String Num Umfasst die numerischen Typen, z.b. Int, Float, Double Operationen: +,-,* in
65 Typklassen In sind Typen in Klassen organisiert. Typen sind dabei Instanzen von Klassen. Beispiele für Typklassen Eq Überprüfung auf Gleichheit. In der Klasse Eq sind die Operationen == und /= definiert. Instanzen z.b.: Int, Float, Double, String Ord Ordnungsrelation. In der Klasse Ord sind die Operationen <,>,<=,>= definiert. Instanzen z.b.: Int, Float, Double, String Num Umfasst die numerischen Typen, z.b. Int, Float, Double Operationen: +,-,* Show Werte eines Typs der Instanz der Klasse Show ist, lassen sich ausgeben Z.B. Int, Float, Double, String in
66 Listen : [1,2,3,4] 1:2:3:4:[] in
67 Listen : [1,2,3,4] 1:2:3:4:[] Konstruktoren: : (cons) [] (nil) in
68 Listen : [1,2,3,4] 1:2:3:4:[] Konstruktoren: : (cons) [] (nil) [1..10] Signature: [a], [Int] usw. in
69 Listen : [1,2,3,4] 1:2:3:4:[] Konstruktoren: : (cons) [] (nil) [1..10] Signature: [a], [Int] usw. Main> 1:2:3:4:[] [1,2,3,4] in
70 Listen : [1,2,3,4] 1:2:3:4:[] Konstruktoren: : (cons) [] (nil) [1..10] Signature: [a], [Int] usw. Main> 1:2:3:4:[] [1,2,3,4] in Example 1 > length :: [a] -> Int 2 > length [] = 0 3 > length (a:as) = 1 + length as
71 Tupel Signatur: ( a1, a2, a3,... ) vordefinierte Funktionen: fst snd... Komponenten können verschiedene Typen haben vs. Liste in
72 Tupel Signatur: ( a1, a2, a3,... ) vordefinierte Funktionen: fst snd... Komponenten können verschiedene Typen haben vs. Liste in Example 1 fst :: (a, b) -> a 2 fst (x, y) = x 3 4 snd :: (a, b) -> a 5 snd (_, y) = y
73 Void in Unit-Datentyp in : () einziges Element: () vergleichbar mit void in C/Java
74 in von Programmen Ausrechnen von einem funktionalem Programm
75 Ausdrücke und Werte in Ausdrücke repräsentieren Werte. Ausdrücke sind zum Beispiel: *7 3 answer 4 reverse [2, 4]
76 Ausdrücke in Ausdrücke können einfach sein oder komplex. Einfach: 1 49 Komplex: 1 square ( 3+4)
77 Ausdrücke in Ausdrücke können einfach sein oder komplex. Einfach: 1 49 Komplex: 1 square ( 3+4) Definition von square: 1 square :: Int - > Int 2 square x = x * x Die einfachste Form eines Ausdrucks wird Normalform genannt.
78 Reduktion von Ausdrücken Reduktion,, Vereinfachung sind synonyme Begriffe und beschreiben den Prozess, einen Ausdruck in seine einfachste Form (Normalform) zu überführen. Example 1 square :: Int - > Int 2 square x = x * x in
79 Reduktion von Ausdrücken Reduktion,, Vereinfachung sind synonyme Begriffe und beschreiben den Prozess, einen Ausdruck in seine einfachste Form (Normalform) zu überführen. Example 1 square :: Int - > Int 2 square x = x * x Reduktion von: square (3+4) in
80 Reduktion von Ausdrücken Reduktion,, Vereinfachung sind synonyme Begriffe und beschreiben den Prozess, einen Ausdruck in seine einfachste Form (Normalform) zu überführen. Example 1 square :: Int - > Int 2 square x = x * x Reduktion von: square (3+4) in square (3 + 4) => square 7 (+) => 7 * 7 (square) => 49 (*)
81 Reduktion von Ausdrücken Reduktion,, Vereinfachung sind synonyme Begriffe und beschreiben den Prozess, einen Ausdruck in seine einfachste Form (Normalform) zu überführen. Example 1 square :: Int - > Int 2 square x = x * x Reduktion von: square (3+4) in square (3 + 4) => square 7 (+) => 7 * 7 (square) => 49 (*) In : Left-to-right, outermost first (lazy evaluation)
82 Reduktionsvarianten in square wertet aus: Left-to-right, outermost first Alternativ: Left-to-right, innermost first (eager evaluation) non-lazy
83 Reduktionsvarianten in square wertet aus: Left-to-right, outermost first Alternativ: Left-to-right, innermost first (eager evaluation) non-lazy 1 square (3 + 4) = > (3 + 4) * (3 + 4) ( square ) 2 => 7 * (3 + 4) (+) 3 => 7 * 7 (+) 4 => 49 (*)
84 Reduktionsvarianten in 1 take 0 xs = [] 2 take n [] = [] 3 take n (x:xs) = x : take (n -1) xs non-lazy: take 2 [1..] take 2 [1..] => take 2 (1:[2..]) (..) => take 2 (1:2:[3..]) (..) => take 2 (1:2:3:[4..]) (..) =>...
WS 2011/2012. Robert Giegerich. October 17, 2012
in in WS 2011/2012 Robert AG Praktische Informatik October 17, 2012 Sprechstunden in GZI-Arbeitsraum (V2-240) Tutoren-Sprechstunden (V2-228) http://www.techfak.uni-bielefeld.de/ags/pi/ lehre/audiws12/#ueb
Programmieren in Haskell
Universität Bielefeld AG Praktische Informatik October 12, 2014 Wir begnen mit eem Überblick über die Syntax von Namen versus Schlüsselwörter Namen bezeichnen Werte (aller Art) und sd frei wählbar Schlüsselwörter
Programmieren in Haskell
Programmieren in Haskell Wir steigen ein... Programmieren in Haskell 1 Was wir heute machen Umfrage: Wer hat den Hugs ausprobiert? Ausdrücke und Werte Datentypen Funktionen Aufgabe für diese Woche Programmieren
Programmieren in Haskell Einstieg in Haskell
Programmieren in Haskell Einstieg in Haskell Peter Steffen Universität Bielefeld Technische Fakultät 24.10.2008 1 Programmieren in Haskell Was wir heute machen Umfrage: Wer hat den Hugs ausprobiert? Ausdrücke
Programmieren in Haskell
Programmieren in Haskell Wir steigen ein... Programmieren in Haskell 1 Was wir heute machen Umfrage: Wer hat den Hugs ausprobiert? Ausdrücke und Werte Datentypen Funktionen Aufgabe für s Wochenende Programmieren
Programmieren in Haskell
WS 2013/2014 Robert Universität Bielefeld AG Praktische Informatik Vordefierte October 22, 2013 Sprechstunden GZI-Arbeitsraum (V2-240) Tutoren-Sprechstunden (V2-228) http://www.techfak.uni-bielefeld.de/ags/pi/
Grundlegende Datentypen
Funktionale Programmierung Grundlegende Datentypen Fakultät für Informatik und Mathematik Hochschule München Letzte Änderung: 14.11.2017 15:37 Inhaltsverzeichnis Typen........................................
Funktionale Programmierung Grundlegende Datentypen
Grundlegende Datentypen Prof. Dr. Oliver Braun Fakultät für Informatik und Mathematik Hochschule München Letzte Änderung: 06.11.2017 16:45 Inhaltsverzeichnis Typen........................................
Grundlegende Datentypen
Grundlegende Datentypen (Funktionale Programmierung) Prof. Dr. Oliver Braun Letzte Änderung: 18.03.2018 21:08 Grundlegende Datentypen 1/16 Typen in Haskell ist alles streng typisiert Haskell verfügt über
Grundlegende Datentypen
Grundlegende Datentypen Funktionale Programmierung Prof. Dr. Oliver Braun Letzte Änderung: 22.10.2018 10:53 Grundlegende Datentypen 1/21 Typen in Haskell ist alles streng typisiert Haskell verfügt über
Programmieren in Haskell
Programmieren in Haskell Syntax und Semantik von Haskell Programmieren in Haskell 1 Was wir heute (und nächstes mal) machen Datentypdefinitionen Wertdefinitionen, Variablenbindungen Musterbindungen Funktionsbindungen
WS 2011/2012. Georg Sauthoff 1. November 11, 2011
WS 2011/2012 Georg 1 AG Praktische Informatik November 11, 2011 1 gsauthof@techfak.uni-bielefeld.de Skripte sind nun fertig und gibt es in den Tutorien Sprechstunden Zusammenfassung -Kapitel Signatur zuerst
Programmieren in Haskell
Programmieren in Haskell Syntax und Semantik von Haskell Programmieren in Haskell 1 Was wir heute (und nächstes mal) machen Datentypdefinitionen Wertdefinitionen, Variablenbindungen Musterbindungen Funktionsbindungen
WS 2011/2012. RobertGiegerich. November 12, 2013
WS 2011/2012 Robert AG Praktische Informatik November 12, 2013 Haskell-Syntax: Ergänzungen Es gibt noch etwas bequeme Notation für Fallunterscheidungen, die wir bisher nicht benutzt haben. Bisher kennen
WS 2011/2012. RobertGiegerich. November 12, 2013
WS 2011/2012 Robert AG Praktische Informatik November 12, 2013 Haskell-Syntax: Ergänzungen Es gibt noch etwas bequeme Notation für Fallunterscheidungen, die wir bisher nicht benutzt haben. Bisher kennen
Programmieren in Haskell Einführung
Programmieren in Haskell Einführung Peter Steffen Universität Bielefeld Technische Fakultät 17.10.2008 1 Programmieren in Haskell Veranstalter Dr. Peter Steffen Raum: M3-124 Tel.: 0521/106-2906 Email:
Typ-Polymorphismus. November 12, 2014
Typ-Polymorphismus Universität Bielefeld AG Praktische Informatik November 12, 2014 Das Haskell Typ-System Wir beginnen mit einer Wiederholung des Bekannten: In allen Programmiersprachen sind Typ-Konzepte
Typklassen. Natascha Widder
Typklassen Natascha Widder 19.11.2007 Motivation Typklassen fassen Typen mit ähnlichen Operatoren zusammen ermöglichen überladenen Funktionen Definition Typklassen Deklarationsschema class Name Platzhalter
Einführung in Haskell
Einführung in Haskell Axel Stronzik 21. April 2008 1 / 43 Inhaltsverzeichnis 1 Allgemeines 2 / 43 Inhaltsverzeichnis 1 Allgemeines 2 Funktions- und Typdefinitionen 2 / 43 Inhaltsverzeichnis 1 Allgemeines
WS 2011/2012. Robert Giegerich. October 30, 2013
WS 2011/2012 Robert AG Praktische Informatik October 30, 2013 Algebraische Datentypen Neue Datentypen werden als algebraische Datentypen eingeführt. Werte des Datentyps sind Formeln, die aus Konstruktoren
Einführung in die funktionale Programmierung
Einführung in die funktionale Programmierung Prof. Dr. Manfred Schmidt-Schauÿ Künstliche Intelligenz und Softwaretechnologie 26. Oktober 2006 Haskell - Einführung Syntax Typen Auswertung Programmierung
Kapitel 3: Eine einfache Programmiersprache. Programmieren in Haskell 1
Kapitel 3: Eine einfache Programmiersprache Programmieren in Haskell 1 Datentypen, Datentypdefinitionen data Instrument = Oboe HonkyTonkPiano Cello VoiceAahs data Musik = Note Ton Dauer Pause Dauer Musik
WS 2011/2012. Georg Sauthoff 1. October 26, 2011
WS 2011/2012 Georg 1 AG Praktische Informatik October 26, 2011 1 gsauthof@techfak.uni-bielefeld.de pea*nuts pea*nuts steht für probieren, erfahren, anwenden - Naturwissenschaften und Technik für Schülerinnen
Programmieren in Haskell Einführung
Programmieren in Haskell Einführung Peter Steffen Universität Bielefeld Technische Fakultät 16.10.2009 1 Programmieren in Haskell Veranstalter Dr. Peter Steffen Raum: M3-124 Tel.: 0521/106-2906 Email:
Praktische Informatik 3: Funktionale Programmierung Vorlesung 4 vom : Typvariablen und Polymorphie
Rev. 2749 1 [28] Praktische Informatik 3: Funktionale Programmierung Vorlesung 4 vom 04.11.2014: Typvariablen und Polymorphie Christoph Lüth Universität Bremen Wintersemester 2014/15 2 [28] Fahrplan Teil
WS 2011/2012. Georg Sauthoff 1. November 1, 2011
WS 2011/2012 Georg 1 AG Praktische Informatik November 1, 2011 1 gsauthof@techfak.uni-bielefeld.de Übungen Abgaben und Aufgabenblätter am Ende der Vorlesung Skript gibt es demnächst in den Übungen Der
Programmieren in Haskell Das Haskell Typsystem
Programmieren in Haskell Das Haskell Typsystem Peter Steffen Robert Giegerich Universität Bielefeld Technische Fakultät 22.01.2010 1 Programmieren in Haskell Belauscht... Lisa Lista: Ohne Typen keine korrekten
Programmieren in Haskell
beschreibungen Universität Bielefeld AG Praktische Informatik October 21, 2014 der funktionalen Programmierung gibt es allen Programmiersprachen, aber der funktionalen Programmierung werden sie besonders
Was bisher geschah Funktionale Programmierung in Haskell: Algebraische Datentypen Pattern Matching Polymorphie Typklassen Rekursive Datentypen:
Was bisher geschah Funktionale Programmierung in Haskell: Algebraische Datentypen Pattern Matching Polymorphie Typklassen Rekursive Datentypen: Peano-Zahlen, Listen, Bäume Rekursive Funktionen strukturelle
WS 2012/2013. Robert Giegerich. 21. November 2012
WS 2012/2013 Robert AG Praktische Informatik 21. November 2012 Funktionen als Bürger erster Klasse Funktionen definieren kann man in jeder Programmiersprache. Eine funktionalen Programmiersprache erlaubt
Funktionale Programmierung Mehr funktionale Muster
Mehr funktionale Muster Prof. Dr. Oliver Braun Fakultät für Informatik und Mathematik Hochschule München Letzte Änderung: 07.12.2017 06:56 Inhaltsverzeichnis Pattern Matching..................................
Praktische Informatik 3: Funktionale Programmierung Vorlesung 2 vom : Funktionen und Datentypen
Rev. 1843 1 [35] Praktische Informatik 3: Funktionale Programmierung Vorlesung 2 vom 23.10.2012: Funktionen und Datentypen Christoph Lüth Universität Bremen Wintersemester 2012/13 2 [35] Fahrplan Teil
Was bisher geschah. deklarative Programmierung. funktionale Programmierung (Haskell):
Was bisher geschah deklarative Programmierung funktional: Programm: Menge von Termgleichungen, Term Auswertung: Pattern matsching, Termumformungen logisch: Programm: Menge von Regeln (Horn-Formeln), Formel
Vorsemesterkurs Informatik
Vorsemesterkurs Informatik Sommersemester 2011 Grundlagen der Programmierung in Haskell SoSe 2011 Stand der Folien: 30. März 2011 Übersicht 1 Ausdrücke und Typen 2 Funktionen 3 Rekursion Vorkurs Informatik
Funktionale Programmierung
Funktionale Programmierung Jörg Kreiker Uni Kassel und SMA Solar Technology AG Wintersemester 2011/2012 2 Teil II Typen mit Werten und Ausdruck, sogar listenweise 3 Haskell Programme Programm Module ein
ALP I. Funktionale Programmierung
ALP I Funktionale Programmierung Zusammengesetzte Datentypen in Haskell WS 2012/2013 Zusammengesetzte Datentypen Tupel List String Zusammengesetzte Datentypen Tupel-Datentyp Ein Tupel ist eine Ansammlung
Prüfung Funktionale Programmierung
Hochschule für angewandte Wissenschaften München Fakultät für Informatik und Mathematik Studiengruppe IF, IB, IC Sommersemester 2015 Prüfung Funktionale Programmierung Datum : 23.07.2015, 10:30 Uhr Bearbeitungszeit
Programmieren in Haskell Programmiermethodik
Programmieren in Haskell Programmiermethodik Peter Steffen Universität Bielefeld Technische Fakultät 12.01.2011 1 Programmieren in Haskell Bisherige Themen Was soll wiederholt werden? Bedienung von hugs
Praktische Informatik 3: Funktionale Programmierung Vorlesung 4 vom : Typvariablen und Polymorphie
16:02:01 2017-01-17 1 [37] Praktische Informatik 3: Funktionale Programmierung Vorlesung 4 vom 08.11.2016: Typvariablen und Polymorphie Christoph Lüth Universität Bremen Wintersemester 2016/17 PI3 WS 16/17
Haskell for Hackers... or why functional programming matters
... or why functional programming matters Franz Pletz CCC München 27-06-2009 @ GPN8 Fahrplan Ablauf Motivation 1 Ablauf Motivation 2 3 4 Ablauf Ablauf Motivation bei Fragen/Unklarheiten:
ALP I. Funktionale Programmierung
ALP I Funktionale Programmierung Typ-Klassen und SS 2011 Überladung von Datentypen Funktionen sollen oft auf verschiedene Datentypen anwendbar sein, aber nicht auf beliebige Datentypen. Beispiel: Die (+)
Funktionale Programmierung mit Haskell
Funktionale Programmierung mit Haskell Dr. Michael Savorić Hohenstaufen-Gymnasium (HSG) Kaiserslautern Version 20120622 Überblick Wichtige Eigenschaften Einführungsbeispiele Listenerzeugung und Beispiel
Monaden. 14. Januar 2015
Universität Bielefeld AG Praktische Informatik 14. Januar 2015 Imperativ nennt man Progamiersprachen, die mit Anweisungen operieren. Jede Anweisung hat Wirkungen auf einen globalen Zustand, der wiederum
HASKELL KAPITEL 2.1. Notationen: Currying und das Lambda-Kalkül
HASKELL KAPITEL 2.1 Notationen: Currying und das Lambda-Kalkül Bisheriges (Ende VL-Teil 1) weite :: (Float,Float) ->Float weite (v0, phi) = (square(v0)/9.81) * sin(2 * phi) (10, 30 ) smaller ::(Integer,
Hallo Haskell. Funktionale Programmierung. Prof. Dr. Oliver Braun Letzte Änderung: :06. Hallo Haskell 1/23
Hallo Haskell Funktionale Programmierung Prof. Dr. Oliver Braun Letzte Änderung: 15.10.2018 07:06 Hallo Haskell 1/23 Glasgow Haskell Compiler (GHC) der Haskell-Compiler ist der GHC Sie installieren ihn
Die Definition eines Typen kann rekursiv sein, d.h. Typ-Konstruktoren dürfen Elemente des zu definierenden Typ erhalten.
4.5.5 Rekursive Typen Die Definition eines Typen kann rekursiv sein, d.h. Typ-Konstruktoren dürfen Elemente des zu definierenden Typ erhalten. datatype IntList = Nil Cons o f ( i n t IntList ) ; Damit
WS 2013/2014. Robert Giegerich. 11. Dezember 2013
WS 2013/2014 Robert AG Praktische Informatik 11. Dezember 2013 höherer Ordnung Worum geht es heute? In Haskell gibt es, die als Argument haben oder als Ergebnis liefern. Diese nennt man höherer Ordnung.
Hallo Haskell. (Funktionale Programmierung) Prof. Dr. Oliver Braun. Letzte Änderung: :08. Hallo Haskell 1/23
Hallo Haskell (Funktionale Programmierung) Prof. Dr. Oliver Braun Letzte Änderung: 18.03.2018 21:08 Hallo Haskell 1/23 Glasgow Haskell Compiler (GHC) der Haskell-Compiler ist der GHC Sie installieren ihn
Zahlen in Haskell Kapitel 3
Einführung in die Funktionale Programmiersprache Haskell Zahlen in Haskell Kapitel 3 FH Wedel IT-Seminar: WS 2003/04 Dozent: Prof. Dr. Schmidt Autor: Timo Wlecke (wi3309) Vortrag am: 04.11.2003 - Kapitel
Funktionale Programmierung mit Haskell. Jan Hermanns
Funktionale Programmierung mit Haskell Jan Hermanns 1 Programmiersprachen imperativ deklarativ konventionell OO logisch funktional Fortran Smalltalk Prolog Lisp C Eiffel ML Pascal Java Haskell 2 von Neumann
Programmierkurs II. Typsynonyme & algebraische Datentypen
Programmierkurs II Typsynonyme & algebraische Datentypen Um Dinge der realen Welt abzubilden, ist es nur in den seltensten Fällen komfortabel alles als Zahlen, Strings oder Listen zu kodieren. Wir benötigen
WS 2013/2014. Robert Giegerich. 11. Dezember 2013
WS 2013/2014 Robert AG Praktische Informatik 11. Dezember 2013 höherer Ordnung Worum geht es heute? In Haskell gibt es, die als Argument haben oder als Ergebnis liefern. Diese nennt man höherer Ordnung.
Algorithmen und Programmieren 1 Funktionale Programmierung - Musterlösung zur Übungsklausur -
Algorithmen und Programmieren 1 Funktionale Programmierung - Musterlösung zur Übungsklausur - Punkte: A1: 30, A2: 20, A3: 20, A4: 20, A5: 10, A6: 20 Punkte: /120 12.02.2012 Hinweis: Geben Sie bei allen
Verarbeitung unendlicher Datenstrukturen Jetzt können wir z.b. die unendliche Liste aller geraden Zahlen oder aller Quadratzahlen berechnen:
Verarbeitung unendlicher Datenstrukturen Jetzt können wir z.b. die unendliche Liste aller geraden Zahlen oder aller Quadratzahlen berechnen: take 1 0 ( f i l t e r ( fn x => x mod 2=0) nat ) ; val it =
Gliederung. n Teil I: Einleitung und Grundbegriffe. n Teil II: Imperative und objektorientierte Programmierung
Gliederung n Teil I: Einleitung und Grundbegriffe l 1. Organisatorisches l 2. Grundlagen von Programmiersprachen n Teil II: Imperative und objektorientierte Programmierung l 1. Grundelemente der Programmierung
Haskell. (Compiler) Prof. Dr. Oliver Braun. Letzte Änderung: :58. Haskell 1/28
Haskell (Compiler) Prof. Dr. Oliver Braun Letzte Änderung: 03.05.2017 14:58 Haskell 1/28 Haskell vs. imperative Sprachen https://www.haskell.org/ rein funktionale Sprache funktionale Programmierung ==
Informatik I - Programmierung Globalübung Hugs98 Currying. Hugs98 Currying
Informatik I - Programmierung Globalübung 13.01.2003 Hugs98 Currying Thomas Weiler Fachgruppe Informatik RWTH Aachen T. Weiler, RWTH Aachen - 1 - Hugs98 Currying Bedienung Typen Fehlermeldungen Inhalt
Prüfung Funktionale Programmierung
Hochschule für angewandte Wissenschaften München Fakultät für Informatik und Mathematik Studiengruppe IF, IB, IC Sommersemester 2014 Prüfung Funktionale Programmierung Datum : 16.07.2014, 12:30 Uhr Bearbeitungszeit
Basiskonstrukte von Haskell
Basiskonstrukte von Haskell PD Dr. David Sabel Goethe-Universität Frankfurt am Main 29. September 2015 Basistypen und Operationen Ganzzahlen: Int = Ganzzahlen beschränkter Länge Integer = Ganzzahlen beliebiger
Crashkurs: Haskell. Mentoring FU Berlin Felix Droop
Crashkurs: Haskell Mentoring FU Berlin 7.11.2018 Felix Droop Crashkurs Haskell 1. GHCi Umgebung
Paradigmen der Programmierung
SS 11 Prüfungsklausur 25.07.2011 Aufgabe 5 (6+9 = 15 Punkte) a) Bestimmen Sie jeweils den Typ der folgenden Haskell-Ausdrücke: ( 1, 2 :"3", 4 < 5) :: (Char, String, Bool) [(last, tail), (head, take 5)]
Grundprinzipien der funktionalen Programmierung
Grundprinzipien der funktionalen Programmierung Funktionen haben keine Seiteneffekte Eine Funktion berechnet einen Ausgabewert der nur von den Eingabewerten abhängt: 12 inputs + output 46 34 2 Nicht nur
Praktische Informatik 3
Praktische Informatik 3 Christian Maeder WS 03/04 Vorlesung vom 12.1.2004: Ein/Ausgabe in funktionalen Sprachen Vorlesung vom 12.1.2004: Ein/Ausgabe in funktionalen Sprachen 3 Inhalt Wo ist das Problem?
Anwendung (2. Versuch:-) Entkopplung der Locks
Gut gemeint aber leider fehlerhaft... Jeder Producer benötigt zwei Locks gleichzeitig, um zu produzieren: 1. dasjenige für den Puffer; 2. dasjenige für einen Semaphor. Musser fürden Semaphor einwait()
ProInformatik: Funktionale Programmierung Woche 1:
Informatik Institut, Fachbereich Mathematik und Informatik ProInformatik: Funktionale Programmierung Woche 1: 28.7-1.8.2008 Dozentin: Maria Knobelsdorf Tutorin, Tutor: Peggy Sabri, Dirk Wiesenthal 28.7
Haskell, Typen, und Typberechnung. Grundlagen der Programmierung 3 A. Einige andere Programmiersprachen. Typisierung in Haskell
Haskell, Typen, und Typberechnung Grundlagen der Programmierung 3 A Typen, Typberechnung und Typcheck Prof. Dr. Manfred Schmidt-Schauß Ziele: Haskells Typisierung Typisierungs-Regeln Typ-Berechnung Milners
Informatik-Seminar Thema: Monaden (Kapitel 10)
Informatik-Seminar 2003 - Thema: Monaden (Kapitel 10) Stefan Neumann 2. Dezember 2003 Inhalt Einleitung Einleitung Die IO()-Notation Operationen Einleitung Gegeben seien folgende Funktionen: inputint ::
October 29, Universität Bielefeld AG Praktische Informatik. Programmieren in Haskell. Stefan Janssen. Typ-Synonyme. Algebraische Datentypen
Universität Bielefeld AG Praktische Informatik October 29, 2014 Typsynonyme Neue Typnamen durch Typsynonyme: 1 type Pair a b = (a,b) 2 type Triple a b c = (a,b,c) 3 type OrdList a = [ a] definiert neue
Funktionale Programmierung
Monaden LFE Theoretische Informatik, Institut für Informatik, Ludwig-Maximilians Universität, München 30. April 2009 Monaden Eine Monade ist ein Programmier-Schema für sequentielle Berechnungen. In Haskell
WS 2012/2013. Robert Giegerich. January 22, 2014
WS 2012/2013 Robert Systeme AG Praktische Informatik January 22, 2014 Das Haskell System In allen Programmiersprachen sind die Konzepte ein prägendes Element. Das Haskell System hat zwei grundlegende Konzepte:
Proinformatik Marco Block Dienstag, den 21. Juli 2009
2. Skript vom Dienstag, den 21. Juli 2009 zur Vorlesung Proinformatik Marco Block Dienstag, den 21. Juli 2009 1 Verschiedenes 1.1 let und where Am Anfang der Vorlesung haben wir uns ein paar einfache neue
ALP I Einführung in Haskell
ALP I Einführung in Haskell WS 2012/2013 Was ist Haskell? Haskell ist eine rein Funktionale Programmiersprache mit einer nach Bedarf Auswertung-Strategie oder "Lazy Evaluation". Was bedeutet rein funktional?
5. Januar Universität Bielefeld AG Praktische Informatik. Programmieren in Haskell. Stefan Janssen. Abstrakte Datentypen.
Universität Bielefeld AG Praktische Informatik 5. Januar 2015 Themen-Vorschau Module In der Software-Entwicklung unterscheidet zwei Arten von : konkrete beziehen sich auf eine konkrete Repräsentation in
Funktionale Programmierung ALP I. Algebraische Datentypen und Abstrakte Datentypen. SS 2013 Prof. Dr. Margarita Esponda. Prof. Dr.
Funktionale Programmierung AP I Algebraische Datentypen und Abstrakte Datentypen SS 2013 Abstrakt Datentypen Beispiel: Algebraischen Datentypen für Bäume data SBTree = SBTree SBTree AP I: Margarita Esponda,
ROGER GILLIAR / MCS GMBH HASKELL FÜR JAVA PROGRAMMIERER
ROGER GILLIAR / MCS GMBH HASKELL FÜR JAVA PROGRAMMIERER interface ImportantService { Double getmoney(); } ... sollte stets ein so genannter Kontrakt definiert werden, über den die Bedeutung der verschiedenen
Funktionale Programmierung. Das Funktionale Quiz. Das Funktionale Quiz. Das Funktionale Quiz
Funktionale Programmierung Das Funktionale Quiz 31.5.2005 Nenne eine Gemeinsamkeit zwischen Typklassen und OO-Klassen Das Funktionale Quiz Das Funktionale Quiz Nenne einen Unterschied zwischen Typklassen
Praktische Informatik 3: Funktionale Programmierung Vorlesung 11 vom : Monaden als Berechnungsmuster
16:02:16 2017-01-17 1 [30] Praktische Informatik 3: Funktionale Programmierung Vorlesung 11 vom 10.01.2017: Monaden als Berechnungsmuster Christoph Lüth Universität Bremen Wintersemester 2016/17 Frohes
Algorithmen und Programmieren 1 Funktionale Programmierung - Musterlösung zu Übung 4 -
Algorithmen und Programmieren 1 Funktionale Programmierung - Musterlösung zu Übung 4 - Dozent: Prof. Dr. G. Rote Tutoren: J. Fleischer, T. Haimberger, N. Lehmann, C. Pockrandt, A. Steen 11.11.011 Ziele
5.3 Auswertung von Ausdrücken
5.3 Auswertung von Ausdrücken Funktionen in Java bekommen Parameter/Argumente als Input, und liefern als Output den Wert eines vorbestimmten Typs. Zum Beispiel könnte man eine Funktion i n t min ( i n
3. Java - Sprachkonstrukte I
Lernziele 3. Java - Sprachkonstrukte I Namen und Bezeichner, Variablen, Zuweisungen, Konstanten, Datentypen, Operationen, Auswerten von Ausdrücken, Typkonversionen Sie kennen die grundlegensten Bausteine
Vorsemesterkurs Informatik
Stand der Folien: 31. März 2011 Vorsemesterkurs Informatik Sommersemester 2011 Grundlagen der Programmierung in Haskell SoSe 2011 Übersicht 1 Ausdrücke und Typen 2 Funktionen 3 Rekursion 4 Listen 5 Paare
Softwaretechnik. Funktionale Programmierung. Christian Lindig. 23. Januar 2006. Lehrstuhl für Softwaretechnik Universität des Saarlandes
Softwaretechnik Funktionale Programmierung Christian Lindig Lehrstuhl für Softwaretechnik Universität des Saarlandes 23. Januar 2006 Quicksort in Java static void sort(int a[], int lo0, int hi0) { int
Programmieren in Haskell
Programmieren in Haskell Felder (Arrays) Programmieren in Haskell 1 Was wir heute machen Motivationsbeispiel Die Typklasse Ix Felder in Haskell Funktionstabellierung Binäre Suche Pascalsches Dreieck Ein
Workshop Einführung in die Sprache Haskell
Workshop Einführung in die Sprache Haskell Nils Rexin, Marcellus Siegburg und Alexander Bau Fakultät für Informatik, Mathematik und Naturwissenschaften Hochschule für Technik, Wirtschaft und Kultur Leipzig
3. Java - Sprachkonstrukte I
Namen und Bezeichner Ein Programm (also Klasse) braucht einen Namen 3. Java - Sprachkonstrukte I Namen und Bezeichner, Variablen, Zuweisungen, Konstanten, Datentypen, Operationen, Auswerten von Ausdrücken,
Grundlagen der Programmierung 3 A
Grundlagen der Programmierung 3 A Typen, Typberechnung und Typcheck Prof. Dr. Manfred Schmidt-Schauß Sommersemester 2016 Haskell, Typen, und Typberechnung Ziele: Haskells Typisierung Typisierungs-Regeln
Crashkurs Haskell Mentoring WiSe 2016/17. Anja Wolffgramm Freie Universität Berlin
Crashkurs Haskell Mentoring WiSe 2016/17 Anja Wolffgramm Freie Universität Berlin 02/11/2016 , Inhalt Kommandozeile Haskell installieren & starten Ein 1. Haskell-Programm Funktionsdefinition Primitive
Grundlagen der Programmierung 2 (1.A)
Grundlagen der Programmierung 2 (1.A) Einführung Prof. Dr. Manfred Schmidt-Schauß Sommersemester 2015 Grundlagen der Programmierung 2 Geplanter Inhalt der ersten Hälfte: Programmieren in Haskell Definitionen;
WS 2011/2012. Robert Giegerich Dezember 2013
WS 2011/2012 Robert 1 AG Praktische Informatik 11. Dezember 2013 1 robert@techfak.uni-bielefeld.de Vorschau Themen heute: Funktionen höherer Ordnung (Fortsetzung) künstliche Striktheit mehr zu fold für
Javaprogrammierung mit NetBeans. Variablen, Datentypen, Methoden
Javaprogrammierung mit NetBeans Variablen, Datentypen, Methoden Programmieren 2 Java Bezeichner Bezeichner: Buchstabe _ $ Buchstabe _ $ Ziffer Groß- und Kleinbuchstaben werden strikt unterschieden. Schlüsselwörter
Frage, Fragen und nochmals Fragen
Frage, Fragen und nochmals Fragen Berthold Hoffmann Universität Bremen and DFKI Bremen hof@informatik.uni-bremen.de In diesem Text stehen einige Fragen, die man sich zu den Folien der Veranstaltung Funktionales
Datentypen: integer, char, string, boolean
Agenda für heute, 13. April, 2006 Der Datentyp integer Vergleichsoperatoren, Wahrheitswerte und boolesche Variablen Zusammengesetzte if-then-else-anweisungen Var i: integer; Teilbereich der ganzen Zahlen,
Grundlagen der Programmierung 2 A (Listen)
Grundlagen der Programmierung 2 A (Listen) Haskell: Listen Prof. Dr. Manfred Schmidt-Schauß Sommersemester 2017 Listen und Listenfunktionen Listen modellieren Folgen von gleichartigen, gleichgetypten Objekten.
Programmieren in Haskell
Programmieren in Haskell Felder (Arrays) Programmieren in Haskell 1 Was wir heute machen Motivationsbeispiel Die Typklasse Ix Felder in Haskell Funktionstabellierung Binäre Suche Pascalsches Dreieck Hashing
Funktionen höherer Ordnung. 3. Dezember 2014
höherer Ordnung Universität Bielefeld AG Praktische Informatik 3. Dezember 2014 höherer Ordnung Worum geht es heute? In Haskell gibt es, die als Argument haben oder als Ergebnis liefern. Diese nennt man
ProInformatik: Funktionale Programmierung. Punkte
ProInformatik: Funktionale Programmierung 27.7-22.8.2008, M. Knobelsdorf Probeklausur Ihre persönliche Klausurnummer: Vorname, Nachname: Aufgabe 1 2 3 4 5 6 7 8 Punkte 12 4 4 4 4 2 4 6 40 Erz. Punkte Zum