Funktionsorientierte Programmierung

Wiki-Quelltext dieser Seite.

In dieser Übung geht es um das symbolische Differenzieren einstelliger Funktionen:<br/>
<tt><center>f : x -> f(x)</center><br/></tt>
Dieses Verfahren kann in Scheme angemessen realisiert werden. Für jede Ableitungsregel
schreiben Sie eine Prozedur.

===Beispiel: Ableitung einer Summe===
Die mathematische Notation fur die Ableitung y´ einer Summe y sieht wie folgt aus:<br />
<tt>
<center>y = u + v
=> y´ = u´ + v´</center>
</tt><br />
Daraus ergibt sich folgende Schemeprozedur:
<code>
(define derive+
  (lambda (u v)
    (list '+ (derive u) (derive v))))
</code>

'''Hinweis:''' Arbeiten Sie in dieser Übung zu zweit an einem Rechner und nutzen Sie ein
Tafelwerk! Außerdem gilt es zu beachten, dass die abzuleitenden Funktionen in der
Regel verkettet sind.<br />
'''Hinweis:''' Die folgenden Aufgaben sind lediglich auf Grund der Übersicht unterteilt. Die
einzelnen Teilprozeduren sind nicht alleine lauffähig. Daher müssen alle Teilprozeduren
in der letzten Aufgabe zusammen gesetzt werden um eine funktionsfähige Prozedur zum
symbolischen Differenzieren zu erhalten.

===derive-, derive*, derive/ ===
Erstellen Sie nach dem Vorbild von <tt>derive+</tt> drei weitere Prozeduren <tt>derive-</tt>,
<tt>derive*</tt> und <tt>derive/</tt>.
<code>
;Ihre 3 Prozeduren derive+, derive- und derive/
</code>

===derive-sin, derive-cos===
Implementieren Sie 2 weitere Prozeduren <tt>derive-sin</tt> und <tt>derive-cos</tt> für die
Ableitung der Sinus und der Kosinusfunktion.
<code>
;Ihre 2 Prozeduren derive-sin und derive-cos
</code>

===Top-Level-Ableitungsprozedur===
Schreiben Sie eine (top-level-) Ableitungsprozedur, welche <tt>derive+</tt> und die Prozeduren
aus den vorherigen Aufgaben nutzt.
<tt>derive</tt> erwartet einen Ausdruck als Parameter, der die Funktion definiert. Es
soll also nicht die entsprechende Prozedur für die Funktion übergeben werden, wie
wir das üblicherweise tun. Es soll auch keine Prozedur zurückgegeben werden,
sondern analog lediglich der die Ableitungsfunktion definierende Term in Gestalt
eines Scheme-Ausdruckes.<br />
Die Präfixausdrucke dürfen enthalten:
* die Variable, nach der abgeleitet wird, also <tt>x</tt>,
* Symbole für Konstanten (im mathematischen Sinn) und Zahlen, z. B. A und 4,
* Namen einstelliger Funktionen, wie <tt>sin</tt> und <tt>cos</tt>
* Symbole für zweistellige Operationen, wie <tt>+</tt> und <tt>*</tt>.
<br />
'''Hinweis:''' Beachten Sie, dass '''ALLE''' Hilfsprozeduren in den oberen code-Blöcken stehen!
<br />
'''WICHTIG:''' Beachten Sie die Ausgaben der Aufrufbeispiele!<br />
'''Aufrufbeispiele'''
<tt>
 > (derive '(* x x))
 (+ (* 1 x) (* x 1))
 > (derive '(/ 1 x))
 (/ (- (* 0 x) (* 1 1)) (* x x))
 > (derive '(sin (* x x))
 (* (+ (* 1 x) (* x 1)) (cos (* x x)))
 > (derive '(cos (* x x))
 (* (+ (* 1 x) (* x 1)) (* -1 (sin (* x x))))
 > (derive '(+ (* x x) (sin x)))
 (+ (+ (* 1 x) (* x 1)) (* 1 (cos x)))
</tt>

<code>;Ihre Top-Level-Ableitungsprozedur</code>

<eval>;Testen Sie hier Ihre Prozeduren</eval>