Beim funktionalen Konzept werden Transformationen als Funktionsaufrufe realisiert, in wel-chen eine genaue syntaktische Analyse der (ausgewerteten) Aufrufparameter erfolgt und danach entsprechend verzweigt wird.
Da in die Abarbeitung eines solchen Funktionsaufrufs die Struktur der Argumente mit eingeht, werden dazu Funktionen ben¨otigt, welche diese Struktur wenigstens teilweise analysieren.Maple verf¨ugt f¨ur diesen Zweck ¨uber die Funktion type(A,T), die pr¨uft, ob ein AusdruckA den
”Typ“
T hat.
Wie bereits an anderer Stelle erw¨ahnt handelt es sich dabei allerdingsnicht um ein strenges Typkonzept f¨ur Variablen, sondern um eine syntaktische Typanalyse f¨ur Ausdr¨ucke, die in der Regel nur die Syntax der obersten Ebene des Ausdrucks analysiert (z. B. entspre-chende Schl¨usselworte an der Stelle 0 der zu-geh¨origen Liste auswertet) oder ein mit dem Bezeichner verbundenes Typschl¨usselwort ab-greift. Dies erkennen wir etwa an nebenstehen-dem Beispiel.
exp(ln(x));
x h:=exp(ln(x)+ln(y));
eln(x)+ln(y)
simplify(h);
x y
Die Struktur des Arguments verbirgt im zweiten Beispiel die Anwendbarkeit der Transformations-regel. Erst nach eingehender Analyse, die mitsimplifyangestoßen wird, gelingt die Umformung.
Betrachten wir als Beispiel die Definition der Exponentialfunktion inMaple, was mitprint(exp) angezeigt werden kann, nachdeminterface(verboseproc=2)gesetzt wurde:
proc(x::algebraic)
local res, i, t, q, n, f, r;
option builtin = HFloat_exp,
‘Copyright (c) 1992 by the University of Waterloo. All rights reserved.‘;
if nargs <> 1 then error "expecting 1 argument, got %1", nargs elif type(x, ’complex(float)’) then return evalf(’exp’(x)) elif type(x, ’rational’) then res := ’exp’(x)
elif type(x, ’function’) and op(0, x) = ’ln’ then res := op(1, x) elif ...
elif type(x, ’‘*‘’) and type(-I*x/Pi, ’rational’) then i := -I*x/Pi;
if 1 < i or i <= -1 then
t := trunc(i); t := t + irem(t, 2); res := exp((i - t)*Pi*I) elif type(6*i, ’integer’) or type(4*i, ’integer’) then
res := cos(-I*x) + sin(-I*x)*I else res := ’exp’(x)
end if elif ...
elif type(x, ’function’) and nops(x) = 1 then n := op(0, x);
t := op(1, x);
if n = ’arcsinh’ then res := t + sqrt(1 + t^2)
elif n = ’arccosh’ then res := t + sqrt(t + 1)*sqrt(t - 1) elif n = ’arctanh’ then res := (t + 1)/sqrt(1 - t^2) elif n = ’arccsch’ then res := 1/t + sqrt(1 + 1/t^2)
elif n = ’arcsech’ then res := 1/t + sqrt(1/t - 1)*sqrt(1/t + 1) elif n = ’arccoth’ then res := 1/sqrt((t - 1)/(t + 1))
else res := ’exp’(x) end if
elif ...
else res := ’exp’(x) end if;
exp(args) := res end proc
Zun¨achst
if nargs <> 1 then error "expecting 1 argument, got %1", nargs
H.-G. Gr¨abe: Einf¨uhrung in das symbolische Rechnen, Notizen zur Vorlesung 83
wird die Korrektheit der Anzahl der Aufrufargumente gepr¨uft. Die meisten Zeilen des folgenden Codes beginnen mittype(x, Art) und analysieren den Kopfterm des aufgerufenen Arguments.
Sehen wir uns die einzelnen Zeilen nacheinander an:
elif type(x, ’complex(float)’) then return evalf(’exp’(x))
untersucht, obxeine (reelle oder komplexe) float-Zahl ist und ruft in diesem Fallevalf(exp(x)) auf, was nach einer durchevalfausgel¨osten Funktionstransformation zu‘evalf/exp‘(x) trans-formiert wird. ‘evalf/fff‘(x)definiert ein einheitliches Konzept des Aufrufs von Funktionsde-finitionen zur numerischen Auswertung von Funktionen fff, das zur Laufzeit erweitert werden kann.
Ehe wir uns genauer anschauen, was im Fall eines Produkts ausgef¨uhrt wird, analysieren wir die an mehreren Stellen auftretende R¨uckgaberes:=‘exp‘(x)genauer.
In diesem Fall wird ein Funktionsausdruck mit dem Kopf exp und dem ausgewerteten Argu-mentxgebildet.
Am letzten Beispiel sehen wir noch einmal, dass das Argument vor dem Aufruf vonexpwirklich ausgewertet wurde.
exp(2/3);
exp 2
3
exp(27/3);
exp (9)
Die Zeile
elif type(x, ’function’) and op(0, x) = ’ln’ then res := op(1, x)
untersucht, ob das Argumentxein Funktionsausdruck mit dem Kopf lnist, und gibt in dem Fall das erste Element vonx= ln(z), alsoz, zur¨uck: exp(ln(z)) =z.
Weiter
elif type(x, ’‘*‘’) and type(-I*x/Pi, ’rational’) then
wird gepr¨uft, ob x ein Produkt ist, also mit dem Kopf * beginnt, und zus¨atzlich die Gestalt x=y·πimit y∈Qhat, da dann ey πizu cos(y π) + isin(y π) vereinfacht werden kann. Mit den Zeilen
y := -I*x/PI;
if 1 < y or y <= -1 then
t := trunc(i); t := t + irem(t, 2); res := exp((y - t)*Pi*I) wird untersucht, ob−1≤y <1 gilt, und
ande-renfalls in einem neuen Aufruf das Argumenty durch y−t ersetzt, wobeit eine ganze gerade Zahl mit−1≤y−t <1 ist. Dies entspricht der Anwendung der Identit¨at e2πi= 1.
exp(24/7*Pi*I);
e−4/7iπ
elif type(6*i, ’integer’) or type(4*i, ’integer’) then res := cos(-I*x) + sin(-I*x)*I
else res := ’exp’(x)
Die Verwandlung in cos(y π) + isin(y π) wird nur dann vorgenommen, wenn 4y oder 6y ei-ne ganze Zahl ist. Zusammen mit denMaple bekannten expliziten Werten der Winkelfunk-tionen an diesen Stellen ergibt sich das hier ge-zeigte Verhalten. Anderenfalls wird ein Funkti-onsausdruck mit dem Kopfexpzur¨uckgegeben.
exp(23/6*Pi*I);
1 2
√ 3−1
2 i
Die restlichen Zeilen realisieren die Funktions-transformationen exp(arcsinh(t)) =t+√
1 +t2 usw., die sich aus den entsprechenden Funkti-onsdefinitionen ergibt.
exp(arcsinh(t));
t+p 1 +t2
Das Beispiel zeigt, dass expeine Transformationsfunktion ist und die symbolischen F¨ahigkeiten eines CAS eingesetzt werden k¨onnen, um Polymorphie zu simulieren. Neue Funktionsbezeichner k¨onnen w¨ahrend des Aufrufs durch Stringoperationen erzeugt werden und auf vorhandene Funk-tionsdefinition verweisen, wie wir beim Zusammensetzen vonevalf(exp(x))zu‘evalf/exp‘(x) gesehen hatten.
Dieses Prinzip findet bei inerten Maple -Funktionen Anwendung. Schauen wir uns dazu noch einmal das Beispiel der FunktionFactor an, welche beim modularen Faktorisieren von Polynomen zu verwenden ist.
Factor(f) mod 2;
(x+ 1)3
Factor(f)wird unver¨andert zur¨uckgegeben undmoderkennt an der Strukturmod(Factor(f),p), dass modular zu faktorisieren ist. Schauen wir uns mitprint(‘mod/Factor‘)den Quellcode der speziellen modularen Faktorisierungsroutine‘mod/Factor‘(f,p) an, die hier aufgerufen wird.
proc(a)
local K, f, p;
option
‘Copyright (c) 1990 by the University of Waterloo. All rights reserved.‘;
if nargs = 3 then K := args[2]; p := args[3]
else K := NULL; p := args[2]
end if;
f := Factors(a, K) mod p;
f[1]*convert(map(proc(x) x[1]^x[2] end proc, f[2]), ‘*‘) mod p end proc
Der Funktionsrumpf enth¨alt die KombinationFactors(a, K) mod p, die nach denselben Regeln in
‘mod/Factors‘(f,p)umgesetzt wird und im Wesentlichen eine Liste von Paaren aud Primfaktor und Exponent zur¨uckgibt, die in der letzten Zeile mitconvertin ein Produkt verwandelt wird.
Die Nachteile des funktionalen Transformationskonzepts fallen sofort ins Auge:
1. Man hat mit jedem Funktionsaufruf eine Menge verschiedener Typinformationen zu ermit-teln, womit jeder Funktionsaufruf relativ aufw¨andige Operationen anst¨oßt. Deshalb ist es oft sinnvoll, bereits berechnete Funktionswerte zu speichern, wenn man weiß, dass sie sich nicht ver¨andern.
2. Die Typanalyse ist bei vielen Funktionen von ¨ahnlicher Bauart, so dass unn¨otig Code dupli-ziert wird.
3. Die so definierten Transformationsregeln sind relativ
”starr“. M¨ochte man z. B. das Verhal-ten der exp-Funktion dahingehend ¨andern, dass sie bei rein imagin¨arem Argumentimmer
H.-G. Gr¨abe: Einf¨uhrung in das symbolische Rechnen, Notizen zur Vorlesung 85
die trigonometrische Darstellung verwendet, so m¨usste man den gesamten oben gegebenen Code kopieren, an den entsprechenden Stellen ¨andern und dann die (nat¨urlich außerdem vor Uberschreiben gesch¨¨ utzte)exp-Funktion entsprechend redefinieren.