Moved to 1415 directoryHEADmaster

11 files changed, 0 insertions, 468 deletions

diff --git a/fp1/week3/camil/.gitignore b/fp1/week3/camil/.gitignore
deleted file mode 100644
index 341d5f8..0000000
--- a/fp1/week3/camil/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-/Clean System Files/
-StdStack
diff --git a/fp1/week3/camil/StdSortList.dcl b/fp1/week3/camil/StdSortList.dcl
deleted file mode 100644
index 556dfc0..0000000
--- a/fp1/week3/camil/StdSortList.dcl
+++ /dev/null
@@ -1,18 +0,0 @@
-definition module StdSortList

-

-import StdClass

-

-::  SortList a

-

-newSortList   :: SortList a                   | zero a         // lege gesorteerde lijst

-memberSort    :: a (SortList a) -> Bool       | Eq, Ord a      // is element van

-insertSort    :: a (SortList a) -> SortList a | Ord a          // voeg element toe

-removeFirst   :: a (SortList a) -> SortList a | Eq, Ord, zero a      // verwijder eerste voorkomen

-removeAll     :: a (SortList a) -> SortList a | Eq, Ord, zero a      // verwijder alle voorkomens

-elements      ::   (SortList a) -> [a]                         // geef alle elementen

-count         ::   (SortList a) -> Int                         // aantal elementen

-

-minimum       ::   (SortList a) -> a                           // huidige minimum waarde

-maximum       ::   (SortList a) -> a                           // huidige maximum waarde

-

-mergeSortList :: (SortList a) (SortList a) -> SortList a | Eq, Ord, zero a // meng gesorteerde lijsten

diff --git a/fp1/week3/camil/StdSortList.icl b/fp1/week3/camil/StdSortList.icl
deleted file mode 100644
index 21778bd..0000000
--- a/fp1/week3/camil/StdSortList.icl
+++ /dev/null
@@ -1,64 +0,0 @@
-// Ik kreeg het alleen werkend door de .dcl ook aan te passen. 

-// Met een record dat het maximum bijhoudt moet je er namelijk vanuit kunnen gaan dat zero gedefinieerd is voor type a.

-

-implementation module StdSortList

-

-import StdEnv

-

-::  SortList a = {list :: [a], max :: a}

-

-newSortList   :: (SortList a) | zero a

-newSortList = {list=[], max=zero}

-

-memberSort    :: a (SortList a) -> Bool       | Eq, Ord a      // is element van

-memberSort _ {list=[],max=_} = False

-memberSort m l

-    | minimum l == m = True

-    | minimum l > m = False

-    | otherwise = memberSort m {list=(tl l.list),max=l.max}

-

-insertSort    :: a (SortList a) -> SortList a | Ord a          // voeg element toe

-insertSort m l = insertSort` {list=[],max=l.max} m l 

-where 

-    insertSort` :: (SortList a) a (SortList a) -> (SortList a) | Ord a

-    insertSort` l1 m l2

-        | count l2 == 0 = {list=l1.list ++ [m], max=m}

-        | minimum l2 >= m = {list=l1.list ++ [m] ++ l2.list, max=l2.max}

-        | otherwise = insertSort` {list=l1.list ++ [hd l2.list], max=hd l2.list} m {list=(tl l2.list), max=l2.max}

-

-removeFirst   :: a (SortList a) -> SortList a | Eq, Ord, zero a      // verwijder eerste voorkomen

-removeFirst m l = removeFirst` newSortList m l

-where

-    removeFirst` :: (SortList a) a (SortList a) -> (SortList a) | Eq, Ord a

-    removeFirst` l1 m l2

-        | count l2 == 0 = l1

-        | minimum l2 > m = {list=l1.list ++ l2.list, max=l2.max}

-        | minimum l2 == m && count l2 == 1 = {list=l1.list ++ tl l2.list, max=l1.max}

-        | minimum l2 == m = {list=l1.list ++ tl l2.list, max=l2.max}

-        | otherwise = removeFirst` {list=(l1.list ++ [hd l2.list]),max=hd l2.list} m {list=(tl l2.list), max=l2.max}

-

-removeAll     :: a (SortList a) -> SortList a | Eq, Ord, zero a      // verwijder alle voorkomens

-removeAll m l = removeAll` newSortList m l

-where

-    removeAll` :: (SortList a) a (SortList a) -> (SortList a) | Eq, Ord a

