Algorithmisches Differenzieren - M1

Technische Universität München
Fakultät für Mathematik
Herbert Fischer
Algorithmisches Differenzieren
Skriptum zur Vorlesung WS 2005/06

Algorithmisches Differenzieren
Herbert Fischer
1 Einleitung
Wir wollen für eine Funktion f die Ableitung f ′ an einer gegebenen Stelle berechnen.
Nehmen wir zum Beispiel die Funktion f : IR → IR mit f(x) = (x 3 + x) 2 und fragen
nach f ′ (7). Gemäß der Definition der Ableitung erhalten wir den Wert
f ′ ((7 + h)
(7) = lim
h→0
3 + (7 + h)) 2 − (73 + 7) 2
h
= 103600.
Üblicher ist es, mit den bekannten Regeln der Differentialrechnung eine Formel
f ′ (x) = 2(x 3 + x)(3x 2 + 1)
zu erzeugen, mit der wir dann f ′ (7) = 103600 berechnen. Beide Wege sind nur in
einfachen Fällen brauchbar. Ist die Funktion f etwa durch ein Programm mit 5000
Anweisungen gegeben, so sind andere Wege zu suchen.
Die Regeln zum Differenzieren ermöglichen es, die Berechnung von Ableitungen
zu automatisieren. Das Prinzip ist einfach: Die gegebene Funktion f wird in Teile
zerlegt, für die Teile werden Ableitungen gebildet, sodann werden die Ableitungen der
Teile zusammengesetzt und ergeben f ′ (x). Dieses mehr oder weniger automatische
Differenzieren wollen wir schematisch so darstellen.
103600
✛
auto. Diff.
✛
✛
(x 3 + x) 2
In vielen Bereichen der Angewandten Mathematik treten Ableitungen auf: beim iterativen
Lösen von nichtlinearen Gleichungen, in der nichtlinearen Optimierung, bei der
Behandlung von Differentialgleichungen, bei der Steuerung von Robotern, in der Sensitivitätsanalyse,
bei fast allen kontinuierlichen physikalischen Problemen. Während
innerhalb der Reinen Mathematik die Behandlung von Ableitungen, also die Differentialrechnung,
seit langem ein abgeschlossenes Gebiet ist, wird in der numerischen
Praxis bezüglich der Ableitungen meist der Stand vor Leibniz beibehalten: Für eine
gegebene Funktion f wird die Ableitung f ′ an gegebener Stelle x angenähert durch
einen Differenzen-Quotienten
f ′ (x) ≈
f(y) − f(x)
.
y − x
7

1 EINLEITUNG 2
Es ist klar, daß in gewissen Fällen der Differenzen-Quotient die einzige Möglichkeit
ist, Informationen über die Ableitung zu erhalten, z.B. wenn f(x) das Ergebnis eines
Experimentes ist. In vielen Fällen jedoch ist die zu betrachtende Funktion explizit
gegeben, etwa durch einen Algorithmus, oder formelmäßig implizit bestimmt, etwa
durch eine definierende Gleichung. Nun sind Regeln zum Differenzieren bekannt und
einfach. Es liegt also durchaus nahe, die schrittweise Anwendung dieser Regeln und
damit die Berechnung von Ableitungen nicht dem Benutzer aufzubürden, sondern
von einem Algorithmus durchführen zu lassen. Für praktische Anwendungen braucht
man nicht Formeln für Ableitungen, es reicht, wenn die Werte von Ableitungen an
vorgegebenen Stellen berechnet werden können. Die systematische Erzeugung von Algorithmen,
die Ableitungswerte berechnen, und die Verwendung dieser Algorithmen
nennt man Algorithmisches Differenzieren.
Betrachten wir eine differenzierbare Funktion f : D ⊆ IR n → IR. Sei A ein Algorithmus,
der zu gegebenem x ∈ D den Funktionswert f(x) berechnet.
f(x)
✛
A
Wir sind interessiert an einem transformierten Algorithmus A ′ , der zu gegebenem x ∈
D den Funktionswert und den Ableitungswert f ′ (x) berechnet.
f(x), f ′ (x)
✛
✛
x
A ′ ✛ x
Die Transformation von A nach A ′ soll durch einen Algorithmus DIFF erfolgen.
A ′ ✛
✛
DIFF
Wir werden untersuchen, wie für eine große Klasse von Funktionen bzw. Algorithmen
die Transformation DIFF realisiert werden kann.
Für eine rationale Funktion f : D ⊆ IR n → IR sei #(f, A) die Anzahl der rationalen
Operationen zur Berechnung von f(x) mit Algorithmus A, und #(f, f ′ , A ′ ) sei die
Anzahl der rationalen Operationen zur Berechnung von f(x) und f ′ (x) mit Algorithmus
A ′ . Im Vergleich dieser “Kosten” gemäß der Formel
#(f, f ′ , A ′ ) = K · #(f, A)
gibt der Faktor K Auskunft über die Effizienz des Algorithmus A ′ . Und da A ′ durch
DIFF erzeugt wird, ist K auch ein Maß für die Effizienz von DIFF. Bei geschickter
Realisierung von DIFF ergibt sich K ≤ 4. Das heißt: Funktionswert f(x)
A

1 EINLEITUNG 3
und Ableitungswert f ′ (x) zusammen kosten höchstens 4-mal soviel wie der Funktionswert
f(x) alleine. Im Vergleich dazu ist die Approximation von f ′ (x) durch
einen Differenzen-Quotienten teuer, sie erfordert mindestens n + 1 Funktionswert-
Berechnungen. Somit ergibt sich für n > 3 die überraschende Situation: Die Approximation
von f ′ (x), berechnet mit einem Differenzen-Quotienten, ist teuerer als der
exakte Wert f ′ (x), berechnet mit Algorithmischem Differenzieren.
Im Jahr 1959 wurde an der Akademie der Wissenschaften der UdSSR ein Bericht [11]
“Programme zum Automatischen Differenzieren für die Maschine BESM” in Russisch
geschrieben, der eine der ersten Arbeiten zu unserem Thema ist. Seitdem erschienen
etwa 300 einschlägige Veröffentlichungen, ein subjektive Auswahl ist im Literaturverzeichnis
zu finden. Rall’s Buch [121] von 1981 ist heute eine Standard–Referenz. Einen
guten Überblick geben die Proceedings [70] einer internationalen Tagung im Jahr 1991,
herausgegeben von Griewank und Corliss. Von den neueren Veröffentlichungen, insbesondere
im Zusammenhang mit der Intervall–Rechnung, ist Lohner’s Arbeit [106]
von 1994 zu nennen. Das vorliegende Kapitel enthält die grundlegenden Ideen des
Algorithmischen Differenzierens, wobei wir auch auf die Hesse–Matrix einer reellen
Funktion von n Veränderlichen eingehen. Die Darstellung ist bewußt breit ausgelegt,
sodaß besondere Vorkenntnisse nicht nötig sind.

2 VORWÄRTS–METHODE 4
2 Vorwärts–Methode
Sei f :D ⊆ IR n → IR eine differenzierbare Funktion. f ′ bezeichne die Ableitung von f.
Dann ist
f ′ �
∂f(x)
(x) = ,
∂x1
∂f(x)
, . . . ,
∂x2
∂f(x)
�
∈ IR
∂xn
1×n .
f ′ (x) ist eine Matrix mit einer Zeile und n Spalten. Wir wollen f ′ (x) zusammensetzen
aus Ableitungen von Teilen von f. Beginnen wir mit ganz einfachen Teilen, mit
kanonischen Projektionen und konstanten Funktionen.
Ist r : IR n → IR eine kanonische Projektion, d.h.
r(x) = xk = k–te Komponente von x,
so ist offensichtlich
r ′ (x) = [0, . . . , 0, 1, 0, . . . , 0] mit 1 in Position k.
Ist r : IR n → IR eine konstante Funktion, d.h.
so gilt natürlich
r(x) = gegebene oder berechnete Konstante,
r ′ (x) = [0, . . . . . . , 0].
So trivial diese Ableitungen auch sind, wir benötigen sie vorerst als Basis für den
Aufbau von f ′ (x).
Jetzt behandeln wir zwei geläufige Verfahren, aus gegebenen Funktionen in einfacher
Weise neue Funktionen zu bilden, die rationale Komposition und die Verwendung von
Bibliothek–Funktionen.
2.1 Rationale Komposition
Wir betrachten zwei differenzierbare Funktionen
a : D ⊆ IR n → IR und b : D ⊆ IR n → IR.
Sei r eine der Funktionen a + b, a − b, a · b, a/b mit der Einschränkung b(x) �= 0 für
alle x ∈ D im Fall a/b. Die Funktion r ist differenzierbar. In Tabelle 1 sind Formeln
für die Ableitung r ′ angegeben.
Typ r = r ′ =
+ r = a + b r ′ = a ′ + b ′
− r = a − b r ′ = a ′ − b ′
· r = a · b r ′ = b · a ′ + a · b ′
/ r = a / b r ′ = (a ′ − r · b ′ )/b
Tabelle 1: Ableitung der rationalen Komposition
Wir wollen streng unterscheiden zwischen Funktionen und Funktionswerten: r und r ′
sind Funktionen, r(x) und r ′ (x) sind Funktionswerte. Die Tabelle 1 zeigt also Formeln

