Funktionale Programmierung. ALP I Lambda-Kalkül. Teil IVb WS 2012/2013. Prof. Dr. Margarita Esponda. Prof. Dr. Margarita Esponda
|
|
|
- Elizabeth Küchler
- vor 8 Jahren
- Abrufe
Transkript
1 ALP I Lambda-Kalkül Teil IVb WS 2012/2013
2 λ-kalkül-parser Hilfsfunktionen: Die break-funktion ist eine Funktion höherer Ordnung, die eine Liste beim ersten Vorkommen einer Bedingung in zwei Listen spaltet. break :: (a -> Bool) -> [a] -> ([a],[a]) break p xs = span p' xs span p [] = ([],[]) where p' x = not (p x) span p xs@(x:xs') p x = (x:ys, zs) xs wird als Synonym von (x:xs') interpretiert otherwise = ([], xs) where (ys,zs) = span p xs'
![break :: (a -> Bool) -> [a] -> ([a],[a]) break p xs = span p' xs span p [] = ([],[]) where p' x =](/docs-images/42/3188529/images/page_2.jpg "not (p x) span p xs@(x:xs') p x = (x:ys, zs) xs wird als Synonym von (x:xs') interpretiert")
3 Parser Anwendungsbeispiele der Funktionen break und span: break (=='e') "abcdehijkl" ("abcd", "ehijkl") break (>3) [2,3,4,5,6] ([2,3],[4,5,6]) span (/='e') "123ebc456" ("123","ebc456") span (>3) [2,3,4,5,6] ([],[2,3,4,5,6]) break (>3) [2,3,4,5] == span (<=3) [2,3,4,5] True
![([2,3],[4,5,6]) span (/='e') "123ebc456" ("123","ebc456") span (>3)](/docs-images/42/3188529/images/page_3.jpg "[2,3,4,5,6] ([],[2,3,4,5,6]) break (>3) [2,3,4,5] == span (<=3)")
4 Parser (Hilfsfunktionen) lowletter x = elem x ['a'..'z'] digit x = elem x ['0'..'9'] symbol x = elem x ['A'..'Z'] digit x elem x ['+','*','!','&',' ','%','=','>','<','-'] extract :: String -> String -> Int -> (String, String) extract a [] _ = error "unbalanced parentheses" extract a (')':b) 0 = (a,b) extract a (')':b) n = extract (a++")") b (n-1) extract a ('(':b) n = extract (a++"(") b (n+1) extract a (b:c) n = extract (a++[b]) c n
![','&',' ','%','=','>','<','-'] extract :: String -> String -> Int -> (String, String) extract a [] _ = error](/docs-images/42/3188529/images/page_4.jpg "\"unbalanced parentheses\" extract a (')':b) 0 = (a,b) extract a (')':b) n = extract (a++\")\") b (n-1) extract")
5 Parser (Hilfsfunktionen) Beispiele: extract "x" [] 0 *** Exception: unbalanced parentheses extract [] "abcd)" 0 ("abcd","") extract [] "(abcd))" 0 ("(abcd)","") extract [] "/x.xx)" 0 ("/x.xx","") extract [] "/x.xx)(ww)" 0 ("/x.xx","(ww)") extract [] "/x.xx)(ww)))" 2 ("/x.xx)(ww))","") extract [] "/x.xx)(ww)(a)" 0 ("/x.xx","(ww)(a)")
![extract [] "/x.xx)" 0 ("/x.xx","") extract [] "/x.xx)(ww)" 0 ("/x.](/docs-images/42/3188529/images/page_5.jpg "xx\",\"(ww)\") extract [] \"/x.xx)(ww)))\" 2 (\"/x.xx)(ww))\",\"\") extract [] \"/x.")
6 Syntaxbaum data Expr = Var String App Expr Expr Lambda (Var String) Expr Nil deriving ( Eq ) App (λs. ss)(λy.x) Lambda Lambda Var App Var Var s Var Var y x s s
7 Syntaxbaum (Vereinfacht) data Expr = Var String App Expr Expr Lambda String Expr Nil deriving ( Eq ) App (λs. ss)(λy.x) Lambda Lambda s App y Var Var Var x s s
8 λ-kalkül-parser parser "y" Var "y" parser "yx" App (Var "x") (Var "y") parser "/x.xy" Lambda "x" (App (Var "x") (Var "y")) parser "/x.xy(/z.y)" Lambda "x" (App (App (Var "x") (Var "y")) (Lambda "z" (Var "y")))
9 λ-kalkül-parser und -Interpreter module LambdaCalcul ( Expr, parser, eval, show, lci) where data Expr = Var String App Expr Expr Lambda String Expr Nil deriving (Eq) type Parser = String -> Expr instance Show Expr where show = show_expr show_expr:: Expr- > String show_expr (Var x) = x show_expr (App x y) = "(" ++ (show_expr x) ++ (show_expr y) ++")" show_expr (Lambda x y) = "(/" ++ x ++ "." ++ (show_expr y) ++")"
10 parser :: Parser parser str = parse Nil str Parser (1. Version) parse :: Expr -> String -> Expr parse Nil [] parse e [] parse Nil (a:r) lowletter a parse e (a:r) lowletter a = error "empty expression" = e = parse (Var [a]) r = parse (App e (Var [a])) r parse Nil ('/':a:'.':r) lowletter a = Lambda [a] (parse Nil r) parse e ('/':a:'.':r) lowletter a = App e (Lambda [a] (parse Nil r)) parse Nil ('(':r) = parse (parse Nil a) b where (a,b) = extract [] r 0 parse e ('(':r) = parse (App e (parse Nil a)) b where (a,b) = extract [] r 0 parse e _ = error ("parsing error"++(show_expr e))
![= e = parse (Var [a]) r = parse (App e (Var [a])) r parse Nil ('/':a:'.':r) lowletter a = Lambda [a] (parse Nil r) parse e ('/':a:'.](/docs-images/42/3188529/images/page_10.jpg "':r) lowletter a = App e (Lambda [a] (parse Nil r)) parse Nil ('(':r) = parse (parse Nil a) b where (a,b) = extract [] r 0 parse e ('(':r) =")
11 λ-kalkül-parser parser "y" Var "y" parser "yx" App (Var "x") (Var "y") parser "/x.xy" Lambda "x" (App (Var "x") (Var "y")) parser "/x.xy(/z.y)" Lambda "x" (App (App (Var "x") (Var "y")) (Lambda "z" (Var "y")))
12 Parser (2. Version) parser :: Parser parser str = parse Nil str... parse Nil ('/':a:'.':r) lowletter a = Lambda [a] (parse Nil r) parse e ('/':a:'.':r) lowletter a = App e (Lambda [a] (parse Nil r)) parse Nil ('/':a:b:r) (lowletter a) && (lowletter b) = Lambda [a] (parse Nil ('/':b:r)) parse e ('/':a:b:r) (lowletter a) && (lowletter b) = App e (Lambda [a] (parse Nil ('/':b:r)))... parse e _ = error ("parsing error"++(show_expr e))
![':r) lowletter a = App e (Lambda [a] (parse Nil r)) parse Nil ('/':a:b:r) (lowletter a) && (lowletter b) =](/docs-images/42/3188529/images/page_12.jpg "Lambda [a] (parse Nil ('/':b:r)) parse e ('/':a:b:r) (lowletter a) && (lowletter b) = App e (Lambda [a]")
13 Vordefinierte Lambda-Ausdrücke (Makros) -- successor function macro 'S' = "(/wxy.x(wxy))" -- arithmetic and logic functions macro '+' = "(/xy.xsy)" -- addition macro '*' = "(/xyz.x(yz))" -- multiplication macro 'T' = "(/ab.a)" -- true macro 'F' = "(/ab.b)" -- false macro '&' = "(/xy.xyf)" -- and macro ' ' = "(/xy.xty)" -- or macro 'N' = "(/x.xft)" -- not macro 'Z' = "(/x.xfnf)" -- compare to 0 macro 'G' = "(/xy.z(xpy))" -- greater or equal as macro '=' = "(/xy.&(gxy)(gyx))" -- equal
14 Vordefinierte Lambda-Ausdrücke (Makros) -- predecessor function macro 'P' = "(/n.nh(/z.z00)f)" macro 'H' = "(/pz.z(s(pt))(pt))" -- predecessor -- (n,n-1) to (n,n+1) -- recursion operator macro 'Y' = "(/y.(/x.y(xx))(/x.y(xx)))" -- factorial macro '!' = "(/rn.zn1(*n(r(pn))))" --factorial -- macros with long names longmacro "FIB" = "(/rn.=n00(=n11(+(r(pn))(r(p(pn))))))" -- fibonacci longmacro "SUM" = "(/rn.zn0(+n(r(pn))))" -- recursive sum
15 ... mehr Hilfsfunktionen Natural numbers macro '0' = "(/s.(/z.z))" macro '1' = "(S0)" macro '2' = "(S1)" macro '3' = "(S2)" macro '4' = "(S3)" macro '5' = "(S4)"... Hausaufgabe?
16 ... Parser-Erweiterung für Macros (3.Version) parse Nil (a:r) symbol a parse e (a:r) symbol a = parse Nil ((macro a)++r) = parse e ((macro a)++r) parse Nil ('{':r) parse e ('{':r)... = parse Nil ((longmacro a)++(tail b)) where (a, b) = (break (=='}') r) = parse e ((longmacro a)++(tail b)) where (a, b) = (break (=='}') r)
17 Anwendungsbeispiel mit Macros: parser "Y{FIB}5" Parser-Erweiterung für Macros App (App (Lambda "y" (App (Lambda "x" (App (Var "y") (App (Var "x") (Var "x")))) (Lambda "x" (App (Var "y") (App (Var "x") (Var "x")))))) (Lambda "r" (Lambda "n" (App (App (App (App (Lambda "x" (Lambda "y" (App (App (Lambda "x" (Lambda "y" (App (App (Var "x") (Var "y")) (Lambda "a" (Lambda "b" (Var "b")))))) (App (App (Lambda "x" (Lambda "y" (App (Lambda "x" (App (App (App (Var "x") (Lambda "a" (Lambda "b" (Var "b")))) (Lambda "x" (App (App (Var "x") (Lambda "a" (Lambda "b" (Var "b")))) (Lambda "a" (Lambda "b" (Var "a")))))) (Lambda "a" (Lambda "b" (Var "b"))))) (App (App (Var "x") (Lambda "n" (App (App (App (Var "n") (Lambda "p" (Lambda "z" (App (App (Var "z") (App (Lambda "w" (Lambda "x" (Lambda "y" (App (Var "x") (App (App (Var "w") (Var "x")) (Var "y")))))) (App (Var "p") (Lambda "a" (Lambda "b" (Var "a")))))) (App (Var "p") (Lambda "a" (Lambda "b" (Var "a")))))))) (Lambda "z" (App (App (Var "z") (Lambda "s" (Lambda "z" (Var "z")))) (Lambda "s" (Lambda "z" (Var "z")))))) (Lambda "a" (Lambda "b" (Var "b")))))) (Var "y"))))) (Var "x")) (Var "y"))) (App (App (Lambda "x" (Lambda "y" (App (Lambda "x" (App (App (App (Var "x") (Lambda "a" (Lambda "b" (Var "b")))) (Lambda "x" (App (App (Var "x") (Lambda "a" (Lambda "b" (Var "b")))) (Lambda "a" (Lambda "b" (Var "a")))))) (Lambda "a" (Lambda "b" (Var "b"))))) (App (App (Var "x") (Lambda "n" (App (App (App (Var "n") (Lambda "p" (Lambda "z" (App (App (Var "z") (App (Lambda "w" (Lambda "x" (Lambda "y" (App (Var "x") (App (App (Var "w") (Var "x")) (Var "y")))))) (App (Var "p") (Lambda "a" (Lambda "b" (Var "a")))))) (App (Var "p") (Lambda "a" (Lambda "b" (Var "a")))))))) (Lambda "z" (App (App (Var "z") (Lambda "s" (Lambda "z" (Var "z")))) (Lambda "s" (Lambda "z" (Var "z")))))) (Lambda "a" (Lambda "b" (Var "b")))))) (Var "y"))))) (Var "y")) (Var "x"))))) (Var "n")) (Lambda "s" (Lambda "z" (Var "z")))) (Lambda "s" (Lambda "z" (Var "z")))) (App (App (App (App (Lambda "x" (Lambda "y" (App (App (Lambda "x" (Lambda "y" (App (App (Var "x") (Var "y")) (Lambda "a" (Lambda "b" (Var "b")))))) (App (App (Lambda "x" (Lambda "y" (App (Lambda "x" (App (App (App (Var "x") (Lambda "a" (Lambda "b" (Var "b")))) (Lambda "x" (App (App (Var "x") (Lambda "a" (Lambda "b" (Var "b")))) (Lambda "a" (Lambda "b" (Var "a")))))) (Lambda "a" (Lambda "b" (Var "b"))))) (App (App (Var "x") (Lambda "n" (App (App (App (Var "n") (Lambda "p" (Lambda "z" (App (App (Var "z") (App (Lambda "w" (Lambda "x" (Lambda "y" (App (Var "x") (App (App (Var "w") (Var "x")) (Var "y")))))) (App (Var "p") (Lambda "a" (Lambda "b" (Var "a")))))) (App (Var "p") (Lambda "a" (Lambda "b" (Var "a")))))))) (Lambda "z" (App (App (Var "z") (Lambda "s" (Lambda "z" (Var "z")))) (Lambda "s" (Lambda "z" (Var "z")))))) (Lambda "a" (Lambda "b" (Var "b")))))) (Var "y"))))) (Var "x")) (Var "y"))) (App (App (Lambda "x" (Lambda "y" (App (Lambda "x" (App (App (App (Var "x") (Lambda "a" (Lambda "b" (Var "b")))) (Lambda "x" (App (App (Var "x") (Lambda "a" (Lambda "b" (Var "b")))) (Lambda "a" (Lambda "b" (Var "a")))))) (Lambda "a" (Lambda "b" (Var "b"))))) (App (App (Var "x") (Lambda "n" (App (App (App (Var "n") (Lambda "p" (Lambda "z" (App (App (Var "z") (App (Lambda "w" (Lambda "x" (Lambda "y" (App (Var "x") (App (App (Var "w") (Var "x")) (Var "y")))))) (App (Var "p") (Lambda "a" (Lambda "b" (Var "a")))))) (App (Var "p") (Lambda "a" (Lambda "b" (Var "a")))))))) (Lambda "z" (App (App (Var "z") (Lambda "s" (Lambda "z" (Var "z")))) (Lambda "s" (Lambda "z" (Var "z")))))) (Lambda "a" (Lambda "b" (Var "b")))))) (Var "y"))))) (Var "y")) (Var "x"))))) (Var "n")) (App (Lambda "w" (Lambda "x" (Lambda "y" (App (Var "x") (App (App (Var "w") (Var "x")) (Var "y")))))) (Lambda "s" (Lambda "z" (Var "z"))))) (App (Lambda "w" (Lambda "x" (Lambda "y" (App (Var "x") (App (App (Var "w") (Var "x")) (Var "y")))))) (Lambda "s" (Lambda "z" (Var "z"))))) (App (App (Lambda "x" (Lambda "y" (App (App (Var "x") (Lambda "w" (Lambda "x" (Lambda "y" (App (Var "x") (App (App (Var "w") (Var "x")) (Var "y"))))))) (Var "y")))) (App (Var "r") (App (Lambda "n" (App (App (App (Var "n") (Lambda "p" (Lambda "z" (App (App (Var "z") (App (Lambda "w" (Lambda "x" (Lambda "y" (App (Var "x") (App (App (Var "w") (Var "x")) (Var "y")))))) (App (Var "p") (Lambda "a" (Lambda "b" (Var "a")))))) (App (Var "p") (Lambda "a" (Lambda "b" (Var "a")))))))) (Lambda "z" (App (App (Var "z") (Lambda "s" (Lambda "z" (Var "z")))) (Lambda "s" (Lambda "z" (Var "z")))))) (Lambda "a" (Lambda "b" (Var "b"))))) (Var "n")))) (App (Var "r") (App (Lambda "n" (App (App (App (Var "n") (Lambda "p" (Lambda "z" (App (App (Var "z") (App (Lambda "w" (Lambda "x" (Lambda "y" (App (Var "x") (App (App (Var "w") (Var "x")) (Var "y")))))) (App (Var "p") (Lambda "a" (Lambda "b" (Var "a")))))) (App (Var "p") (Lambda "a" (Lambda "b" (Var "a")))))))) (Lambda "z" (App (App (Var "z") (Lambda "s" (Lambda "z" (Var "z")))) (Lambda "s" (Lambda "z" (Var "z")))))) (Lambda "a" (Lambda "b" (Var "b"))))) (App (Lambda "n" (App (App (App (Var "n") (Lambda "p" (Lambda "z" (App (App (Var "z") (App (Lambda "w" (Lambda "x" (Lambda "y" (App (Var "x") (App (App (Var "w") (Var "x")) (Var "y")))))) (App (Var "p") (Lambda "a" (Lambda "b" (Var "a")))))) (App (Var "p") (Lambda "a" (Lambda "b" (Var "a")))))))) (Lambda "z" (App (App (Var "z") (Lambda "s" (Lambda "z" (Var "z")))) (Lambda "s" (Lambda "z" (Var "z")))))) (Lambda "a" (Lambda "b" (Var "b"))))) (Var "n")))))))))) (App (Lambda "w" (Lambda "x" (Lambda "y" (App (Var "x") (App (App (Var "w") (Var "x")) (Var "y")))))) (App (Lambda "w" (Lambda "x" (Lambda "y" (App (Var "x") (App (App (Var "w") (Var "x")) (Var "y")))))) (App (Lambda "w" (Lambda "x" (Lambda "y" (App (Var "x") (App (App (Var "w") (Var "x")) (Var "y")))))) (Lambda "s" (Lambda "z" (Var "z")))))) r
Funktionale Programmierung. ALP I Lambda-Kalkül. Teil III SS Prof. Dr. Margarita Esponda. Prof. Dr. Margarita Esponda
ALP I Lambda-Kalkül Teil III SS 2011 Parser Hilfsfunktionen: Die break-funktion ist eine Funktion Höherer Ordnung, die eine Liste beim ersten Vorkommen einer Bedingung in zwei Listen spaltet. break ::
Funktionale Programmierung ALP I. Funktionen höherer Ordnung. Teil 2 SS 2013. Prof. Dr. Margarita Esponda. Prof. Dr.
ALP I Funktionen höherer Ordnung Teil 2 SS 2013 Funktionen höherer Ordnung Nehmen wir an, wir möchten alle Zahlen innerhalb einer Liste miteinander addieren addall:: (Num a) => [a -> a addall [ = 0 addall
Funktionale Programmierung ALP I. λ Kalkül. Teil 2 WS 2012/2013. Prof. Dr. Margarita Esponda. Prof. Dr. Margarita Esponda
ALP I λ Kalkül Teil 2 WS 2012/2013 Lokale Variablennamen Haskell: let x = exp1 in exp2 Lambda: λ exp1. exp2 Einfache Regel: Der Geltungsbereich eines Lambda-Ausdrucks erstreckt sich soweit wie möglich
Interpreter (Hilfsfunktionen)
Interpreter (Hilfsfunktionen) -- Berechnet die Liste der gebundenen Variablen boundlist :: Expr -> [String] boundlist (Var x) = [] boundlist (Lambda x e) = x : (boundlist e) boundlist (App e1 e2) = (boundlist
Funktionale Programmierung ALP I. Kombinatorische Logik (CL) SS Prof. Dr. Margarita Esponda. Prof. Dr. Margarita Esponda
ALP I Kombinatorische Logik (CL) SS 2011 Äquivalenz vieler Berechnungsmodelle Alonzo Church λ-kalkül Kombinatorische Logik Alan Turing Turing-Maschine Mathematische Präzisierung µ-rekursive Funktionen
Funktionale Programmierung ALP I. Die Natur rekursiver Funktionen SS Prof. Dr. Margarita Esponda. Prof. Dr.
ALP I Die Natur rekursiver Funktionen SS 2011 Die Natur rekursiver Funktionen Rekursive Funktionen haben oft folgende allgemeine Form: f :: a -> a f 0 = c f (n+1) = h (f n ) Diese Art der Definitionen
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
ALP I. Funktionale Programmierung
ALP I Funktionale Programmierung Sortieren und Suchen (Teil 1) WS 2012/2013 Suchen 8 False unsortiert 21 4 16 7 19 11 12 7 1 5 27 3 8 False sortiert 2 4 6 7 9 11 12 18 21 24 27 36 Suchen in unsortierten
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
Funktionale Programmierung ALP I. Funktionen höherer Ordnung SS Prof. Dr. Margarita Esponda. Prof. Dr. Margarita Esponda
ALP I SS 2011 Funktionstypen Funktionen haben einen Datentyp, der folgende allgemeine Form hat: functionname :: T 1 -> T 2, wobei T 1, T 2 wiederum beliebige Datentypen sind Beispiel: T 1 T 2 Der Datentyp
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
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
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
Funktionale Programmierung mit Haskell
Funktionale Programmierung mit Haskell Prof. Dr. Hans J. Schneider Lehrstuhl für Programmiersprachen und Programmiermethodik Friedrich-Alexander-Universität Erlangen-Nürnberg Sommersemester 2011 I. Die
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)]
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
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
Praktikum Funktionale Programmierung Teil 1: Lexen und Parsen
Praktikum Funktionale Programmierung Teil 1: Lexen und Parsen Professur für Künstliche Intelligenz und Softwaretechnologie Sommersemester 2009 Überblick Teil 1: Lexen und Parsen Die Sprache LFP +C Professur
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
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
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,
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
Programmieren in Haskell Abstrakte Datentypen
Programmieren in Haskell Abstrakte Datentypen Peter Steffen Universität Bielefeld Technische Fakultät 09.01.2009 1 Programmieren in Haskell Einführung Man unterscheidet zwei Arten von Datentypen: konkrete
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
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
ALP I Induktion und Rekursion
ALP I Induktion und Rekursion WS 2012/2013 Vollständige Induktion (Mafi I) Die Vollständige Induktion ist eine mathematische Beweistechnik, die auf die Menge der natürlichen Zahlen spezialisiert ist. Vorgehensweise:
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
Lösungvorschlag zum Übungsblatt 6: Software-Entwicklung I (WS 2007/08)
Prof. Dr. A. Poetzsch-Heffter Dipl.-Inform. J. O. Blech Dipl.-Inform. M. J. Gawkowski Dipl.-Inform. N. Rauch TU Kaiserslautern Fachbereich Informatik AG Softwaretechnik Lösungvorschlag zum Übungsblatt
Programmieren in Haskell. Abstrakte Datentypen
Programmieren in Haskell Abstrakte Datentypen Einführung Man unterscheidet zwei Arten von Datentypen: konkrete Datentypen: beziehen sich auf eine konkrete Repräsentation in der Sprache. Beispiele: Listen,
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
So schreiben Sie ein Parser-Programm
Universität des Saarlandes Fachrichtung Informatik Programming Systems Lab Prof. Gert Smolka Proseminar Programmiersysteme WS 03/04 Höhere Funktionale Programmierung: Parser-Kombinatoren Matthias Berg
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
Typdeklarationen. Es gibt in Haskell bereits primitive Typen:
Typdeklarationen Es gibt in bereits primitive Typen: Integer: ganze Zahlen, z.b. 1289736781236 Int: ganze Zahlen mit Computerarithmetik, z.b. 123 Double: Fließkommazahlen, z.b. 3.14159 String: Zeichenketten,
Java Einführung Operatoren Kapitel 2 und 3
Java Einführung Operatoren Kapitel 2 und 3 Inhalt dieser Einheit Operatoren (unär, binär, ternär) Rangfolge der Operatoren Zuweisungsoperatoren Vergleichsoperatoren Logische Operatoren 2 Operatoren Abhängig
Programmieren in Haskell
Programmieren in Haskell Programmiermethodik Programmieren in Haskell 1 Was wir heute machen Spezifikation Strukturelle Rekursion Strukturelle Induktion Programmieren in Haskell 2 Spezifikation sort [8,
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 (+)
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
Grundlagen der Programmierung 2. Bäume
Grundlagen der Programmierung 2 Bäume Prof. Dr. Manfred Schmidt-Schauÿ Künstliche Intelligenz und Softwaretechnologie 24. Mai 2006 Graphen Graph: Menge von Knoten undzugehörige (gerichtete oder ungerichtete)
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
[10] Software Transactional Memory in Haskell, Tortenwurf und Aufgabenblatt 7
![[10] Software Transactional Memory in Haskell, Tortenwurf und Aufgabenblatt 7](/thumbs/27/11687557.jpg "[10] Software Transactional Memory in Haskell, Tortenwurf und Aufgabenblatt 7")
Haskell Live [10 Software Transactional Memory in Haskell, Tortenwurf und Aufgabenblatt 7 Bong Min Kim e0327177@student.tuwien.ac.at Christoph Spörk christoph.spoerk@inode.at Bernhard Urban lewurm@gmail.com
1. Probeklausur zu Programmierung 1 (WS 07/08)
Fachschaft Informatikstudiengänge Fachrichtung 6.2 Informatik Das Team der Bremser 1. Probeklausur zu Programmierung 1 (WS 07/08) http://fsinfo.cs.uni-sb.de Name Matrikelnummer Bitte öffnen Sie das Klausurheft
Die LogTrace-Bibliothek
Die LogTrace-Bibliothek Debugging-Hilfsmittel Weiteres Beispiel Motivation void Func() { FunktionLog var( Func );... Func2();... Ausgabe sollte hier sein: >Func > Func2 < Func2 < Func void Func2() { FunktionLog
1 - FortProg ist: [ ] objekt-orientiert; [ ] funktional; [ ] logisch; [ ] manchmal nicht auszuhalten
![1 - FortProg ist: [ ] objekt-orientiert; [ ] funktional; [ ] logisch; [ ] manchmal nicht auszuhalten](/thumbs/62/47356194.jpg "1 - FortProg ist: [ ] objekt-orientiert; [ ] funktional; [ ] logisch; [ ] manchmal nicht auszuhalten")
1 - FortProg ist: [ ] objekt-orientiert; [ ] funktional; [ ] logisch; [ ] manchmal nicht auszuhalten Java-1. a), e) Java-2. --- gestrichen --- Java-3. keine Antwort ist richtig Java-4. a) Java-5. a), b)
ALP I Turing-Maschine
ALP I Turing-Maschine Simulator WS 2012/2013 Haskell-Implementierung eines TM-Simulators module Turing (sim, start) data Move = L R S deriving (Show, Eq) type State = Int type Input = Char type Output
Einführung in die Informatik 2
Technische Universität München Fakultät für Informatik Prof. Tobias Nipkow, Ph.D. Lars Noschinski, Dr. Jasmin Blanchette, Dmitriy Traytel Wintersemester 2012/13 Lösungsblatt Endklausur 9. Februar 2013
Syntaktische Analyse (Parsen)
Syntaktische Analyse (Parsen) Gegeben: eine kontextfreie Grammatik G und ein String w. Fragen: Vorgehen: gehört w zu L(G)? Welche Bedeutung hat w? Konstruiere Herleitungsbaum zu w P raktische Informatik
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:
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
Programmierung und Modellierung
Programmierung und Modellierung Terme, Suchbäume und Pattern Matching Martin Wirsing in Zusammenarbeit mit Moritz Hammer SS 2009 2 Inhalt Kap. 7 Benutzerdefinierte Datentypen 7. Binärer Suchbaum 8. Anwendung:
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
Adressen. Praktikum Funktionale Programmierung Organisation und Überblick. Termine. Studienleistung
Adressen Adressen, Termine Studienleistung Praktikum Funktionale Programmierung Organisation und Überblick Dr. David Sabel Büro und Email Raum 216, Robert-Mayer-Str. 11-15 sabel@ki.informatik.uni-frankfurt.de
Felder. November 5, 2014
Felder Universität Bielefeld AG Praktische Informatik November 5, 2014 Felder: Datenstrukturen mit konstantem Zugriff Felder nennt man auch, Vektoren, Matrizen,... Konstanter Zugriff heisst: Zugriff auf
Programmieren in Haskell. Stefan Janssen. Strukturelle Rekursion. Universität Bielefeld AG Praktische Informatik. 10.
Universität Bielefeld AG Praktische Informatik 10. Dezember 2014 Wiederholung: Schema: f :: [σ] -> τ f [] = e 1 f (a : as) = e 2 where s = f as wobei e 1 und e 2 Ausdrücke vom Typ τ sind und e 2 die Variablen
1. Probeklausur (Lösung) zu Programmierung 1 (WS 07/08)
Fachschaft Informatikstudiengänge Fachrichtung 6.2 Informatik Das Team der Bremser 1. Probeklausur (Lösung) zu Programmierung 1 (WS 07/08) http://fsinfo.cs.uni-sb.de Name Matrikelnummer Bitte öffnen Sie
Einführung in die Informatik 2
Technische Universität München Fakultät für Informatik Prof. Tobias Nipkow, Ph.D. Manuel Eberl, Lars Hupel, Lars Noschinski Wintersemester 2014/15 Lösungsblatt Endklausur 13. Februar 2015 Einführung in
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
Scriptless JSP. Motivation. Expression Language (EL) JSP Standard Tag Library (JSTL)
Scriptless JSP Motivation Expression Language (EL) JSP Standard Tag Library (JSTL) Pratikum SWE 2 M. Löberbauer, T. Kotzmann, H. Prähofer 1 Motivation: EL public class Car { public Engine getengine() {}
Funktionale Programmierung mit Haskell
Funktionale Programmierung mit Haskell Prof. Dr. Hans J. Schneider Lehrstuhl für Programmiersprachen und Programmiermethodik Friedrich-Alexander-Universität Erlangen-Nürnberg Sommersemester 2011 I. Die
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
Kapitel 7 des Buches, von Java-Selbstbau nach Scala-Library portiert. 2014-11-14 Christoph Knabe
Anfragen für Listen Kapitel 7 des Buches, von Java-Selbstbau nach Scala-Library portiert. 2014-11-14 Christoph Knabe 1 MapReduce-Verfahren Google u.a. verwenden Map-Reduce-Verfahren zur Verarbeitung riesiger
Funktionale Programmierung und Typtheorie
Funktionale Programmierung und Typtheorie 5. Fortgeschrittene Konzepte 5.1 Komprehensionen 5.2 Partielle Applikationen 5.3 Strikte und nichtstrikte Funktionen 5.4 Unendliche Datenstrukturen und verzögerte
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
Tutoraufgabe 1 (Datenstrukturen in Haskell):
Prof. aa Dr. J. Giesl Programmierung WS12/13 M. Brockschmidt, F. Emmes, C. Otto, T. Ströder Allgemeine Die Hausaufgaben sollen in Gruppen von je 2 Studierenden aus der gleichen Kleingruppenübung (Tutorium)
Funktionale Programmierung mit Haskell
Funktionale Programmierung mit Haskell Prof. Dr. Hans J. Schneider Lehrstuhl für Programmiersprachen und Programmiermethodik Friedrich-Alexander-Universität Erlangen-Nürnberg Sommersemester 2011 I. Die
Einführung Datentypen Verzweigung Schleifen Funktionen Dynamische Datenstrukturen. Java Crashkurs. Kim-Manuel Klein (kmk@informatik.uni-kiel.
Java Crashkurs Kim-Manuel Klein (kmk@informatik.uni-kiel.de) May 7, 2015 Quellen und Editoren Internet Tutorial: z.b. http://www.java-tutorial.org Editoren Normaler Texteditor (Gedit, Scite oder ähnliche)
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
Outline. 1 Einleitung. 2 Einführung in C. 3 Fortgeschrittenes in C. 4 Einführung in Emacs Lisp. 5 Einführung in Prolog. 6 Formale Semantik
Outline 1 Einleitung 2 Einführung in C 3 Fortgeschrittenes in C 4 Einführung in Emacs Lisp 5 Einführung in Prolog 6 Formale Semantik Lisp 1958 von John McCarthy erfunden Funktionales Programmierparadigma
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
Abstrakte Datentypen II
7 Abstrakte Datentypen II Nachdem wir im letzten Kapitel die grundlegenden Eigenschaften abstrakter Datentypen beschrieben haben und dabei eher einfache Beispiele betrachtet haben, soll es in diesem Kapitel
WS 2011/2012. Georg Sauthoff November 2011
WS 2011/2012 Georg 1 AG Praktische Informatik 22. November 2011 1 gsauthof@techfak.uni-bielefeld.de Vorstellung der abgaben aus den Tutorien. Sieb-Beispiel Siehe Tafel (Auswertungsbeispiel) Sieb-Beispiel
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
Rainer Stropek cubido. Baumschule Expression Trees in C#, CLR und DLR
Rainer Stropek cubido Baumschule Expression Trees in C#, CLR und DLR Inhalt Als Anwendungsentwickler kommt man selten mit Expression Trees in Berührung. Sie sind ein Implementierungsdetail von LINQ. Ihre
Programmieren in Haskell Felder (Arrays)
Programmieren in Haskell Felder (Arrays) Peter Steffen Universität Bielefeld Technische Fakultät 05.12.2008 1 Programmieren in Haskell Quadratzahlen 0 1 2 3 n 0 1 4 9 n 2 squareslist :: Integral a => [a]
ROHRE FUER HOHE TEMPERATUREN ASTM A 106
ROHRE FUER HOHE TEMPERATUREN ASTM A 106 1/8 10,300 1,240 0,280 10 1/8 10,300 1,450 0,320 30 1/8 10,300 1,730 0,370 STD 40 1/8 10,300 2,410 0,470 XS 80 1/4 13,700 1,650 0,490 10 1/4 13,700 1,850 0,540 30
Programmieren in Haskell Felder
Programmieren in Haskell Felder Peter Steffen Universität Bielefeld Technische Fakultät 01.12.2010 1 Programmieren in Haskell Was wir heute machen Beispiel Die Typklasse Ix Felder in Haskell Funktionstabellierung
Zusammenfassung des Handzettels für Programmieren in C
Zusammenfassung des Handzettels für Programmieren in C In der handschriftlichen Kopie werden mehr Abkürzungen verwendet. Alles Grün markierte dient zum lernen und wird nicht auf den Handzettel übertragen.
XML Verarbeitung mit einer in Haskell eingebetteten DSL. Manuel Ohlendorf (xi2079)
XML Verarbeitung mit einer in Haskell eingebetteten DSL Manuel Ohlendorf (xi2079) 2.0.200 Manuel Ohlendorf Übersicht 1 2 Einführung Datenstruktur Verarbeitung Vergleich mit anderen Verfahren Fazit 2 Übersicht
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
Ich liebe Java && Ich liebe C# Rolf Borst
Ich liebe Java && Ich liebe C# Rolf Borst Java oder C#? Einführung public class Einfuehrung { private int gesamtzahl = 0; /* Ermittelt die Anzahl der geraden und durch drei teilbaren Zahlen */ public String
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
Proseminar: Fortgeschrittene Programmierung 1
Proseminar: Fortgeschrittene Programmierung 1 Parsen and Backtracking WS 2007 2008 Christian Wawrzinek Übersicht 2 1.Grammatiken 2. Parser 3.Backtracking 4.Kombinatoren Übersicht 3 1.Grammatiken 2. Parser
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:
8 Prozeduren als Daten
8 Prozeduren als Daten Prozeduren als Parameter Prozeduren als Ergebnisse Prozeduren höherer Ordnung (higher-order procedures) Programmierung höherer Ordnung Verwendung als Abstraktionsmittel 8.1 Prozeduren
Programmierung WS 2002 / 03: Musterlösung zum 12. Übungsblatt
U N S A R I V E R S A V I E I T A S N I S S Programmierung WS 2002 / 03: Musterlösung zum 12. Übungsblatt Prof. Dr. Gert Smolka, Dipl.-Inform. Thorsten Brunklaus Aufgabe 12.1: Syntaxbäume (10 = 2 + 2 +
ALP I Turing-Maschine
ALP I Turing-Maschine Teil I SS 2011 Äquivalenz vieler Berechnungsmodelle Alonzo Church λ-kalkül Kombinatorische Logik Alan Turing Turing-Maschine Mathematische Präzisierung Effektiv Berechenbare Funktionen
Modul 122 VBA Scribt.docx
Modul 122 VBA-Scribt 1/5 1 Entwicklungsumgebung - ALT + F11 VBA-Entwicklungsumgebung öffnen 2 Prozeduren (Sub-Prozeduren) Eine Prozedur besteht aus folgenden Bestandteilen: [Private Public] Sub subname([byval
orgexterndoc31 Inhaltsverzeichnis Einleitung... 1 Installation... 3 Grundinstallation... 3 Installation pro Arbeitsplatz... 6 Lizenzierung... 7 Benutzung Einzeldokument... 9 1. Möglichkeit:... 9 2. Möglichkeit...
2.2.1 Algebraische Spezifikation (Fortsetzung)
2.2.1 Algebraische Spezifikation (Fortsetzung) Algebraische Spezifikation: Mengen Types Set, Bool, t Signature > creates :: Eq t => Set t > isempty :: Eq t => Set t -> Bool > insert :: Eq t => t -> Set
WS 2011/2012. Georg Sauthoff 1. October 18, 2011
in in WS 2011/2012 Georg 1 AG Praktische Informatik October 18, 2011 1 gsauthof@techfak.uni-bielefeld.de Neue Übungsgruppen in neue Übungsgruppen neue Tutoren Sprechstunden in GZI-Arbeitsraum (V2-240)
Grundlagen der Programmierung 2 (Comp-C)
Grundlagen der Programmierung 2 (Comp-C) Prof. Dr. Manfred Schmidt-Schauÿ Künstliche Intelligenz und Softwaretechnologie 25. Juni 2008 Syntaktische Analyse (Parsen) Gegeben: eine kontextfreie Grammatik
Diana Lange. Generative Gestaltung Operatoren
Diana Lange Generative Gestaltung Operatoren Begriffserklärung Verknüpfungsvorschrift im Rahmen logischer Kalküle. Quelle: google Operatoren sind Zeichen, die mit einer bestimmten Bedeutung versehen sind.
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. 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
2.5 Listen. Kurzschreibweise: [42; 0; 16] Listen werden mithilfe von [] und :: konstruiert.
![2.5 Listen. Kurzschreibweise: [42; 0; 16] Listen werden mithilfe von [] und :: konstruiert.](/thumbs/55/37072779.jpg "2.5 Listen. Kurzschreibweise: [42; 0; 16] Listen werden mithilfe von [] und :: konstruiert.")
2.5 Listen Listen werden mithilfe von [] und :: konstruiert. Kurzschreibweise: [42; 0; 16] # let mt = [];; val mt : a list = [] # let l1 = 1::mt;; val l1 : int list = [1] # let l = [1;2;3];; val l : int
C# 2000 Expression Beispielcodes für Konsolen- und Formularanwendung
C# 2000 Expression Beispielcodes für Konsolen- und Formularanwendung 1. "Hai!" [Konsolenanwendung] Console.WriteLine("Hai, wie geht's?"); 2. Muktiplikation mit sich selbst [Konsolenanwendung] // Ausgabe
Angewandte Mathematik und Programmierung
Angewandte Mathematik und Programmierung Einführung in das Konzept der objektorientierten Anwendungen zu mathematischen Rechnens WS 2013/14 Operatoren Operatoren führen Aktionen mit Operanden aus. Der
MVC-II Schematische Aufzeichnung Des MVC (model-2), bei dem zwei Modelle zum Zuge kommen:
MVC im Web-Context bedeutet, dass es einen Controller gibt, welcher verschiedene Views kommandiert. Informationen an die Views kann der Controller per Models übergeben. Die Komplexität und das Multithreading
BTree.dll - Balancierte und verkettete Bäume. Ecofor. BTree.dll. Realisiert mit Microsoft Visual Studio 16.04.2015 1/9
BTree.dll Realisiert mit Microsoft Visual Studio 16.04.2015 1/9 INHALT 1. Allgemein... 3 2. Class BTree1 (balanciert)... 3 3. Class BTree2 (balanciert und verkettet)... 4 4. Beschreibung BTree1 und BTree2...
Funktionales Programmieren in Python
Wintersemester 2008/2009 1 Funktionen sind Objekte 2 lambda Funktionen 3 apply 4 map 5 zip 6 filter 7 reduce 8 List Comprehension Funktionales Programmieren Wer nicht funktional programmiert, programmiert