-    removeAll` l1 m l2

-        | count l2 == 0 = l1

-        | minimum l2 > m = {list=l1.list ++ l2.list, max=l2.max}

-        | minimum l2 == m = removeAll` l1 m {list=tl l2.list, max=l2.max}

-        | otherwise = removeAll` {list=l1.list ++ [hd l2.list], max=hd l2.list} m {list=tl l2.list,max=l2.max}

-

-elements      ::   (SortList a) -> [a]                         // geef alle elementen

-elements l = l.list

-

-count         ::   (SortList a) -> Int                         // aantal elementen

-count l = length l.list

-

-minimum       ::   (SortList a) -> a                           // huidige minimum waarde

-minimum l = hd l.list

-

-maximum       ::   (SortList a) -> a                           // huidige maximum waarde

-maximum l = l.max

-

-mergeSortList :: (SortList a) (SortList a) -> SortList a | Eq, Ord, zero a // meng gesorteerde lijsten

-mergeSortList l1 {list=[],max=_} = l1

-mergeSortList l1 l2 = mergeSortList (insertSort (hd l2.list) l1) {list=tl l2.list,max=l2.max}

diff --git a/fp1/week3/camil/StdSortListTest.icl b/fp1/week3/camil/StdSortListTest.icl
deleted file mode 100644
index 411f7ca..0000000
--- a/fp1/week3/camil/StdSortListTest.icl
+++ /dev/null
@@ -1,107 +0,0 @@
-module StdSortListTest

-

-/*	Test module StdSortList

-	Voor werken met Gast: 

-		(*) gebruik Environment 'Gast'

-		(*) zet Project Options op 'Basic Values Only' en '16M' Maximum Heap Size.

-*/

-

-import gast

-import GenLexOrd

-import StdSortList

-

-Start = testn 10000 

-		(\n` n2` m -> let	n  = lst2slst (cast [A,B,C] n` )

-							n2 = lst2slst (cast [A,B,C] n2`) 

-			           in 

-							leeg_is_leeg                   /\

-							count_matches_elems     n      /\

-							is_sorted_elems         n      /\

-							member_is_member        n m    /\

-							member_na_insert        n m    /\

-							member_na_remove        n m    /\

-							insert_remove_invariant n m    /\

-							minimum_property        n      /\

-							maximum_property        n      /\

-							merge_additive          n n2   /\

-							merge_member            n n2 m /\

-							True

-		)

-

-:: Enum = A | B | C 

-

-derive bimap []

-derive ggen Enum

-derive genShow Enum

-derive gEq Enum

-derive gLexOrd Enum

-instance == Enum where (==) x y = gEq{|*|} x y

-instance <  Enum where  (<) x y = gEq{|*|} (gLexOrd{|*|} x y) LT

-

-// clean should have something like this!

-cast :: a a -> a

-cast _ x = x

-

-leeg_is_leeg :: Property

-leeg_is_leeg 

- = name "leeg_is_leeg"

-    (count newSortList == 0)

-

-count_matches_elems :: (SortList a) -> Property | Eq, Ord a

-count_matches_elems n 

- = name "count_matches_elems" 

-    (length (elements n) == count n)

-

-is_sorted_elems :: (SortList a) -> Property | Eq, Ord a

-is_sorted_elems n

- = name "is_sorted_elems"

-    (isSorted (elements n))

-    where isSorted lst = and [ x<=y \\ x<-lst & y<-tl lst ]

-

-member_is_member :: (SortList a) a -> Property | Eq, Ord a

-member_is_member lst e

- = name "member_is_member"

-    ((isMember e (elements lst)) <==> (memberSort e lst))

-

-member_na_insert :: (SortList a) a -> Property | Eq, Ord a

-member_na_insert lst e

- = name "member_na_insert"

-    (memberSort e (insertSort e lst))

-

-member_na_remove :: (SortList a) a -> Property | Eq, Ord a

-member_na_remove lst e

- = name "member_na_remove"

-    (not (memberSort e (removeAll e lst)))

-

-insert_remove_invariant :: (SortList a) a -> Property | Eq, Ord a

-insert_remove_invariant lst e

- = name "insert_remove_invariant"

-    (memberSort e lst <==> memberSort e lst`)