2 VORWÄRTS–METHODE 5
für Funktionen. Wenden wir eine der Funktionen r, r ′ auf ein x ∈ D an, so erhalten
wir Formeln für Funktionswerte. Etwa für die Division erhalten wir
r ′ (x) = (a ′ (x) − r(x) · b ′ (x))/b(x).
Aus den Formeln in Tabelle 1 schließen wir:
Das Paar r(x), r ′ (x) kann berechnet werden aus den Paaren a(x), a ′ (x) und b(x), b ′ (x).
Diese schlichte Einsicht ist einer der wichtigsten Angelpunkte des Automatischen Differenzierens.
Das Paar r(x), r ′ (x) ist nicht ein Paar von Formeln, es ist auch nicht
ein Paar von Funktionen, es ist ein Element von IR × IR 1×n . Der Mechanismus zur
Berechnung des Paares r(x), r ′ (x) hängt nicht von x ab, er ist auch unabhängig von
den speziellen Funktionen a und b, er wird allein bestimmt durch den Typ ω von r.
Dies soll durch folgendes Diagramm verdeutlicht werden.
r(x), r ′ (x)
✛
RAT
✛
✛
✛
ω
a(x), a ′ (x)
b(x), b ′ (x)
RAT kann realisiert werden als Prozedur in PASCAL, als Subroutine in FORTRAN,
oder als Funktion, wenn die gewählte Programmiersprache es zuläßt. Einfacher ist es,
die vier Typen von r einzeln zu behandeln. Dann kann man in Programmiersprachen
wie ADA, C++, PASCAL–XSC Operatoren definieren, die in kompakter Schreibweise
RAT realisieren.
Wir verwenden hier RAT als Funktion, die zu einem Typ ω ∈ {+, −, ·, /} und zu
Paaren A = (a(x), a ′ (x)) und B = (b(x), b ′ (x)) das Paar R = (r(x), r ′ (x)) berechnet,
R ←− RAT(ω, A, B).
Ein kurzes Beispiel soll die Bedeutung der rationalen Komposition für die Berechnung
von Ableitungen demonstrieren.

2 VORWÄRTS–METHODE 6
Beispiel 1
Gegeben sei die differenzierbare Funktion
f : D ⊆ IR 2 → IR mit f(x) = x1 · x2 − 7
,
x1 + x2
wobei D = {x|x = (x1, x2) ∈ IR 2 , x1 + x2 �= 0}. Gewünscht ist f ′ (3, 8). Wir definieren
Funktionen f1, f2, . . . , f7 : D → IR durch
f1(x) = x1
f2(x) = x2
f3(x) = 7
f4(x) = f1(x) · f2(x)
f5(x) = f4(x) − f3(x)
f6(x) = f1(x) + f2(x)
f7(x) = f5(x) / f6(x)
Offensichtlich ist f7 = f. Da zu gegebenem x ∈ D nacheinander die Werte f1(x),
f2(x),. . . , f7(x) = f(x) berechnet werden können, liegt ein Algorithmus A zur Berechnung
von f(x) vor. Nun betrachten wir die Paare Yk = (fk(x), f ′ k(x)) für k =1, 2, . . . , 7.
Mit x = (3, 8) sind die Paare Y1, Y2, Y3 bekannt. Die folgenden Paare Y4, Y5, Y6, Y7
können schrittweise mit RAT berechnet werden.
Y1 ←− (3, [1, 0])
Y2 ←− (8, [0, 1])
Y3 ←− (7, [0, 0])
Y4 ←− RAT(·, Y1, Y2) = (24, [8, 3])
Y5 ←− RAT(−, Y4, Y3) = (17, [8, 3])
Y6 ←− RAT(+, Y1, Y2) = (11, [1, 1])
Y7 ←− RAT(/, Y5, Y6) = (1.54 . . . , [0.586 . . . , 0.132 . . .])
Somit ist f(3, 8) = 1.54 . . . und f ′ (3, 8) = [0.586 . . . , 0.132 . . .]. ⊓⊔
Für jede explizit gegebene rationale Funktion f und jedes zulässige Argument x können
wir f ′ (x) mit RAT schrittweise berechnen. Eine Formel für die Ableitung f ′ im
herkömmlichen Sinne wird dabei nicht verwendet.

2 VORWÄRTS–METHODE 7
2.2 Bibliothek–Funktionen
Sei Λ eine Kollektion differenzierbarer reeller Funktionen einer reellen Variablen. Wir
denken dabei an Funktionen wie sin, ln, exp,. . . und ähnliche. Der Kürze halber seien
die Funktionen in Λ Bibliothek–Funktionen genannt. Wir betrachten eine Bibliothek–
Funktion
λ : E ⊆ IR → IR
und eine differenzierbare Funktion
a : D ⊆ IR n → IR.
Unter der Voraussetzung a(D) ⊆ E definieren wir eine neue Funktion
r : D ⊆ IR n → IR mit r(x) := λ(a(x)).
Diese Funktion r ist differenzierbar und es gilt
r ′ (x) = λ ′ (a(x)) · a ′ (x).
Wir nehmen an, die Funktionen λ und λ ′ können für jedes zulässige Argument ausgewertet
werden. Dies ist kein Problem für die üblichen Bibliothek–Funktionen sin, ln,
exp,. . . und ähnliche.
Aus den Formeln für r(x) und r ′ (x) schließen wir:
Das Paar r(x), r ′ (x) kann mittels λ, λ ′ berechnet werden aus dem Paar a(x), a ′ (x).
Diese fast triviale Erkenntnis ist ein weiterer wichtiger Angelpunkt des Algorithmischen
Differenzierens. Der Mechanismus zur Berechnung des Paares r(x), r ′ (x) hängt nicht
von x ab, er ist auch unabhängig von den speziellen Funktionen a und λ. Zur Berechnung
des Paares r(x), r ′ (x) aus dem Paar a(x), a ′ (x) müssen wir allerdings wissen,
welches λ ∈ Λ verwendet werden soll. Dies soll durch folgendes Diagramm verdeutlicht
werden.
r(x), r ′ (x)
✛
LIB
✛
✛
λ
a(x), a ′ (x)
LIB kann realisiert werden als Prozedur in PASCAL, als Subroutine in FORTRAN,
oder als Funktion, wenn die gewählte Programmiersprache das zuläßt. Man kann auch
jede Bibliothek–Funktion einzeln behandeln und den Namen der Bibliothek–Funktion
in den Namen der entsprechenden Prozedur bzw. Subroutine bzw. Funktion stecken.
Wir verwenden hier LIB als Funktion, die zu einer Bibliothek–Funktion λ und zu
einem Paar A = (a(x), a ′ (x)) das Paar R = (r(x), r ′ (x)) berechnet,
R ←− LIB(λ, A).
Ein kurzes Beispiel soll die Verwendung von Bibliothek–Funktionen für die Berechnung
von Ableitungen demonstrieren.

2 VORWÄRTS–METHODE 8
Beispiel 2
Gegeben sei die differenzierbare Funktion
f : D ⊆ IR 3 → IR mit f(x) = (x1 − 7) · sin(x1 + x2)
,
wobei D = {x|x = (x1, x2, x3) ∈ IR 3 , x3 �= 0}. Gewünscht ist f ′ (−13, 8, 0.3). Zu
gegebenem x ∈ D kann der Funktionswert f(x) schrittweise berechnet werden wie in
Spalte 1 des folgenden Schemas angegeben. Hier ist y9 = f(x).
y1 = x1 f1(x) = x1 Y1 ← (x1, [1, 0, 0])
y2 = x2 f2(x) = x2 Y2 ← (x2, [0, 1, 0])
y3 = x3 f3(x) = x3 Y3 ← (x3, [0, 0, 1])
y4 = 7 f4(x) = 7 Y4 ← (7, [0, 0, 0])
y5 = y1 − y4 f5(x) = f1(x) − f4(x) Y5 ← RAT(−, Y1, Y4)
y6 = y1 + y2 f6(x) = f1(x) + f2(x) Y6 ← RAT(+, Y1, Y2)
y7 = sin(y6) f7(x) = sin(f6(x)) Y7 ← LIB(sin, Y6)
y8 = y5 · y7 f8(x) = f5(x) · f7(x) Y8 ← RAT(·, Y5, Y7)
y9 = y8/y3 f9(x) = f8(x)/f3(x) Y9 ← RAT(/, Y8, Y3)
Das Schema für y1, y2, . . . , y9 erlaubt die Definition von Funktionen f1, f2, . . . , f9 wie
in Spalte 2 angegeben. Offensichtlich ist f9 = f. Nun führen wir Paare Yk =
(fk(x), f ′ k(x)), für k = 1, 2, . . . , 9, ein. Für gegebenes x sind die Paare Y1, Y2, Y3, Y4
bekannt. Und für k = 5, 6, 7, 8, 9 kann das Paar Yk aus bereits ermittelten Paaren mit
RAT und LIB berechnet werden. Das letzte Paar ist
Y9 = (f9(x), f ′ 9(x)) = (f(x), f ′ (x)).
Für x = (−13, 8, 0.3) erhalten wir
f(x) = −63.9 . . . und f ′ (x) = [−15.7 . . . , −18.9 . . . , 213. . . .].
Die Spalte 1 stellt eine code-list für die Funktion f dar, wie sie von L.B. Rall in [121]
verwendet wird. Diese code-list ist ein Algorithmus A zur Berechnung von f(x). Die
Spalte 2 zeigt, daß eine code-list für f eine iterative Folge f1, f2, . . . , f9 von Funktionen
definiert. Und die Spalte 3 kann als Algorithmus A ′ zur Berechnung von f(x) und f ′ (x)
aufgefaßt werden. Die in der Einleitung genannte Transformation DIFF : A → A ′ ist
im Vergleich von Spalte 1 und Spalte 3 ersichtlich. ⊓⊔
x3

