Aufgabe 6.4 Lösung

Bachelor Algorithmen und Datenstrukturen
1

Disclaimer: Dieser Thread wurde aus dem alten Forum importiert. Daher werden eventuell nicht alle Formatierungen richtig angezeigt. Der ursprüngliche Thread beginnt im zweiten Post dieses Threads.

2

Aufgabe 6.4 Lösung
Hallo,
hier meine Lösung:

[CODE];Aufgabe 6.4.1

;Das ist die allgemeine Summationsprozedur, in linear rekursiver Form:

(define sum-rek (lambda (Proz1 a Proz2 b)
(if (> a b) 0
(+ (Proz1 a)
(sum-rek Proz1 (Proz2 a) Proz2 b)))))

;Diese auf Itterativ umgeschrieben:

(define (sum-iter proz1 a proz2 b)
(sum-iter-aux proz1 a proz2 b 0.0))

(define (sum-iter-aux proz1 a proz2 b Akku)
(if (> a b) Akku
(Sum-iter-aux proz1 (proz2 a) proz2 b (+ akku (proz1 a)))))

;Setzt man z.B folgende Prozeduren ein erhält man die Berechnung von Quadraten innerhalb ;des Vorgabeintervalls:
(define (quadr a) (* a a))
(define (inc a)
(+ a 1))

;Anmerkung: Ich hab mich hier nicht an das vorgegebene Schema der Aufgabe gehalten.
;Grund: Die lambda Struktur verwirrt
;mich irgendwie ?!? Genauer: Die Zeile “(define sum-iter-aux (lambda (i sum)” ist mir ;ziemlich schleierhaft.
;Das muss irgendwie was mit der Akkumulation der Werte durch die iterrativen Aufrufe ;hindurch zu tun haben (glaube ich).
;Wenn da jemand eine Idee dazu hatt, posten !!!

;Aufgabe 6.4.2

;Prozedur zur Annäherung von e durch Summation über n Schritte:

;Fakultätsprozedur; Wird im Rahmen der Berechnung benötigt !
(define (fact x)
(if (= x 0) 1
(* x (fact (- x 1)))))

;Rechenvorschrift für jeden Einzelschritt zur Annäherung von e!
(define (eulerproz x)
(/ 1 (fact x)))

;Die Prozedur “Euler-rek” zur Annäherung über n Schritte unter Benutzung von “sum-rek”:
(define (euler-rek n)
(sum-rek eulerproz 0.0 inc n)) ;Bemerkung: Hier
;wird neben “eulerproz” nochmal “inc”
;benutzt, da der Erhöhungsschritt 1 ist!

;Aufgabe 6.4.3

;Prozedur “Euler-iter”; Ich benutze hier nochmal meine Variante von “sum-iter”:
(define (euler-iter n)
(sum-iter eulerproz 0.0 inc n))

;komischerweise liefert “euler-iter” eine Stelle nach dem Komma mehr, grübel. . . ???
;Warum der Aufwand nicht passt ist und wie man das ändern kann,
;check ich nicht ?? Ideen ???[/CODE]

[size=9]Anm. d. Mod.: Code-Blöcke sind dafür da, verwendet zu werden! - Krull[/SIZE]

3

Ich hab das so verstanden: Das i zählt von 0 bis (b-a), d.h.

(define sum-iter (lambda (term a next b)
      (define sum-iter-aux (lambda (i sum)
           (if (> (+ a i) b) sum
               (sum-iter-aux (next i) (+ (term (+ a i)) sum)))))
                   
     (sum-iter-aux 0 0)))
4

Hier meine Lösung:

[CODE](define sum-iter (lambda (term a next b)
(define sum-iter-aux (lambda (i sum)
;;Invariante:
;; sum ist die Summe von a bis Vorgänger von i über term
(if (> i b)
sum
(sum-iter-aux (next i) (+ sum (term i))))))
(sum-iter-aux a 0)
))

(define euler-iter (lambda (n)
(define fact
(lambda (n)
(if (= n 0)
1
(* n (fact (- n 1))))))
(exact->inexact (sum-iter (lambda (x) (/ 1 (fact x))) 0 (lambda (y) (+ y 1)) n))))

(euler-iter 20)[/CODE]
Doch, wer beantwortet mir die Frage:
Woran liegt es, dass diese Prozedur einen unnötigen Aufwand betreibt???