Add exercises for pp lecture 2 and 3

1 files changed, 99 insertions, 0 deletions

diff --git a/sem7/pp/lec2.scm b/sem7/pp/lec2.scm
new file mode 100644
index 0000000..72d6904
--- /dev/null
+++ b/sem7/pp/lec2.scm
@@ -0,0 +1,99 @@
+;; This is not meant do be, please do not use define-syntax too much.
+;; Just leaving this here to remember how it works.
+(define-syntax lambda-curry
+  (syntax-rules ()
+    [(_ (x) b1 b2 ...)
+     (lambda (x) b1 b2 ...)]
+    [(_ (x r ...) b1 b2 ...)
+     (lambda (x)
+       (lambda-curry (r ...) b1 b2 ...)
+       )]
+    ))
+
+(define-syntax call-curry
+  (syntax-rules ()
+    [(_ f x)
+     (f x)]
+    [(_ f x r ...)
+     (call-curry (f x) r ...)]
+    ))
+
+;;# Exercise 2.21
+;;? Create a differentiation function
+;;? For the delta use a very small number ;-)
+(define (diff f)
+  (lambda (x)
+    (let [(delta 0.00001)]
+      (/ (- (f (+ delta x)) (f x)) delta))
+    ))
+
+;; Lets get a text function
+(define (f x) (* x x))
+(define (fd x) (* 2 x))
+
+;;? Create compare-2-function which takes two functions and and array of numbers
+(define (compare-2-funcs f1 f2 numbers)
+  (map (lambda (num)
+	 (- (f2 num) (f1 num)))
+       numbers))
+
+;; Yeah not tail recursive, but its fine
+(define (linspace start stop step)
+  (if (> start stop)
+      '()
+      (cons start (linspace (+ start step) stop step))
+      ))
+
+(define (accumulate f nul)
+  (letrec [(self (lambda (lst)
+		   (if (null? lst)
+		       nul
+		       (f (car lst) (self (cdr lst)))
+		       ))
+		 )] self))
+
+(define sum (accumulate + 0))
+
+;;# Exercise 2.11
+;;? Create a generator function for (cmp x y) which takes a lt (less than) function.
+;;? (cmp x y) returns -1 if x < y, 0 when x = y and 1 when x > y.
+(define (make-cmp lt)
+  (lambda (x y)
+    (cond [(lt x y) -1]
+	  [(lt y x) 1]
+	  [else 0])
+    ))
+
+(define (from-cmp cmp)
+  (let* ([lt (lambda (x y) (= -1 (cmp x y)))]
+	 [gt (lambda (x y) (= 1 (cmp x y)))]
+	 [eq (lambda (x y) (= 0 (cmp x y)))]
+	 ) (values lt gt eq)))
+
+;;# Exercise 2.2
+(define (replication-to list len)
+  (letrec ([recur (lambda (part len res)
+		    (cond [(zero? len) res]
+			  [(null? part) (recur list len res)]
+			  [else (recur (cdr part) (1- len) (cons (car part) res))]
+			  ))]
+	   ) (reverse (recur list len '()))))
+
+;;# Exercise 2.16
+(define (for-all-1 lst p)
+  ((accumulate (lambda (x y) (and y (p x))) #t) lst))
+
+(define (there-exists lst p)
+  ((accumulate (lambda (x y) (or y (p x))) #f) lst))
+
+;; Wow im a bit stupid, but this is much easier with a filter function
+;; The above one's too
+;; I dont want to implement it right now
+(define (there-exists-1 lst p)
+  (car ((accumulate (lambda (x state) (let ([good (p x)])
+					(cons (cond [(not (cdr state)) good]
+						    [good #f]
+						    [else #t])
+					      (or good (cdr state))
+					      ))) (cons #f #f)) lst)))
+