2 VORWÄRTS–METHODE 9
2.3 Allgemeines Schema
Wir betrachten eine Funktion f : D ⊆ IR n → IR, die durch einen Algorithmus A gemäß
Tabelle 2 definiert ist.
(1) Für k = 1, 2, . . . , n
yk = xk = k–te Komponente von x
(2) Für k = n + 1, n + 2, . . . , n + t
yk = Φk(y1, y2, . . . , yk−1)
(3) f(x) = yn+t
Tabelle 2: Algorithmus A zur Berechnung von f(x)
Die verwendeten Funktionen Φn+1, Φn+2, . . . , Φn+t seien differenzierbar. Dann ist f
ebenfalls differenzierbar. Wir definieren Funktionen f1, f2, . . . , fn mit
fk(x) := xk = k–te Komponente von x
und Funktionen fn+1, fn+2, . . . , fn+t mit
fk(x) := Φk(f1(x), f2(x), . . . , fk−1(x)).
Ist Φk eine konstante Funktion, dann ist natürlich fk ebenfalls eine konstante Funktion.
Ist Φk von der Gestalt
Φk(y1, y2, . . . , yk−1) = yi ∗ yj mit ∗ ∈ {+, −, ·, /},
dann ist fk(x) = fi(x) ∗ fj(x), also ist fk eine rationale Komposition wie in Abschnitt
2.1 behandelt. Ist Φk von der Gestalt
Φk(y1, y2, . . . , yk−1) = λ(yi) mit λ ∈ Λ,
dann ist fk(x) = λ(fi(x)), also ist fk eine Funktion wie in Abschnitt 2.2 behandelt.
Im allgemeinen nehmen wir an, daß Φk für gegebene Argumente ausgewertet werden
kann. Für die Ableitung f ′ k erhalten wir mit der Ketten–Regel
⎡ ⎤
f ′ k(x) = Φ ′ k(f1(x), f2(x), . . . , fk−1(x)) ·
⎢
⎣
f ′ 1(x)
.
f ′ k−1(x)
Diese Formel für f ′ k(x) beinhaltet als Spezialfälle auch die entsprechenden Formeln für
die Ableitungen aus den Abschnitten 2.1 und 2.2. Im allgemeinen nehmen wir an, daß
Φ ′ k für gegebene Argumente ausgewertet werden kann.
Nun betrachten wir Paare von Funktionswert und Ableitungswert und setzen
Yk := (fk(x), f ′ k(x)) für k = 1, 2, . . . , n + t.
Für k = 1, 2, . . . , n ist das Paar Yk offensichtlich, und für k = n + 1, n + 2, . . . , n + t
kann das Paar Yk aus den Paaren Y1, Y2, . . . , Yk−1 berechnet werden,
Yk ←− Φ ∗ k(Y1, Y2, . . . , Yk−1).
⎥
⎦ .

2 VORWÄRTS–METHODE 10
Damit ergibt sich ein Algorithmus A ′ zur Berechnung von f(x) und f ′ (x) wie in Tabelle
3 dargestellt.
(1) Für k = 1, 2, . . . , n
Yk ← (xk, [0, . . . , 0, 1, 0, . . . , 0]) mit 1 in Position k
(2) Für k = n + 1, n + 2, . . . , n + t
Yk ← Φ ∗ k(Y1, Y2, . . . , Yk−1)
(3) (f(x), f ′ (x)) ← Yn+t
Tabelle 3: Algorithmus A ′ zur Berechnung von f(x) und f ′ (x)
Die Anwendung von A ′ nennt man Vorwärts–Methode. Die Algorithmen A und A ′
sehen sich sehr ähnlich. Entsprechend einfach und naheliegend ist daher die in der
Einleitung erwähnte Transformation DIFF : A → A ′ . Allerdings sind wir bisher sehr
großzügig mit den Konstanten umgegangen. Die Verwendung einer Konstanten als
konstante Funktion, deren Ableitung nur Nullen enthält, fügt sich zwar einfach in die
Theorie ein, in der Praxis wird man jedoch darauf Wert legen, unnötige Operationen
mit Nullen zu vermeiden. Dies führt zu einer Verfeinerung der Funktionen RAT und
LIB und zu einer sorgfältigeren Behandlung von Φk. In der Transformation DIFF
müssen dann entsprechend viele Spezialfälle berücksichtigt werden.
2.4 Komplexität
In diesem Abschnitt beschränken wir uns auf eine rationale Funktion
f : D ⊆ IR n → IR.
Wir wollen abschätzen, wie viele rationale Operationen zur Berechnung von Funktionswert
f(x) und Ableitungswert f ′ (x) benötigt werden. Unter einer rationalen Operation
verstehen wir Addition oder Subtraktion oder Multiplikation oder Division zweier
reeller Zahlen oder Vorzeichenwechsel einer reellen Zahl. Ferner soll abgeschätzt werden,
wieviel Speicherplatz nötig ist. Bei solchen Abschätzungen ist es wesentlich zu
beachten, daß sowohl f(x) als auch f ′ (x) auf verschiedene Weisen berechnet werden
können. So gibt es zum einen für eine Funktion viele Schreibweisen, die sich in der
Anzahl der Operationen unterscheiden, etwa
f(x) = 1 − x2
=
x1 + x2
x1
.
x1 + x2
Zum anderen gibt es bei einem vorgegebenen Algorithmus zur Berechnung von f(x)
verschiedene Algorithmen, die den Ableitungswert f ′ (x) berechnen.
Wir folgen dem Algorithmus A in Tabelle 2 und spezifizieren die Vorschrift
yk = Φk(y1, y2, . . . , yk−1).
Wir nehmen an, daß yk mit einer rationalen Operation aus y1, y2, . . . , yk−1 berechnet
wird. Die verschiedenen Möglichkeiten sind in Tabelle 4 zusammengestellt, wobei ci
und cj konstante reelle Zahlen sind.
Den präzisierten Algorithmus zur Berechnung von f(x) nennen wir jetzt FUN, siehe
Tabelle 5.

2 VORWÄRTS–METHODE 11
Typ yk y ′ k #(yk, y ′ k)
A yi + yj mit i �= j y ′ i + y ′ j n + 1
S yi − yj mit i �= j y ′ i − y ′ j n + 1
M yi · yj mit i �= j yj · y ′ i + yi · y ′ j 3n + 1
D yi/yj mit i �= j (y ′ i − yk · y ′ j)/yj 3n + 1
AV yi + yi 2 · y ′ i n + 1
SV yi − yi 0 1
MV yi · yi (2 · yi) · y ′ i n + 2
DV yi/yi 0 1
AVC yi + cj y ′ i 1
SVC yi − cj y ′ i 1
MVC yi · cj cj · y ′ i n + 1
DVC yi/cj y ′ i/cj n + 1
ACV ci + yj y ′ j 1
SCV ci − yj −y ′ j n + 1
MCV ci · yj ci · y ′ j n + 1
DCV ci/yj (−yk/yj) · y ′ j n + 3
VW −yj −y ′ j n + 1
Tabelle 4: Formeln für yk und y ′ k
(1) Für k = 1, 2, . . . , n
yk = xk = k–te Komponente von x
(2) Für k = n + 1, n + 2, . . . , n + t
yk = eine der Formeln in Tabelle 4 Spalte 2
(3) f(x) = yn+t
Tabelle 5: Algorithmus FUN zur Berechnung von f(x)

2 VORWÄRTS–METHODE 12
Wir definieren
#(f, FUN) := Anzahl der rationalen Operationen zur Berechnung
von f(x) mit FUN.
Offensichtlich gilt #(f, FUN) = t. Es sei nochmals darauf hingewiesen, daß die Zahl
#(f, FUN) nicht eine Kenngröße der Funktion f ist, sondern dem Algorithmus FUN
zugeordnet ist. Die in der Literatur auftretende Bezeichnung L(f) im Zusammenhang
mit “Anzahl der Operationen” sollte reserviert bleiben für L(f) := min #(f, FUN),
wobei das Minimum zu nehmen ist über alle möglichen Algorithmen vom Typ FUN
zur Berechnung von f(x).
Nun folgen wir dem Algorithmus A ′ in Tabelle 3 und spezifizieren die Vorschrift
Yk ←− Φ ∗ k(Y1, Y2, . . . , Yk−1).
Das Paar Yk besteht aus yk = fk(x) und y ′ k = f ′ k(x). Abhängig vom Typ der k–ten
Operation wird y ′ k berechnet wie in Tabelle 4 Spalte 3 angegeben. Den so präzisierten
Algorithmus zur Berechnung von f(x) und f ′ (x) nennen wir jetzt VM (Vorwärts–
Methode), siehe Tabelle 6.
Wir definieren
(1) Für k = 1, 2, . . . , n
(yk, y ′ k) ← (xk, [0, . . . , 0, 1, 0, . . . , 0]) mit 1 in Position k
(2) Für k = n + 1, n + 2, . . . , n + t
(yk, y ′ k) ← gemäß Tabelle 4 Spalte 2 und Spalte 3
(3) (f(x), f ′ (x)) ← (yn+t, y ′ n+t)
Tabelle 6: Algorithmus VM
#(f, f ′ , VM) := Anzahl der rationalen Operationen zur Berechnung
von f(x) und f ′ (x) mit VM.
Es ist sehr einfach, die Größe #(f, f ′ , VM) abzuschätzen. In Tabelle 4 Spalte 4 ist
unter #(yk, y ′ k) angemerkt, wie “teuer” ein Paar (yk, y ′ k) ist. Damit erhalten wir
Proposition 1: Für die Berechnung von f(x) und f ′ (x) mit dem Algorithmus VM
gilt
#(f, f ′ , VM) ≤ (3n + 1) · #(f, FUN).
Funktionswert und Ableitungswert zusammen, berechnet mit VM, kosten also höchstens
(3n + 1)–mal soviel wie der Funktionswert alleine. Diese Abschätzung ist scharf.
Wenn im Algorithmus FUN nur Operationen vom Typ M oder D auftreten, dann wird
obige Ungleichung zu einer Gleichung.

