(define debug 0)
(define (show n)
  (cond ((= debug 0)
         (display n)(newline)
         )
        ))


; ----------
(display "Aufgabe 1a\n")
(define pi 3)
(define (circle-circumference d)
  (let 
      ((pi 3.14159))
      (* pi d)
  )
)

; pi ist nur innerhalb der let blockes als *lokale* Variable definiert

;! circle-circumference 2 6.28318


(display "Aufgabe 1b\n")
(define pi 3) ; Wieder vermeintlich
(define r 13) ; unbeteiligte, globale
(define k 23) ; Definitionen

(define (cylinder-area d h)
  (let* ((pi 3.14159) ; * eingefuegt
         (r (/ d 2))
         (k (* pi r r))
         (b (* 2 k))
         (s (* 2 pi r h)))
    (+ b s)))
;! cylinder-area 2 3 25.13272

(define (cylinder-area d h)
  (let ((pi 3.14159)) ; * eingefuegt
  (let ((r (/ d 2))) 
  (let ((k (* pi r r)))
  (let ((b (* 2 k)))
  (let ((s (* 2 pi r h)))
    (+ b s)))))))
;! cylinder-area 2 3 25.13272


; Es werden die Falschen Variablen genommen da die globalen Definitionen
; verwendet werden, da alle let-Definitionen simultan ausgefuehrt werden.
(show (cylinder-area 2 3))



(display "Aufgabe 1c\n")
(define (analyse-dauer n) (+ (* 3 n) (* n (- n 1))))
(define (flexible-analyse-dauer n)
  (let ((dauer (analyse-dauer n)))
    (min dauer
         (+ (/ dauer 2) 12))
  )	
)

;! flexible-analyse-dauer 1 3
;! flexible-analyse-dauer 2 8
;! flexible-analyse-dauer 6 36



(display "Aufgabe 1d\n")
(define (circle-circumference d)
  ((lambda (pi)
    (* pi d)) 3.14159)
)
;! circle-circumference 2 6.28318


(define (cylinder-area d h)
  ((lambda (r h pi)
     ((lambda (k r h pi)
       ((lambda (b s) 
         (+ b s)
       ) (* 2 k) (* 2 pi r h))
     ) (* pi r r) r h pi)
  ) (/ d 2) h 3.14159)
)
;! cylinder-area 2 3 25.13272


(define (flexible-analyse-dauer n)
  ((lambda (dauer)
   (min dauer
         (+ (/ dauer 2) 12))
  ) (analyse-dauer n))
)
;! flexible-analyse-dauer 1 3
;! flexible-analyse-dauer 6 36



(display "Aufgabe 2\n")

(define (combine-sequence operator a1 get-ak+1 n)
  (define (inner-iter ak k result-so-far)
    (cond ((= k n) result-so-far)
          (else (let ((ak+1 (get-ak+1 ak k)))
                  (inner-iter ak+1 (+ k 1) (operator result-so-far ak+1))))))
  (inner-iter a1 1 a1)
)


; f(x+1) - berechnet durch get-ak+1

; Fakultaet


(show (combine-sequence * 1 (lambda (ak k) k) 2))
(show (combine-sequence * 1 (lambda (ak k) k) 3))
(show (combine-sequence * 1 (lambda (ak k) k) 4))

(define (fac n)
    (cond ((< n 1)
        1)
    (else
        (* n (fac (- n 1)))
    ))
)

(define (euler-approx n)
  (combine-sequence + 1.0 (lambda (ak k) (* ak (/ 1 k))) n)
)

;! euler-approx 10 2.7182815255731922
(show (euler-approx 10))


(define (pi-approx n)
  (/ 1 (combine-sequence * (* 0.5 (sqrt 2)) (lambda (ak k) (* 0.5 (sqrt (+ 2 (* 2 ak))))) n) 0.5)
)

;! pi-approx 10 3.1415914215111997
(pi-approx 10)


(display "Aufgabe 3a\n")
(define (compose f1 f2) (lambda (x) (f1 (f2 x))))
((compose (lambda (x) (* x x)) (lambda (x) (- (* 2 x) 3))) 6)


(display "Aufgabe 3b\n")
(define (h^k h k)
  (lambda (x)
  (cond ((= k 1)
             (h x)
         )(else
             (h ((h^k h (- k 1)) x))
         )
  ))
)

(define (square x) (* x x))
(define f (h^k square 4))

;! f 2 65536
(show (f 2))