-    where lst` = removeFirst e (insertSort e lst)

-

-minimum_property :: (SortList a) -> Property | Eq,Ord a

-minimum_property n

- = name "minimum_property"

-    (count n > 0 ==> (memberSort min n /\ all ((<=) min) (elements n)))

-    where min = minimum n

-

-maximum_property :: (SortList a) -> Property | Eq,Ord a

-maximum_property n

- = name "maximum_property"

-    (count n > 0 ==> (memberSort max n /\ all ((>=) max) (elements n)))

-    where max = maximum n

-

-merge_member :: (SortList a) (SortList a) a -> Property | Eq,Ord a

-merge_member n m e

- = name "merge_member"

-	(memberSort e nm <==> (memberSort e n \/ memberSort e m))

-	where nm = mergeSortList n m

-

-merge_additive :: (SortList a) (SortList a) -> Property | Eq,Ord a

-merge_additive n m 

- = name "merge_additive"

-	(count n + count m == count nm)

-	where nm = mergeSortList n m

-

-lst2slst :: [a] -> SortList a | Eq,Ord a

-lst2slst xs = seq (map insertSort xs) newSortList

diff --git a/fp1/week3/camil/StdStack.dcl b/fp1/week3/camil/StdStack.dcl
deleted file mode 100644
index 8c861a1..0000000
--- a/fp1/week3/camil/StdStack.dcl
+++ /dev/null
@@ -1,13 +0,0 @@
-definition module StdStack

-

-:: Stack a

-

-newStack :: Stack a                        // lege stack

-push     ::  a  (Stack a) -> Stack a       // plaats nieuw element bovenop de stack

-pushes   :: [a] (Stack a) -> Stack a       // plaats elementen achtereenvolgens bovenop stack

-pop      ::     (Stack a) -> Stack a       // haal top element van stack

-popn     :: Int (Stack a) -> Stack a       // haal bovenste $n$ top elementen van stack

-top      ::     (Stack a) -> a             // geef top element van stack

-topn     :: Int (Stack a) -> [a]           // geef bovenste $n$ top elementen van stack

-elements ::     (Stack a) -> [a]           // geef alle elementen van stack

-count    ::     (Stack a) -> Int           // tel aantal elementen in stack

diff --git a/fp1/week3/camil/StdStack.icl b/fp1/week3/camil/StdStack.icl
deleted file mode 100644
index dd51a94..0000000
--- a/fp1/week3/camil/StdStack.icl
+++ /dev/null
@@ -1,66 +0,0 @@
-implementation module StdStack

-

-import StdEnv

-import StdList

-

-:: Stack a :== [a]

-

-newStack :: (Stack a)

-newStack = []

-

-push :: a (Stack a) -> (Stack a)

-push a s = [a] ++ s

-

-pop :: (Stack a) -> (Stack a)

-pop [a:s] = s

-pop [] = []

-

-popn :: Int (Stack a) -> (Stack a)

-popn 0 s = s

-popn n s = popn (n-1) (pop s)

-

-pushes :: [a] (Stack a) -> (Stack a)

-pushes [] s = s

-pushes a s = pushes (tl a) (push (hd a) s)

-

-top :: (Stack a) -> a

-top [] = abort "`top s` with s = []"

-top s = hd s

-

-topn :: Int (Stack a) -> [a]

-topn n s

-	| n > length s = abort "`topn n s` with n > length s"

-	| otherwise = take n s

-

-count :: (Stack a) -> Int

-count s = length s

-

-elements :: (Stack a) -> [a]

-elements s = s

-

-Start  = ( "s0 = newStack = ",        s0,'\n'

-         , "s1 = push 1 s0 = ",       s1,'\n'

-         , "s2 = pushes [2..5] s1 = ",s2,'\n'

-         , "s3 = pop s2 = ",          s3,'\n'

-         , "s4 = popn 3 s3 = ",       s4,'\n'

-         , "s5 = top s4 = ",          s5,'\n'

-         , "s6 = topn 3 s2 = ",       s6,'\n'

-         , "s7 = elements s2 = ",     s7,'\n'

-//	 , "s8 = push 10 s1 = ",      s8,'\n'

-//	 , "s9 = popn 10 s8 = ",      s9,'\n'

-//	 , "sa = topn 5 s4 = ",       sa,'\n'

-//	 , "sb = top s0 = ",          sb,'\n'

-         )

-where

-	s0 = newStack

-	s1 = push 1 s0

-	s2 = pushes [2..5] s1

-	s3 = pop s2

-	s4 = popn 3 s3

-	s5 = top s4

-	s6 = topn 3 s2

-	s7 = elements s2

-//	s8 = push 10 s1

-//	s9 = popn 10 s8

-//	sa = topn 5 s4

-//	sb = top s0

diff --git a/fp1/week3/camil/StdStackTest.icl b/fp1/week3/camil/StdStackTest.icl
deleted file mode 100644
index 8127f53..0000000
--- a/fp1/week3/camil/StdStackTest.icl
+++ /dev/null
@@ -1,60 +0,0 @@
-module StdStackTest

-

-/*	Test module StdStack

-	Voor werken met Gast: 

-		(*) gebruik Environment 'Gast'

-		(*) zet Project Options op 'Basic Values Only' en '2M' Maximum Heap Size

-*/

-

-import gast

-import StdStack

-

-Start

-							= testn 1000

-								(\x n ->

-								   newStack_is_empty               /\

-								   stack_is_reverse        n       /\

-								   pop_empty_is_ok                 /\

-								   top_na_push             n x     /\

-								   pop_na_push               x     /\

-								   count_counts            n x     /\

-								   pop_maakt_stack_korter  n       /\

-								   True

-								)

-

-newStack_is_empty			:: Property

-newStack_is_empty			= name "newStack_is_empty" (isEmpty (elements empty))

-

-stack_is_reverse			:: Int -> Property

-stack_is_reverse n			= name "stack_is_reverse"

-							  (elements (pushes [1..n`] newStack) == reverse [1..n`])

-where            n`			= min (abs n) 100

-

-pop_empty_is_ok				:: Property

-pop_empty_is_ok				= name "pop_empty_is_ok" (count (pop empty) == 0)

-

-top_na_push					:: Int Int -> Property

-top_na_push x n				= name "top_na_push"

-							  (top (push x (pushes [1..n`] newStack)) == x)

-where         n`			= min (abs n) 100

-

-pop_na_push					:: Int -> Property

-pop_na_push a				= name "pop_na_push"

-                              (top (pop (pop (pushes [a,b,c] newStack))) == a)

-where b						= a + a + one

-      c						= b + a + one

-

-count_counts				:: Int Int -> Property

-count_counts n x			= name "count_counts"

-							  (length (elements stack) == count stack)

-where stack					= pushes [1..n`] newStack

-      n`					= min (abs n) 100

-

-pop_maakt_stack_korter		:: Int -> Property

-pop_maakt_stack_korter n	= name "pop_maakt_stack_korter"

-							  (count stack == 0 || count (pop stack) == count stack - 1)

-where stack					= pushes [1..n`] newStack

-	  n`					= min (abs n) 100

-

-empty						:: Stack Int

-empty						= newStack

diff --git a/fp1/week3/mart/StdSortList.dcl b/fp1/week3/mart/StdSortList.dcl
deleted file mode 100644
index 46bd238..0000000
--- a/fp1/week3/mart/StdSortList.dcl
+++ /dev/null
@@ -1,18 +0,0 @@
-definition module StdSortList

-

-import StdClass

-

-::  SortList a

-

-newSortList   :: SortList a                                    // lege gesorteerde lijst

-memberSort    :: a (SortList a) -> Bool       | Eq, Ord a      // is element van

-insertSort    :: a (SortList a) -> SortList a | Ord a          // voeg element toe

-removeFirst   :: a (SortList a) -> SortList a | Eq, Ord a      // verwijder eerste voorkomen

-removeAll     :: a (SortList a) -> SortList a | Eq, Ord a      // verwijder alle voorkomens

-elements      ::   (SortList a) -> [a]                         // geef alle elementen

-count         ::   (SortList a) -> Int                         // aantal elementen

-

-minimum       ::   (SortList a) -> a                           // huidige minimum waarde

-maximum       ::   (SortList a) -> a                           // huidige maximum waarde

-

-mergeSortList :: (SortList a) (SortList a) -> SortList a | Eq, Ord a // meng gesorteerde lijsten

diff --git a/fp1/week3/mart/StdSortList.icl b/fp1/week3/mart/StdSortList.icl
deleted file mode 100644
index db71a36..0000000
--- a/fp1/week3/mart/StdSortList.icl
+++ /dev/null
@@ -1,50 +0,0 @@
-implementation module StdSortList

-

-import StdEnv

-

-::  SortList a :== ([a], a)

-

-newSortList :: SortList a

-newSortList = ([], abort "Empty list")

-

-memberSort :: a (SortList a) -> Bool | Eq, Ord a

-memberSort e ([], y) = y

-memberSort e ([x:xs], y)

-| e == x = True

-| e > x = False

-| otherwise = memberSort e (xs, y)

-

-insertSort :: a (SortList a) -> SortList a | Ord a

-insertSort e ([], y) = ([e], e)

-insertSort e ([x:xs], y)

-| e <= x = ([e:x:xs], y)

-| otherwise = ([x:fst result], snd result)

-	where result = insertSort e (xs, y)

-

-removeFirst :: a (SortList a) -> SortList a | Eq, Ord a

-removeFirst e ([], y) = y

-removeFirst e ([e], e) = newSortList

-removeFirst e ([x:xs], y)

-| e == x = ([xs], y)

-removeFirst _ _ = abort ""

-

-removeAll :: a (SortList a) -> SortList a | Eq, Ord a

-removeAll _ _ = abort ""

-

-elements :: (SortList a) -> [a]

-elements _ = abort ""

-

-count :: (SortList a) -> Int

-count _ = abort ""

-

-minimum :: (SortList a) -> a

-minimum _ = abort ""

-

-maximum :: (SortList a) -> a

-maximum _ = abort ""

-

-mergeSortList :: (SortList a) (SortList b) -> (SortList a)

-mergeSortList _ _ = abort ""

-

-Start :: String

-Start = newSortList

diff --git a/fp1/week3/mart/StdStack.dcl b/fp1/week3/mart/StdStack.dcl
deleted file mode 100644
index 8c861a1..0000000
--- a/fp1/week3/mart/StdStack.dcl
+++ /dev/null
@@ -1,13 +0,0 @@
-definition module StdStack

-

-:: Stack a

-

-newStack :: Stack a                        // lege stack

-push     ::  a  (Stack a) -> Stack a       // plaats nieuw element bovenop de stack

-pushes   :: [a] (Stack a) -> Stack a       // plaats elementen achtereenvolgens bovenop stack

-pop      ::     (Stack a) -> Stack a       // haal top element van stack

-popn     :: Int (Stack a) -> Stack a       // haal bovenste $n$ top elementen van stack

-top      ::     (Stack a) -> a             // geef top element van stack

-topn     :: Int (Stack a) -> [a]           // geef bovenste $n$ top elementen van stack

-elements ::     (Stack a) -> [a]           // geef alle elementen van stack

-count    ::     (Stack a) -> Int           // tel aantal elementen in stack

diff --git a/fp1/week3/mart/StdStack.icl b/fp1/week3/mart/StdStack.icl
deleted file mode 100644
index 13220e1..0000000
--- a/fp1/week3/mart/StdStack.icl
+++ /dev/null
@@ -1,57 +0,0 @@
-implementation module StdStack

-

-import StdEnv

-

-:: Stack a = Stack [a]

-

-newStack :: Stack a

-newStack = Stack []

-

-push     ::  a  (Stack a) -> Stack a

-push x (Stack xs) = Stack [x:xs]

-

-pushes   :: [a] (Stack a) -> Stack a

-pushes [] (Stack s) = Stack s

-pushes [x:xs] (Stack s) = pushes xs (push x (Stack s))

-

-pop      ::     (Stack a) -> Stack a

-pop (Stack []) = abort "Can't pop from empty stack..."

-pop (Stack [x:xs]) = Stack xs

-

-popn     :: Int (Stack a) -> Stack a

-popn 0 s = s

-popn n s = popn (n-1) (pop s)

-

-top      ::     (Stack a) -> a

-top (Stack []) = abort "Can't give top of empty stack..."

-top (Stack [x:_]) = x

-

-topn     :: Int (Stack a) -> [a]

-topn 0 _ = []

-topn n x = [top x:topn (n-1) (pop x)]

-

-elements ::     (Stack a) -> [a]

-elements (Stack s) = s

-

-count    ::     (Stack a) -> Int

-count (Stack []) = 0

-count (Stack [_:xs]) = 1 + count (Stack xs)

-

-Start  = ( "s0 = newStack = ",        s0,'\n'

-         , "s1 = push 1 s0 = ",       s1,'\n'

-         , "s2 = pushes [2..5] s1 = ",s2,'\n'

-         , "s3 = pop s2 = ",          s3,'\n'

-         , "s4 = popn 3 s3 = ",       s4,'\n'

-         , "s5 = top s4 = ",          s5,'\n'

-         , "s6 = topn 3 s2 = ",       s6,'\n'

-         , "s7 = elements s2 = ",     s7,'\n'

-         )

-where

-	s0 = newStack

-	s1 = push 1 s0

-	s2 = pushes [2..5] s1

-	s3 = pop s2

-	s4 = popn 3 s3

-	s5 = top s4

-	s6 = topn 3 s2

-	s7 = elements s2