2 VORWÄRTS–METHODE 13
Nun zum Bedarf an Speicherplätzen für den Algorithmus VM. Es ist schwierig, eine
relevante Größe zu definieren, da wir im Algorithmus VM nicht spezifiziert haben, was
während des Ablaufes des Algorithmus zu speichern ist und was eventuell zu vergessen
ist. Wenn wir jedes Paar (yk, y ′ k) für k = 1, 2, . . . , n + t separat speichern, dann sind
(n + t) · (n + 1) Speicherplätze nötig. In einem Programm für den Algorithmus VM
wird man allerdings versuchen, gespeicherte Zahlen zu vergessen, wenn sie für den Rest
des Algorithmus nicht mehr von Belang sind, d.h. man überschreibt Speicherplätze.
Dadurch kann der Bedarf an Speicherplätzen weit unter (n + t) · (n + 1) sinken.
Wir wollen noch eine Variante VM1 zum Algorithmus VM angeben. Der Algorithmus
VM startet in Block (1) mit den Ableitungen y ′ 1, y ′ 2, . . . , y ′ n, die jeweils (n − 1)
System–Nullen enthalten. Im Block (2) werden aus diesen Ableitungen neue Ableitungen
gebildet. Dabei werden rationale Operationen mit System–Nullen ausgeführt.
Diese unnötigen Operationen werden im Algorithmus VM1 unterdrückt. Jedem y ′ k
ordnen wir eine Index–Menge Ik zu, welche die Indizes der signifikanten Komponenten
von y ′ k enthält. So gehört z.B. zu y ′ 1 die Index–Menge I1 = {1}. Angenommen y ′ i, Ii
und y ′ j, Ij sind bereits berechnet und y ′ k = y ′ i + y ′ j. Dann werden die Komponenten von
y ′ k berechnet nach der Vorschrift
y ′ ⎧
y
⎪⎨
kµ =
⎪⎩
′ iµ + y ′ jµ für µ ∈ Ii ∩ Ij
y ′ iµ für µ ∈ Ii\Ij
y ′ ⎫
⎪⎬
jµ für µ ∈ Ij\Ii
⎪⎭
0 für µ /∈ Ii ∪ Ij
für µ = 1, 2, . . . , n.
Die zu y ′ k gehörige Index–Menge ist Ik = Ii ∪ Ij. Analog werden bei den anderen
Verknüpfungen von Ableitungen die Operationen mit System–Nullen eingespart.

3 RÜCKWÄRTS–METHODE 14
3 Rückwärts–Methode
In Abschnitt 2 haben wir gezeigt, wie ein Algorithmus A zur Berechnung eines Funktionswertes
f(x) transformiert werden kann in einen Algorithmus A ′ für die Berechnung
von Funktionswert f(x) und Ableitungswert f ′ (x). Der beschriebene Weg ist nicht der
einzige, das gesteckte Ziel zu erreichen. Es gibt einen anderen Weg, der ebenfalls
zu einem Algorithmus für die Berechnung von f(x) und f ′ (x) führt. Während bei
der Vorwärts–Methode schrittweise die Ableitungen ∂yk
verwendet werden, liefert der
∂xi
zweite Weg eine Methode, in der schrittweise Ableitungen ∂yn+t
erscheinen. Diese
∂yk
zweite Methode nennen wir Rückwärts–Methode, aus Gründen, die noch ersichtlich
werden. In diesem Abschnitt wollen wir den mathematischen Formalismus für die
Rückwärts–Methode darlegen. Dabei werden – der Geschlossenheit zuliebe – einige
Bezeichnungen aus Abschnitt 2 wiederholt.
3.1 Allgemeines Schema
Wir betrachten eine Funktion f : D ⊆ IR n → IR, die durch einen Algorithmus A gemäß
Tabelle 7 definiert ist.
(1) Für k = 1, 2, . . . , n
yk = xk = k–te Komponente von x
(2) Für k = n + 1, n + 2, . . . , n + t
yk = Φk(y1, y2, . . . , yk−1)
(3) f(x) = yn+t
Tabelle 7: Algorithmus A zur Berechnung von f(x)
Wir nehmen an, daß für k = n + 1, n + 2, . . . , n + t die Funktion
Φk : Dk−1 ⊆ IR k−1 → IR (1)
und deren Ableitung Φ ′ k bekannt sind. Wir nehmen ferner an, daß die Funktionen
Φk und Φ ′ k für gegebene Argumente ausgewertet werden können. Der Algorithmus
A beschreibt, wie zu gegebenem x ∈ D der Funktionswert f(x) schrittweise über die
Hilfsgrößen y1, y2, . . . , yn+t zu berechnen ist.
Nun definieren wir für k = n + 1, n + 2, . . . , n + t
Ek : Dk−1 ⊆ IR k−1 → IR k � �
z
mit Ek(z) := .
Φk(z)
(2)
Jeder Funktion Φk ist also eine Funktion Ek zugeordnet. Ek kopiert das Argument z
und fügt eine neue Komponente Φk(z) an. Ferner definieren wir die Funktion
L : IR n+t → IR mit L(z) := letzte Komponente von z. (3)

3 RÜCKWÄRTS–METHODE 15
Damit erhalten wir eine schöne Darstellung der Funktion f,
f(x) = L(En+t(En+t−1( . . . En+2(En+1(x)) . . . ))), (4)
oder noch kürzer
f = L ◦ En+t ◦ En+t−1 ◦ . . . ◦ En+2 ◦ En+1, (5)
wobei ◦ die Hintereinanderausführung von Funktionen bedeutet. Die Formel (4)
beschreibt in kompakter Weise die Berechnung von f(x) gemäß Algorithmus A. Der
Berechnung von yk in Algorithmus A entspricht die Auswertung der Funktion Ek in
Formel (4).
Differenzieren wir die Formel (4)! Zur Abkürzung setzen wir
zn := x (6)
und für k = n + 1, n + 2, . . . , n + t
zk := Ek(Ek−1( . . . En+2(En+1(x)) . . . )). (7)
Aus (4) ergibt sich mit der Ketten–Regel
f ′ (x) = L ′ (zn+t) · E ′ n+t(zn+t−1) · . . . · E ′ n+2(zn+1) · E ′ n+1(zn). (8)
Somit erhalten wir für f ′ (x) ein Produkt von Jacobi–Matrizen. Die Multiplikation von
Matrizen ist assoziativ, also gibt es viele Möglichkeiten, das Produkt zu ermitteln.
Bei genauerem Hinsehen kann man erkennen, daß die Multiplikation von rechts nach
links der Vorwärts–Methode entspricht. Die Multiplikation von links nach rechts ergibt
die Rückwärts–Methode. Diese soll jetzt näher beschrieben werden.
Zunächst geben wir den Teil–Produkten Namen, wir definieren
pn+t+1 := L ′ (zn+t), (9)
und für k = n + t, n + t − 1, . . . , n + 1 in dieser Reihenfolge
pk := pk+1 · E ′ k(zk−1). (10)
Dann stellen wir fest, daß für k = n, n + 1, . . . , n + t gilt
⎡ ⎤
y1
⎢ ⎥
⎢
⎢y2
⎥
zk = ⎢ ⎥
⎢
⎣ . ⎥
⎦
yk
mit y1, y2, . . . , yk gemäß Algorithmus A. (11)
Leider benötigen wir die Vektoren zn+t, zn+t−1, . . . , zn in dieser Reihenfolge. Wir
müssen also die Werte y1, y2, . . . , yn+t mit Algorithmus A berechnen und können dann
erst mit der Produktbildung beginnen. In Tabelle 8 ist unser Plan skizziert.

3 RÜCKWÄRTS–METHODE 16
(1) Berechne y1, y2, . . . , yn+t = f(x) mit Algorithmus A. Mit (11)
stehen somit die Vektoren zn+t, zn+t−1, . . . , zn zur Verfügung
(2) Berechnung von f ′ (x):
(2.1) pn+t+1 := L ′ (zn+t)
(2.2) Für k = n + t, n + t − 1, . . . , n + 1 in dieser Reihenfolge
pk := pk+1 · E ′ k(zk−1)
(2.3) f ′ (x) = pn+1
Tabelle 8: Plan für die Rückwärts–Methode
Das folgende Schema soll unseren Plan verdeutlichen.
f ′ (x) =L ′ (zn+t)·E ′ n+t(zn+t−1)·. . .·E ′ n+2(zn+1)·E ′ n+1(zn)
pn+t+1
Nun zu technischen Details! Es gilt
pn+t
pn+2
pn+1
pn+t+1 := L ′ (zn+t) = [0, . . . , 0, 1] = Zeile mit n + t Spalten. (12)
pk+1 ist eine Zeile mit k Spalten. E ′ k(zk−1) ist eine Matrix mit k Zeilen und k − 1
Spalten. Die oberen k − 1 Zeilen von E ′ k(zk−1) bilden eine Einheitsmatrix, und die
letzte Zeile von E ′ k(zk−1) ist Φ ′ k(zk−1). Diese besonders einfache Gestalt der Matrix
E ′ k(zk−1) bewirkt
pk
� �� �
pk,1 . . . pk,k−1
pk+1
� �� �
= pk+1,1 . . . pk+1,k−1 pk+1,k
E
� �� �
′ k(zk−1)
• 1
· · · · · · · · · · · ·
Φ ′ k(zk−1)
[pk,1 . . . pk,k−1] = [pk+1,1 . . . pk+1,k−1] + pk+1,k · letzte Zeile von E ′ k(zk−1) (13)
oder mit Φ ′ k(zk−1) ausgedrückt
[pk,1 . . . pk,k−1] = [pk+1,1 . . . pk+1,k−1] + pk+1,k · Φ ′ k(zk−1). (14)
1

3 RÜCKWÄRTS–METHODE 17
In Block (2.2) Schritt k unseres Planes ist also zu einer Zeile ein Vielfaches der Zeile
Φ ′ k(zk−1) zu addieren. Dies legt “ Überschreiben” nahe. Wir führen eine Arbeitszeile U
der Länge n + t ein,
U = U1 . . . Un Un+1 . . . . . . Un+t
in der wir die aktuellen Werte von pk speichern. Aus (14) entsteht dann die update–
Formel
Uµ ←− Uµ + Uk · Φ ′ k(zk−1)µ für µ = 1, 2, . . . , k − 1, (15)
wobei der Index µ die Spalte von U bzw. Φ ′ k(zk−1) kennzeichnet. Nach Beendigung
von Block (2.2) unseres Planes enthält die Arbeitszeile U die Werte
und es gilt
U = pn+1,1 . . . pn+1,n pn+2,n+1 . . . . . . pn+t+1,n+t (16)
f ′ (x) = pn+1 = [U1, U2, . . . , Un]. (17)
Damit ergibt sich ein Algorithmus A ′ zur Berechnung von f(x) und f ′ (x) wie in Tabelle
9 dargestellt.
(1) Berechne y1, y2, . . . , yn+t = f(x) mit Algorithmus A.
(2) Berechnung von f ′ (x):
(2.1) U ← [0, . . . , 0, 1] mit Länge n + t
(2.2) Für k = n + t, n + t − 1, . . . , n + 1 in dieser Reihenfolge
für µ = 1, 2, . . . , k − 1
Uµ ← Uµ + Uk · Φ ′ k(y1, y2, . . . , yk−1)µ
(2.3) f ′ (x) ← [U1, U2, . . . , Un]
Tabelle 9: Algorithmus A ′ zur Berechnung von f(x) und f ′ (x)
3.2 Komplexität
Über den Rechenaufwand des Algorithmus A ′ kann Näheres erst ausgesagt werden,
wenn Einzelheiten über die Funktionen Φk und Φ ′ k für k = n + 1, n + 2, . . . , n + t
vorliegen. Wir betrachten hier nur rationale Φk. Ferner nehmen wir an, daß die
Vorschrift
yk = Φk(y1, y2, . . . , yk−1) (18)
nur eine rationale Operation darstellt. Die verschiedenen Möglichkeiten sind in Tabelle
10 Spalte 2 angegeben.

3 RÜCKWÄRTS–METHODE 18
Tk yk ¯yki ¯ykj Ski Skj #(Ski, Skj)
A yi + yj mit i �= j 1 1 Uk Uk 0
S yi − yj mit i �= j 1 −1 Uk Uk 0
M yi · yj mit i �= j yj yi Uk · yj Uk · yi 2
D yi/yj mit i �= j 1/yj −yk/yj Uk/yj Ski · yk 2
AV yi + yi 2 Uk · 2 1
SV yi − yi 0
MV yi · yi 2 · yi Uk · 2 · yi 2
DV yi/yi 0
AVC yi + cj 1 Uk 0
SVC yi − cj 1 Uk 0
MVC yi · cj cj Uk · cj 1
DVC yi/cj 1/cj Uk/cj 1
ACV ci + yj 1 Uk 0
SCV ci − yj −1 Uk 0
MCV ci · yj ci Uk · ci 1
DCV ci/yj −yk/yj Uk · yk/yj 2
VW −yj −1 Uk 0
Tabelle 10: Formeln für yk, ¯yki, ¯ykj, Ski, Skj in Abhängigkeit vom Typ Tk Die
Berechnung des Funktionswertes f(x) erfolge mit dem Algorithmus FUN gemäß Tabelle
11.
(1) Für k = 1, 2, . . . , n
yk = xk = k–te Komponente von x
(2) Für k = n + 1, n + 2, . . . , n + t
yk = eine der Formeln in Tabelle 10 Spalte 2
(3) f(x) = yn+t
Tabelle 11: Algorithmus FUN zur Berechnung von f(x)
Dann sind die Funktionen Φk bekannt, und damit auch die Funktionen Φ ′ k. Es sei
¯yk := Φ ′ k(y1, y2, . . . , yk−1). (19)
Wegen der besonderen Gestalt von Φk enthält die Zeile ¯yk höchstens zwei von 0 verschiedene
Einträge. Ist zum Beispiel
yk = Φk(y1, y2, . . . , yk−1) = yi · yj

3 RÜCKWÄRTS–METHODE 19
mit i �= j, so gilt
¯yk = Φ ′ k(y1, y2, . . . , yk−1) = [0, . . . , 0, yj, 0, . . . , 0, yi, 0, . . . , 0]
mit yj in Spalte i und yi in Spalte j. Die update–Vorschrift in Tabelle 9 Block (2.2)
für µ = 1, 2, . . . , k − 1
Uµ ← Uµ + Uk · Φ ′ k(y1, y2, . . . , yk−1)µ
schmilzt daher zusammen auf höchstens zwei updates der Gestalt
Ui ← Ui + Uk · ¯yki
Uj ← Uj + Uk · ¯ykj
In Tabelle 10 sind für alle auftretenden Fälle die ¯yki und/oder ¯ykj angeben.
Zur Einsparung von Operationen setzen wir
(20)
(21)
Ski := Uk · ¯yki für Tk ∈ {A,S,M,D,AV,MV,AVC,SVC,MVC,DVC} (22)
Skj := Uk · ¯ykj für Tk ∈ {A,M,ACV,MCV} (23)
Skj := −Uk · ¯ykj für Tk ∈ {S,D,SCV,DCV,VW} (24)
Damit erhalten wir aus (20) und (21) die endgültigen update–Formeln
Ui ← Ui + Ski für Tk ∈ {A,S,M,D,AV,MV,AVC,SVC,MVC,DVC} (25)
Uj ← Uj + Skj für Tk ∈ {A,M,ACV,MCV} (26)
Uj ← Uj − Skj für Tk ∈ {S,D,SCV,DCV,VW} (27)
Den so präzisierten Algorithmus zur Berechnung von f(x) und f ′ (x) nennen wir jetzt
RM (Rückwärts–Methode), siehe Tabelle 12.
(1) Berechne y1, y2, . . . , yn+t = f(x) mit Algorithmus FUN.
(2) Berechnung von f ′ (x):
(2.1) U ← [0, . . . , 0, 1] mit Länge n + t
(2.2) Für k = n + t, n + t − 1, . . . , n + 1 in dieser Reihenfolge
für Tk ∈ {A,S,M,D,AV,MV,AVC,SVC,MVC,DVC}
Ski ← gemäß Tabelle 10
Ui ← Ui + Ski
für Tk ∈ {A,M,ACV,MCV}
Skj ← gemäß Tabelle 10
Uj ← Uj + Skj
für Tk ∈ {S,D,SCV,DCV,VW}
Skj ← gemäß Tabelle 10
Uj ← Uj − Skj
(2.3) f ′ (x) ← [U1, U2, . . . , Un]
Tabelle 12: Algorithmus RM

3 RÜCKWÄRTS–METHODE 20
Wir definieren
#(f, f ′ , RM) := Anzahl der rationalen Operationen zur Berechnung
von f(x) und f ′ (x) mit RM.
Proposition 2: Für die Berechnung von f(x) und f ′ (x) mit dem Algorithmus RM
gilt
#(f, f ′ , RM) ≤ 5 · #(f, FUN).
Beweis: Block (1) kostet t Operationen. In Tabelle 10 ist unter #(Ski, Skj) angemerkt,
wie teuer Ski und/oder Skj sind. Für k = n + t, n + t − 1, . . . , n + 1 bezeichne
#(update,k) die Anzahl der in Block (2.2) Schritt k durchzuführenden update–
Operationen. Offensichtlich ist #(update,k) höchstens 2. Somit ergibt sich
#(f, f ′ , RM) = t +
≤ t +
n+t
�
k=n+1
n+t
�
k=n+1
(#(Ski, Skj) + #(update, k))
(2 + 2) = 5t = 5 · #(f, FUN).
Die Abschätzung in Proposition 2 ist scharf. Wenn im Algorithmus FUN nur Operationen
vom Typ M oder D auftreten, dann wird obige Ungleichung zu einer Gleichung.
Zur Durchführung des Algorithmus RM werden zwei Listen der Länge n+t benötigt,
eine für die Werte y1, y2, . . . , yn+t, und eine für die Arbeitszeile U. Vergleicht man die
Vorwärts–Methode mit Überschreiben und die Rückwärts–Methode, so zeigt sich, daß
im allgemeinen der Bedarf an Speicherplätzen bei der Vorwärts–Methode sehr viel
kleiner ist als der Bedarf an Speicherplätzen bei der Rückwärts–Methode.
Man kann den Algorithmus RM noch verfeinern zu einem Algorithmus RM1. Dabei
wird berücksichtigt, daß in Block (2.2) zu Beginn die Arbeitszeile U bis auf Un+t = 1
nur “System–Nullen” enthält. Eine Addition zu einer System–Null kann bei geeigneter
Buchführung vermieden werden, eine Subtraktion erfordert einen Vorzeichen–Wechsel.
Dies liefert allerdings nur
#(f, f ′ , RM1) < 5 · #(f, FUN).
Eine weitere Verfeinerung vom RM1 zu einem Algorithmus RM2 ist möglich, wenn
man in Block (2.2) fällige Vorzeichen–Wechsel nicht sofort ausführt, sondern erst am
Ende von Block (2.2). Einzelheiten sind in [57] ausführlich beschrieben. Ohne Beweis
geben wir folgendes Ergebnis an.
Proposition 3: Für die Berechnung von f(x) und f ′ (x) mit dem Algorithmus RM2
gilt
#(f, f ′ , RM2) ≤ 4 · #(f, FUN).
Funktionswert f(x) und Ableitungswert f ′ (x) zusammen, berechnet mit RM2, kosten
also höchstens 4–mal soviel wie der Funktionswert alleine.
⊓⊔

3 RÜCKWÄRTS–METHODE 21
Beispiel 3
Aller Erfahrung nach haben Leser, denen Automatisches Differenzieren noch neu ist,
Schwierigkeiten mit der Rückwärts–Methode. Wir wollen daher den Algorithmus RM
an einem einfachen Beispiel vorführen. Mit folgendem Schema FUN
y1 = x1
y2 = x2
y3 = y1 · y2
y4 = y3 − 7
y5 = y1 + y2
y6 = y4/y5
f(x) = y6
wird eine Funktion f : D ⊆ IR 2 → IR definiert. Für x = (3, 8) sollen Funktionswert
f(x) und Ableitungswert f ′ (x) berechnet werden.
Gemäß RM Block (1) erzeugen wir
y1 = x1 = 3
y2 = x2 = 8
y3 = y1 · y2 = 24
y4 = y3 − 7 = 17
y5 = y1 + y2 = 11
y6 = y4/y5 = 17
11
Somit ist f(3, 8) = 17
11 und die Werte y1, y2, . . . , y6 stehen zur Verfügung.
Gemäß RM Block (2) setzen wir
U ← [0, 0, 0, 0, 0, 1].
Diese Arbeitszeile U wird nun schrittweise umgeformt. Wir geben alle dazu nötigen
Einzelheiten an.
k = 6 : T6 = D, i = 4, j = 5
S64 ← U6/y5 = 1/11 = 1
11 und U4 ← U4 + S64 = 0 + 1
11
S65 ← S64 · y6 = 1 17 · 11 11
k = 5 : T5 = A, i = 1, j = 2
= 1
11
= 17
121 und U5 ← U5 − S65 = 0 − 17
121
S51 ← U5 = − 17
121 und U1 ← U1 + S51 = 0 + (− 17 17 ) = − 121 121
S52 ← U5 = − 17
121 und U2 ← U2 + S52 = 0 + (− 17 17 ) = − 121 121
k = 4 : T4 = SVC, i = 3
S43 ← U4 = 1
11 und U3 ← U3 + S43 = 0 + 1
11
k = 3 : T3 = M, i = 1, j = 2
= 1
11
S31 ← U3 · y2 = 1 8 · 8 = 11 11 und U1 ← U1 + S31 = − 17 8 + 121 11
S32 ← U3 · y1 = 1 3 · 3 = 11 11 und U2 ← U2 + S32 = − 17 3 + 121 11
= − 17
121
= 71
121
= 16
121

3 RÜCKWÄRTS–METHODE 22
Schließlich erhalten wir f ′ (3, 8) = [U1, U2] =
� �
71 16
, .
121 121

REFERENCES 23
References
[1] Aberth, O.: Precise Numerical Analysis. William C.Brown Publishers, Dubuque,
Iowa, USA, 1988.
[2] Aida-Zade, K.R., Evtushenko, Yu.G.: Bystroe avtomaticheskoe differentsirovanie
na EVM. Matematicheskoe Modelirovanie 1, 1989, 120-131.
[3] Arbenz, P., Gander, W.: Solving nonlinear eigenvalue problems by algorithmic
differentiation. Computing 36, 1986, 205-215.
[4] Bartholomew-Biggs, M.C., Bartholomew-Biggs, L., Christianson, B.: Optimization
and Automatic Differentiation in Ada: Some practical experience. Optimization
Methods and Software 4, 1994, 47-73.
[5] Barton, D.: On Taylor series and stiff equations. ACM Transactions on Mathematical
Software 6, 1980, 280-294.
[6] Barton, D., Willers, I.M., Zahar, R.V.M.: Taylor series methods for ordinary
differential equations - an evaluation. In: Mathematical Software, ed. by J.Rice,
Academic Press, New York, 1971, 369-390.
[7] Baur, W., Strassen, V.: The complexity of partial derivatives. Theoretical Computer
Science 22, 1983, 317-330.
[8] Beck, T.: Automatisches Differenzieren von Algorithmen. Dissertation, Technische
Universität München, 1991.
[9] Beck, T.: Automatic differentiation of iterative processes. Journal of Computational
and Applied Mathematics 50, 1994, 109-118.
[10] Beck, T., Fischer, H.: The if-problem in automatic differentiation. Journal of
Computational and Applied Mathematics 50, 1994, 119-131.
[11] Beda, L.M., Korolev, L.N., Sukkikh, N.V., Frolova, T.S.: Programme zum Automatischen
Differenzieren für die Maschine BESM, (in Russisch). Technischer
Bericht, Akademie der Wissenschaften der UdSSR, Moskau, 1959.
[12] Berz, M.: Differential algebra - A new tool. In: Proceedings of the 1989 IEEE Particle
Accelerator Conference, March 20-23, 1989, ed. by F.Bennet and J.Kopta,
IEEE, 1989.
[13] Berz, M.: Forward algorithms for higher derivatives in many variables with applications
to beam physics. In [70], 147-156.
[14] Berz, M.: Automatic differentiation as nonarchimedean analysis. In: Computer
Arithmetic and Enclosure Methods, ed. by L.Atanassova and J.Herzberger, Elsevier
(North-Holland), Amsterdam, 1992, 439-450.
[15] Bischof, Ch.H.: Issues in parallel automatic differentiation. In [70], 100-113.

REFERENCES 24
[16] Bischof, Ch., Carle, A., Corliss, G.F., Griewank, A.: ADIFOR: Automatic differentiation
in a source translator environment. Preprint MCS-P288-0192, Argonne
National Laboratory, 1992.
[17] Bischof, Ch., Griewank, A.: ADIFOR: A Fortran system for portable automatic
differentiation. Preprint MCS-P317-0792, Argonne National Laboratory, 1992.
[18] Bischof, Ch., Griewank, A., Juedes, D.: Exploiting parallelism in automatic
differentiation. In: Proceedings of the 1991 International Conference on Supercomputing,
ed. by E.Houstis and Y.Muraoka, ACM Press, 1991, 146-153.
[19] Bohlender, G., Rall, L.B., Ullrich, Ch., Wolff von Gudenberg, J.: PASCAL-
SC: Wirkungsvoll programmieren, kontrolliert rechnen. Bibliographisches Institut,
Zürich, 1986.
[20] Carlile, B.R.: Solution of nonlinear systems of equations on the FPS 64-bit family
of scientific computers using automatic differentiation. In: Proceedings of the
1986 Array Conference, Portland, Oregon, 1986, 142-169.
[21] Christianson, B.: Automatic Hessians by reverse accumulation. IMA Journal of
Numerical Analysis 12, 1992, 135-150.
[22] Christianson, B.: Reverse accumulation and accurate rounding error estimates
for Taylor series coefficients. Optimization Methods and Software 1, 1992, 81-94.
[23] Christianson, B.: Reverse accumulation and attractive fixed points. Optimization
Methods and Software 3, 1994, 311-326.
[24] Corliss, G.F.: Computing narrow inclusions for definite integrals. In: Computerarithmetic,
Scientific Computation and Programming Languages, ed. by
E.Kaucher, U.Kulisch, Ch.Ullrich, Teubner-Verlag, Stuttgart, 1987, 150-169.
[25] Corliss, G.F.: Applications of differentiation arithmetic. In: Reliability in Computing:
The Role of Interval Methods in Scientific Computing, ed. by R.E.Moore,
Academic Press, London, 1988, 127-148.
[26] Corliss, G.F.: Overloading point and interval Taylor operators. In [70], 139-146.
[27] Corliss, G.F., Chang, Y.F.: Solving ordinary differential equations using Taylor
series. ACM Transactions on Mathematical Software 8, 1982, 114-144.
[28] Corliss, G., Rall, L.B.: Automatic generation of Taylor series in PASCAL-SC:
Basic operations and applications to ordinary differential equations. In: Transactions
of the First Army Conference on Applied Mathematics and Computing,
U.S. Army Research Office, Research Triangle Park, NC, 1984, 177-209.
[29] Corliss, G., Rall, L.B.: Adaptive, self-validating numerical quadrature. SIAM
Journal on Scientific and Statistical Computing 8, 1987, 831-847.

REFERENCES 25
[30] Cuyt, A.A.M., Rall, L.B.: Computational implementation of the multivariate
Halley method for solving nonlinear systems of equations. ACM Transactions on
Mathematical Software 11, 1985, 20-36.
[31] Davis, P.H., Pryce, J.D.: A New Implementation of Automatic Differentiation
for Use with Numerical Software. Technical Report AM-87-11, School of Mathematics,
University of Bristol, 1987.
[32] Davis, P.H., Pryce, J.D., Stephens, B.: Recent developments in automatic differentiation.
In: Scientific Software Systems, ed. by J.C.Mason and M.G.Cox,
Chapman and Hall, London, 1990, 153-165.
[33] Davis, P.H., Stephens, B., Corliss, G.F., Krenz, G.S.: Specification of a Preprocessor
for Use with Differentiation Arithmetic. Technical Report AM-88-08,
School of Mathematics, University of Bristol, 1988.
[34] Dixon, L.C.W.: Automatic differentiation and parallel processing in optimisation.
In: Optimization, Parallel Processing and Applications, ed. by
A.Kurzhanski, K.Neumann, D.Pallaschke, (Lecture Notes in Economics and
Mathematical Systems 304), Springer-Verlag, Berlin, 1988, 86-93.
[35] Dixon, L.C.W.: On the impact of automatic differentiation on the relative performance
of parallel truncated Newton and variable metric algorithms. SIAM
Journal on Optimization 1, 1991, 475-486.
[36] Dixon, L.C.W.: Use of automatic differentiation for calculating Hessians and
Newton steps. In [70], 114-125.
[37] Dixon, L.C.W., Maany, Z., Mohseninia, M.: Finite Element Optimisation in ADA
using Automatic Differentiation. Technical Report 205, Numerical Optimisation
Centre, Hatfield Polytechnic, 1988.
[38] Dixon, L.C.W., Maany, Z., Mohseninia, M.: Automatic differentiation of large
sparse systems. Journal of Economic Dynamics and Control 14, 1990, 299-311.
[39] Dixon, L.C.W., Price, R.C.: Truncated Newton method for sparse unconstrained
optimization using automatic differentiation. Journal of Optimization Theory and
Applications 60, 1989, 261-275.
[40] Evtushenko, Yu.G.: Automatic differentiation viewed from optimal control theory.
In [70], 25-30.
[41] Fischer, H.: Some aspects of automatic differentiation. In: Numerical Methods
and Approximation Theory III, ed. by G.V. Milovanović, University of Niˇs, Yugoslavia,
1988, 199-208.
[42] Fischer, H.: Automatic differentiation: Fast method to compute the quadratic
form of Hessian matrix and given vector. Facta Universitatis (Niˇs),
Ser.Math.Inform.3, 1988, 51-59.

REFERENCES 26
[43] Fischer, H.: Automatic differentiation of characterizing sequences. Journal of
Computational and Applied Mathematics 28, 1989, 181-185.
[44] Fischer, H.: Fast method to compute the scalar product of gradient and given
vector. Computing 41, 1989, 261-265.
[45] Fischer, H.: Automatic differentiation: Parallel computation of function, gradient,
and Hessian matrix. Parallel Computing 13, 1990, 101-110.
[46] Fischer, H.: Automatic and parallel generation of gradient and Hessian matrix.
In: System Modelling and Optimization, ed. by H.J.Sebastian and K.Tammer,
(Lecture Notes in Control and Information Sciences 143), Springer-Verlag, Berlin,
1990, 104-114.
[47] Fischer, H.: Automatic differentiation of the vector that solves a parametric linear
system. Journal of Computational and Applied Mathematics 35, 1991, 169-184.
[48] Fischer, H.: Special problems in automatic differentiation. In [70], 43-50.
[49] Fischer, H.: Automatic differentiation: Reduced gradient and reduced Hessian
matrix. Computational Optimization and Applications 1, 1992, 327-344.
[50] Fischer, H.: Automatisches Differenzieren. In: Wissenschaftliches Rechnen -
Eine Einführung in das Scientific Computing. edited by J.Herzberger, Akademie-
Verlag, Berlin, 1995, 53-104.
[51] Fischer, H.: Automatic differentiation: The key idea and an illustrative example.
In: Applied Mathematics and Parallel Computing, edited by H.Fischer,
B.Riedmüller, S.Schäffler, Physica-Verlag, Heidelberg, 1996, 121–139.
[52] Automatic Differentiation: Root Problem and Branch Problem. In: Encyclopedia
of Optimization, Kluwer Academic Publishers, 2001, edited by C.A.Floudas,
P.M.Pardalos.
[53] Algorithmic Differentiation with Intervals. In: Inclusion Methods for Nonlinear
Problems, with Applications in Engineering, Economics and Physics, edited by
J.Herzberger, Springer-Verlag, Computing Supplementum 16, 2002, 45–65.
[54] Fischer, H., Flanders, H.: A minimal code list. Theoretical Computer Science
215, 1999, 345–348.
[55] Fischer, H., Hertneck, Ch.: Gradient and Hessian matrix forward with functions
version A in ANSI-C. Technical Report IAMS1995.8TUM, Institut für Angewandte
Mathematik und Statistik, Technische Universität München, 1995.
[56] Fischer, H., Schäffler, S., Warsitz, H.: Parameter estimation in linear regression
models with stationary ARMA(p,q)-errors using automatic differentiation.
Yugoslav Journal of Operations Research 2, 1992, 55-68.
[57] Fischer, H., Warsitz, H.: Complexity of derivatives generated by symbolic differentiation.
In: Computer Algebra in Scientific Computing, Proceedings of the
Third Workshop on Computer Algebra in Scientific Computing, CASC-2000,
Samarkand, October 5–9, 2000, ed. by V.G.Ganzha, E.W.Mayr, E.V.Vorozhtsov,
Springer-Verlag, 2000, 129–144.

REFERENCES 27
[58] Fischer, H.C.: Schnelle automatische Differentiation, Einschlie”sungsmethoden
und Anwendungen. Dissertation, Universität Karlsruhe, 1990.
[59] Fischer, H.C.: Effiziente Berechnung von Ableitungswerten, Gradienten und Taylorkoeffizienten.
In: Jahrbuch Überblicke Mathematik 1992, ed. by S.D. Chatterji,
B. Fuchssteiner, U. Kulisch, R. Liedl, W. Purkert, Vieweg-Verlag, Braunschweig,
1992, 59-73.
[60] Gander, W.: Computermathematik. Birkhäuser Verlag, Basel, 1985.
[61] Garcia, O.: A system for the differentiation of Fortran code and an application
to parameter estimation in forest growth models. In [70], 273-285.
[62] Gay, D.: Automatic differentiation of nonlinear AMPL models. In [70], 61-73.
[63] Gilbert, J.C.: Automatic differentiation and iterative processes. Optimization
Methods and Software 1, 1992, 13-21.
[64] Gilbert, J.C., Le Vey, G., Masse, J.: La différentiation automatique de fonctions
représentées par de programmes et son application à l’analyse d’erreurs. Compte
rendu de la journee différentiation automatique, 11 Octobre 1991, Centre National
d’Etudes Spatiales, Toulouse, France.
[65] Grandinetti, L., Conforti, D.: Numerical comparisons of nonlinear programming
algorithms on serial and vector processors using automatic differentiation. Mathematical
Programming 42, 1988, 375-389.
[66] Greiner, M., Kredler, Ch.: PADMOS und PADFIT - Automatisches Differenzieren
und nichtlineare Optimierung in MS-DOS. In: Multimedia, Vernetzung
und Software für die Lehre, ed. by K.Dette and P.J.Pahl, Springer-Verlag, Berlin,
1992, 255-264.
[67] Griewank, A.: On Automatic Differentiation. In: Mathematical Programming
- Recent Developments and Applications, ed. by M.Iri and K.Tanabe, Kluwer
Academic Publishers, Dordrecht, Holland, 1989, 83-107.
[68] Griewank, A.: Automatic evaluation of first and higher-derivative vectors. In:
Bifurcation and Chaos: Analysis, Algorithms, Applications, ed. by R.Seydel,
F.W.Schneider, T.Küpper, H.Troger, (International Series of Numerical Mathematics
97), Birkhäuser Verlag, Basel, 1991, 135-148.
[69] Griewank, A.: Achieving logarithmic growth of temporal and spatial complexity
in reverse automatic differentiation. Optimization Methods and Software 1, 1992,
35-54.
[70] Griewank, A., Corliss, G.F. (editors): Automatic Differentiation of Algorithms:
Theory, Implementation, and Application. SIAM, Philadelphia, 1991.
[71] Griewank, A., Juedes, D., Srinivasan, J.: ADOL-C, A Package for the Automatic
Differentiation of Algorithms Written in C/C++. Preprint MCS-P180-1190, Argonne
National Laboratory, 1991.
[72] Hammer, R., Hocks, M., Kulisch, U., Ratz, D.: Numerical Toolbox for Verified
Computing I. Springer-Verlag, Berlin, 1993.

REFERENCES 28
[73] Hillstrom, K.E.: JAKEF - A portable symbolic differentiator of functions given
by algorithms. Technical Report ANL-82-48, Argonne National Laboratory, 1982.
[74] Horwedel, J.E.: GRESS, a preprocessor for sensitivity studies of Fortran programs.
In [70], 243-250.
[75] Horwedel, J.E.: Reverse automatic differentiation of modular FORTRAN programs.
Technical Memorandum ORNL/TM 12050, Computing and Telecommunications
Division, Oak Ridge National Laboratory, 1992.
[76] Huss, R.: An Ada library for automatic evaluation of derivatives. Applied Mathematics
and Computation 35, 1990, 103-123.
[77] Iri, M.: Simultaneous computation of functions, partial derivatives and estimates
of rounding errors, complexity and practicality. Japan Journal of Applied Mathematics
1, 1984, 223-252.
[78] Iri, M.: History of automatic differentiation and rounding error estimation. In
[70], 3-16.
[79] Iri, M., Kubota, K.: Methods of fast automatic differentiation and applications.
Research Memorandum RMI 87-02, Department of Mathematical Engineering
and Instrumentation Physics, Faculty of Engineering, University of Tokyo, 1987.
[80] Iri, M., Kubota, K., Murota, K.: Geometrical/geographical optimization and
fast automatic differentiation. Yugoslav Journal of Operations Research 1, 1991,
121-134.
[81] Iri, M., Tsuchiya, T., Hoshi, M.: Automatic computation of partial derivatives
and rounding error estimates with applications to large-scale systems of nonlinear
equations. Journal of Computational and Applied Mathematics 24, 1988, 365-392.
[82] Jackson, R.H.F., McCormick, G.P.: The polyadic structure of factorable function
tensors with applications to high-order minimization techniques. Journal of
Optimization Theory and Applications 51, 1986, 63-94.
[83] Jackson, R.H.F., McCormick, G.P.: Second-order sensitivity analysis in factorable
programming: theory and applications. Mathematical Programming 41,
1988, 1-27.
[84] Jerrell, M.E.: Function minimization and automatic differentiation using C++.
In: Object-Oriented Programming: Systems, Languages and Applications, ed.
by N.Meyrowitz, special issue of ACM SIGPLAN Notices, Vol.24, No.10, 1989,
169-173.
[85] Jerrell, M.E.: Automatic differentiation using almost any language. ACM
SIGNUM Newsletter, Vol.24, No.1, 1989, 2-9.
[86] Jerrell, M.E.: Automatic differentiation in C++. Journal of Object Oriented
Programming 3, 1990, 17-24.
[87] Juedes, D.W.: A taxonomy of automatic differentiation tools. In [70], 315-329.

REFERENCES 29
[88] Kagiwada, H., Kalaba, R., Rasakhoo, N., Spingarn, K.: Numerical Derivatives
and Nonlinear Analysis. Plenum Press, New York, 1986.
[89] Kalaba, R., Plum, T., Tesfatsion, L.: Automation of nested matrix and derivative
operations. Applied Mathematics and Computation 23, 1987, 243-268.
[90] Kalaba, R., Tesfatsion, L.: Automatic differentiation of functions of derivatives.
Computers and Mathematics with Applications 12A, 1986, 1091-1103.
[91] Kalaba, R., Tesfatsion, L., Wang, J.: A finite algorithm for the exact evaluation
of higher order partial derivatives of functions of many variables. Journal of
Mathematical Analysis and Applications 92, 1983, 552-563.
[92] Kalaba, R., Tishler, A.: A computer program to minimize a function with many
variables using computer evaluated exact high-order derivatives. Applied Mathematics
and Computation 13, 1983, 143-172.
[93] Kalaba, R., Tishler, A.: Generalized Newton algorithm to minimize a function
with many variables using computer-evaluated exact higher-order derivatives.
Journal of Optimzation Theory and Applications 42, 1984, 383-395.
[94] Kalman, D., Lindell, R.: Automatic differentiation in astrodynamical modeling.
In [70], 228-239.
[95] Kedem, G.: Automatic differentiation of computer programs. ACM Transactions
on Mathematical Software 6, 1980, 150-165.
[96] Kelch, R.: Self-validating numerical quadrature. In: Accurate Numerical Algorithms
- A Collection of Research Papers, ed. by Ch.Ullrich and J. Wolff von Gudenberg,
(Research Report ESPRIT, Project 1072, DIAMOND, Vol.1), Springer-
Verlag, Berlin, 1989, 162-202.
[97] Kelevedzhiev, E., Yantcheva, T.: Application of automatic differentiation to the
Hessian matrix evaluation. In: Proceedings of Twenty First Spring Conference
of the Union of Bulgarian Mathematicians, Sofia, April 3-6, 1992, 86-91.
[98] Kim, K.V., Nesterov, Yu.E., Cherkasskiĭ, B.V.: An estimate of the effort in
computing the gradient. Soviet Mathematics Doklady, Vol.29, 1984, 384-387.
[99] Kredler, Ch.: Anwendungen des automatischen Differenzierens in der Strukturoptimierung.
ZAMM 69, 1989, T91-T93.
[100] Kredler, Ch.: Robust sequential active set programming: Theory and implementation
details. Report 227, DFG-Schwerpunkt: Anwendungsbezogene Optimierung
und Steuerung, Technische Universität München, 1990.
[101] Kubota, K., Iri, M.: Estimates of rounding errors with fast automatic differentiation
and interval analysis. Journal of Information Processing 14, 1991, 508-515.
[102] Lawson, C.L.: Automatic differentiation of inverse functions. In [70], 87-94.
[103] Layne, J.D.: Applying automatic differentiation and self-validation numerical
methods in satellite simulations. In [70], 211-217.

REFERENCES 30
[104] Liepelt, M., Schittkowski, K.: PCOMP: A FORTRAN Code for Automatic Differentiation.
Report 254, DFG-Schwerpunkt: Anwendungsbezogene Optimierung
und Steuerung, Universität Bayreuth, 1990.
[105] Lohner, R.: Einschlie”sung der Lösung gewöhnlicher Anfangs- und Randwertaufgaben
und Anwendungen. Dissertation, Universität Karlsruhe, 1988.
[106] Lohner, R.: Verified Computing and Programs in PASCAL-XSC. Habilitationsschrift,
Universität Karlsruhe, 1994.
[107] Maany, Z.: Ada automatic differentiation packages. Technical Report 209, Numerical
Optimisation Centre, Hatfield Polytechnic, 1989.
[108] Matijasevich, Yu.V.: A posteriori interval analysis. In: EUROCAL’85, ed. by Bob
F.Caviness, (Lecture Notes in Computer Science 204), Springer–Verlag, Berlin,
1985, 328-334.
[109] Mazourik, V.: Integration of automatic differentiation into application programs
for PC’s. In [70], 286-293.
[110] McCormick, G.P.: Nonlinear Programming. Wiley, New York, 1983.
[111] Mehlhorn, R., Sachs, G.: A new tool for efficient optimization by automatic
differentiation and program transparency. Optimization Methods and Software
4, 1994, 225-242.
[112] Michelotti, L.: MXYZPTLK: A C++ hacker’s implementation of automatic differentiation.
In [70], 218-227.
[113] Miller, W., Wrathall, C.: Software for Roundoff Analysis of Matrix Algorithms.
Academic Press, New York, 1980.
[114] Moore, R.E.: Methods and Applications of Interval Analysis. SIAM Studies in
Applied Mathematics, Philadelphia, 1979.
[115] Musaev, E.A.: Narrowing of intervals by partial derivatives. Interval Computations
1, 1991, 86-91.
[116] Neidinger, R.D.: An efficient method for the numerical evaluation of partial
derivatives of arbitrary order. ACM Transactions on Mathematical Software 18,
1992, 159-173.
[117] Neumaier, A.: Interval Methods for Systems of Equations. Cambridge University
Press, Cambridge 1990.
[118] Ostrowski, G.M., Wolin, Yu.M., Borisow, W.W.: Über die Berechnung von
Ableitungen. Wissenschaftliche Zeitschrift Technische Hochschule für Chemie,
Leuna-Merseburg, Vol.13, 1971, 382-384.
[119] Pfeiffer, F.W.: Automatic Differentiation in PROSE. ACM SIGNUM Newsletter,
Vol.22, No.1, January 1987, 2-8.

REFERENCES 31
[120] Rall, L.B.: Applications of software for automatic differentiation in numerical
computation. In: Fundamentals of Numerical Computation, ed. by G.Alefeld
and R.D.Grigorieff, (Computing Supplementum 2), Springer-Verlag, Wien, 1980,
141-156.
[121] Rall, L.B.: Automatic Differentiation: Techniques and Applications. (Lecture
Notes in Computer Science 120), Springer-Verlag, Berlin, 1981.
[122] Rall, L.B.: Differentiation and generation of Taylor-coefficients in PASCAL-
SC. In: A New Approach to Scientific Computation, ed. by U.Kulisch and
W.L.Miranker, Academic Press, New York, 1983, 291-309.
[123] Rall, L.B.: Differentiation in PASCAL-SC: type GRADIENT. ACM Transactions
on Mathematical Software 10, 1984, 161-184.
[124] Rall, L.B.: Global optimization using automatic differentiation and interval iteration.
Technical Summary Report 2832, Mathematics Research Center, University
of Wisconsin, Madison, 1985.
[125] Rall, L.B.: Improved interval bounds for ranges of functions. In: Interval Mathematics
1985, ed. by K.Nickel, (Lecture Notes in Computer Science 212), Springer-
Verlag, Berlin, 1986, 143-155.
[126] Rall, L.B.: Optimal implementation of differentiation arithmetic. In: Computerarithmetic,
Scientific Computation and Programming Languages, ed. by
E.Kaucher, U.Kulisch, Ch.Ullrich, Teubner-Verlag, Stuttgart, 1987, 287-295.
[127] Rall, L.B.: Differentiation arithmetics. In: Computer Arithmetic and Self-
Validating Numerical Methods, ed. by Ch.Ullrich, (Notes and Reports in Mathematics
in Science and Engineering, Vol.7), Academic Press, New York, 1990,
73-90.
[128] Rall, L.B.: Point and interval differentiation arithmetics. In [70], 17-24.
[129] Rich, L.C., Hill, D.R.: Automatic differentiation in MATLAB. Applied Numerical
Mathematics 9, 1992, 33-43.
[130] Rosemblun, M.: Automatic Differentiation: Overview and Application to Systems
of Parametrized Nonlinear Equations. Technical Report CRPC-TR92262,
Center for Research on Parallel Computation, Rice University, 1992.
[131] Saarinen, S., Bramley, R.B., Cybenko, G.: Neural networks, backpropagation,
and automatic differentiation. In [70], 31-42.
[132] Sawyer, J.W.: First partial differentiation by computer with an application to
categorial data analysis. The American Statistician 38, 1984, 300-308.
[133] Shiriaev, D.: Reduction of spatial complexity in reverse automatic differentiation
by means of inverted code. In: Computer Arithmetic and Enclosure Methods, ed.
by L.Atanassova and J.Herzberger, Elsevier (North-Holland), Amsterdam, 1992,
475-484.

REFERENCES 32
[134] Shiriaev, D.: Fast Automatic Differentiation for Vector Processors and Reduction
of the Spatial Complexity in a Source Translation Environment. Dissertation,
Universität Karlsruhe, 1993.
[135] Soulié, E.J.: User’s experience with FORTRAN compilers in least squares problems.
In [70], 297-306.
[136] Speelpenning, B.: Compiling fast partial derivatives of functions given by algorithms.
Ph.D.Thesis, Department of Computer Science, University of Illinois,
Urbana-Champaign, 1980.
[137] Stephens, B.R., Pryce, J.D.: DAPRE, A Differentiation Arithmetic System for
FORTRAN. Technical Report ACM-91-3, Royal Military College of Science,
Shrivenham, UK, 1991.
[138] Tesfatsion, L.: Automatic evaluation of higher-order partial derivatives for nonlocal
sensitivity analysis. In [70], 157-165.
[139] Thacker, W.C.: Automatic differentiation from an oceanographer’s perspective.
In [70], 191-201.
[140] van den Heuvel, P., van Hulzen, J.A., Goldmann, V.V.: Automatic generation
of FORTRAN-coded Jacobians and Hessians. In: Proceedings of EUROCAL 87,
ed. by J.Davenport, (Lecture Notes in Computer Science 378), Springer-Verlag,
Berlin, 1987, 120-131.
[141] Van Iwaarden, R.: Automatic differentiation applied to unconstrained nonlinear
optimization with result verification. Interval Computations, No.3, 1993, 41-60.
[142] Volin, Yu.M., Ostrovskii, G.M.: Automatic computation of derivatives with the
use of the multilevel differentiation technique - 1. Algorithmic basis. Computers
and Mathematics with Applications 11, 1985, 1099-1114.
[143] Warner, D.D.: A partial derivative generator. Computing Science Technical Report
No.28, Bell Telephone Laboratories, Murray Hill, N.J., 1975.
[144] Wexler, A.: Automatic evaluation of derivatives. Applied Mathematics and Computation
24, 1987, 19-46.
[145] Wexler, A.: An algorithm for exact evaluation of multivariate functions and their
derivatives to any order. Computational Statistics and Data Analysis 6, 1988, 1-6.
file vorlesung123.tex