Definiert sei eine Funktion f(x) = 1/x, die wir mit limit auf ihren Grenzwert (limit) im Unendlichen (infinity) untersuchen. Dem Befehl wird die Funktion und die interessierende Stelle, an der nach dem Grenzwert gesucht werden soll, übergeben. Für das Verhalten im Unendlichen steht die Konstante infinity zur Verfügung.
> restart: > f := x -> 1/x: > limit(f(x), x=+infinity); 0 > limit(f(x), x=-infinity); 0Nun erfolgt die Untersuchung der Funktion f an der Stelle x=0:
> limit(f(x), x=0); undefined > f(0); Error, (in f) division by zeroLinks- und rechtsseitiger Grenzwert:
> Limit(f(x), x=0, left) = limit(f(x), x=0, left); Limit 1/x = - infinity x -> 0- > Limit(f(x), x=0, right) = limit(f(x), x=0, right); Limit 1/x = infinity x -> 0+Zusätzlich zu den Parametern Funktion und Stelle wird limit jetzt auch mitgeteilt, von welcher Seite aus der Grenzwert berechnet werden soll: von links (left) oder von rechts (right). Der Befehl Limit ist ein sogenanntes träges (inert) Kommando: Es bewirkt nicht die Errechnung, sondern dient nur der Anzeige unberechneter Formeln. Mit value können Sie eine Berechnung des trägen Ausdruckes erzwingen. Weitere träge Befehle finden sich im Kapitel 7.
Die Stetigkeit (continuity) überprüfen Sie mit iscont. Dieser Befehl muß vorher erst durch den Aufruf readlib(iscont) aktiviert und das zu untersuchende Intervall angegeben werden. Als optionalen dritten Parameter können Sie 'closed' (mit den Apostrophen) übergeben, dann wird das Intervall inklusive dessen Grenzen untersucht.
> readlib(iscont); proc(f:algebraic,z:name = range,opt) ... end > iscont(f(x), x=-1 .. 1); false'False' steht für die Unstetigkeit der Funktion im gegebenen Intervall, 'true' für die Stetigkeit. Die Funktion f(x) = 1/x ist im Intervall [-1, +1] nicht stetig.
> restart; > g := x -> 1/10*x^3-x; 3 g := x -> 1/10 x - x > readlib(iscont); proc(f:algebraic,z:name = range,opt) ... end > iscont(g(x), x=-4 .. 4); true
Für numerische Konstanten und beliebige Zahlenwerte läßt sich die jeweilige Umgebung in Form eines Intervalles angeben. Dazu muß der Befehl shake aus der Maple-Bibliothek geladen werden. Die Breite des Intervalles beträgt 10^(-n+1), wobei Sie den Wert von n als zweiten Parameter dem Befehl übergeben.
> readlib(shake); proc(expr) ... end > shake(E, 5); [2.718010 .. 2.718554] > shake(1, 10); [.9999999990 .. 1.0000000010]
> restart; > folge := (-1)^n+1/n; n folge := (-1) + 1/nMit seq werden die ersten 10 Glieder der Folge (sequence) berechnet und der Variable a zugewiesen. Als zweites Argument wird der Laufbereich index=m .. n angegeben:
> a := seq(folge, n=1 .. 10); 11 a := 0, 3/2, -2/3, 5/4, -4/5, 7/6, -6/7, 9/8, -8/9, ---- 10Auf alle Glieder können Sie durch Angabe ihres Indexes zugreifen:
> a[1]; a[2]; a[3]; 0 3/2 -2/3Jetzt wird eine Teilmenge an als sog. Liste (list) konstruiert, in die das dritte, fünfte und siebte Folgeglied abgespeichert wird:
> an := [a[3], a[5], a[7]]; an := [-2/3, -4/5, -6/7]Listen sind in Maple sehr leistungsfähig.
Die in seq benutzte Laufvariable n hat jetzt einen um 1 höheren Wert als der Index des letzten Folgegliedes von a:
> n; 11Der Indexbereich kann bei seq natürlich beliebig vorgegeben werden.
> n := 'n': > folge := n/(n+1); n folge := ----- n + 1 > seq(folge, n= 3 .. 7); 3/4, 4/5, 5/6, 6/7, 7/8 > n:='n':
Grenzwerte von Folgen:
> Limit(folge, n=0) = limit(folge, n=0); n Limit ----- = 0 n -> 0 n + 1 > Limit(folge, n=infinity) = limit(folge, n=infinity); n Limit ----- = 1 n -> infinity n + 1Die ersten zwanzig Glieder der Folge werden zusammen mit ihrem jeweiligen Index jetzt als Liste der Variable pts zugewiesen, diese dient der graphischen Anzeige der Folge.
> pts := [seq([n, folge(n)], n=1 .. 20)]; pts := [[1, 1/2], [2, 2/3], [3, 3/4], [4, 4/5], [5, 5/6], (usw.)] > gr1 := plot({pts}, x=1..20, y=0.5 .. 1.1, style=point): > gr2 := plot(1, x=1..20, y=0.5 .. 1.1, style=line): > with(plots): > display({gr1, gr2});
Die nächste Folge hat keinen Grenzwert, dafür aber Häufungspunkte. Jene werden von Maple in der Form a .. b ausgegeben, will heißen: im abgeschlossenen Intervall [a, b]. Dies muß aber nicht bedeuten, daß im Intervall nur Häufungspunkte liegen. Daher sollte auf jedem Fall der Graph der Folge zur weiteren Analyse angezeigt werden.
> restart: > a := n-> (-1)^n*n/(n+2); n (-1) n a := n -> ------- n + 2 > Limit(a(n), n=infinity) = limit(a(n), n=infinity); n (-1) n lim ------- = -1 .. 1 n -> infinity n + 2
Diese Folge besitzt nur die Häufungspunkte -1 und +1.
Ist eine Folge bestimmt divergent, d.h. sie strebt entweder gegen den uneigentlichen Grenzwert -unendlich oder gegen +unendlich, so meldet Maple '-infinity' bzw. 'infinity'.
> Limit(n^2, n=infinity) = limit(n^2, n=infinity); 2 lim n = infinity n -> infinity > Limit(-n^2, n=infinity) = limit(-n^2, n=infinity); 2 lim -n = -infinity n -> infinityIst eine Folge unbeschränkt aber nicht bestimmt divergent, so liefert Maple das Resultat 'undefined':
> Limit(((-1)^n+1)*n, n=infinity) = limit(((-1)^n+1)*n, n=infinity); n lim ((-1) + 1) n = undefined n -> infinity
Ein etwas anderer Einsatz von seq: Berechnung der ersten vier Ableitungen von 'ln(x)'.
> seq(diff(ln(x), x$n), n=1 .. 4); 1 2 6 1/x, - ----, ----, - ---- 2 3 4 x x x > n := 'n';
Summen lassen sich mit sum berechnen, der erste Paramter ist die Folge, der zweite der Laufbereich n von a bis b (n=a .. b); dieselbe Syntax gilt für Produkte.
> folge1 := (-1)^n*1/n;
> Sum(folge1, n=1 .. 10)=sum(folge1, n=1 .. 10);
> sum(folge1, n=1 .. infinity); - ln(2) > folge2 := 2*n+1; folge2 := 2 n + 1 > Product(folge2, n=1 .. 10)=product(folge2, n=1 .. 10);
> product(folge2, n=5 .. 7); 2145
> 5!; 120oder statt n!:
> factorial(5); 120Der Binomialkoeffizient n über k:
> binomial(n, k); binomial(n, k) > binomial(4, 2); 6
1) (func1@func2)(var)
2) func1(func2(var))
> restart; > f := x -> exp(2*x); f := x -> exp(2 x) > g := x -> 2*x-7; g := x -> 2 x - 7 > `(f@g)(x)`=(f@g)(x); (f@g)(x) = exp(4 x - 14) > f(g(x)); exp(4 x - 14)
Mit diff können Sie die Ableitungen einer Funktion berechnen. Das erste Argument von diff ist die abzuleitende Funktion, das zweite die Variable, nach der abgeleitet werden soll. Dabei kann mit $n die n-te Ableitung angegeben werden. Die resultierende Ableitungsterme werden mit unapply den Funktionen f1, f2 und f3 zugewiesen.
> restart; > f := x -> -x^3+3*x+4; 3 f := x -> - x + 3 x + 4 > f1 := unapply(diff(f(x), x), x); 2 f1 := x -> - 3 x + 3 > f2 := unapply(diff(f(x), x$2), x); f2 := x -> - 6 x > f3 := unapply(diff(f(x), x$3), x); f3 := -6Die Graphen:
> pf0 := plot(f(x), x=-3 .. 3, linestyle=1, color=navy): > t0 := textplot([1.6, f(1.6), `f(x)`], color=navy, > align={ABOVE, RIGHT}): > pf1 := plot(f1(x), x=-3 .. 3, linestyle=2, color=black): > t1 := textplot([-2.6, f1(-2.6), `f'(x)`], color=black, > align={BELOW, RIGHT}): > pf2 := plot(f2(x), x=-3 .. 3, linestyle=5, color=red): > t2 := textplot([-1.5, f2(-1.5), `f''(x)`], color=red, > align={ABOVE, RIGHT}): > pf3 := plot(f3(x), x=-3 .. 3, linestyle=4, color=magenta): > t3 := textplot([-1, f3(-1), `f'''(x)`], color=magenta, > align={BELOW}): > with(plots): > display({pf0, t0, pf1, t1, pf2, t2, pf3, t3}, > scaling=unconstrained);
Die Extremwerte (extreme values): f '(x)=0;
> solve(f1(x)=0, x); -1, 1f ''(x) <> 0;
> f2(-1); 6 > f(-1); 2f ''(-1) = 6 > 0 -> lok. Minimum (local minimum) bei x=-1; T(-1, 2)
> f2(1); -6 > f(1); 6f ''(1) = -6 < 0 -> lok. Maximum (local maximum) bei x=1; H(1, 6)
Die Wendepunkte (inflection points): f ''(x) = 0;
> solve(f2(x)=0, x); 0f'''(x) <> 0;
> f3(0); -6 > f(0); 4f '''(0) = -6 <> 0 -> Wendestelle bei x=0; W(0, 4)
Eine andere Möglichkeit der Extremwertberechnung existiert mit minimize und maximize aus dem Paket 'student'. Diese beiden Befehle berechnen allerdings nur die Ordinatenwerte der Extremstellen.
Hinweis: Sowohl in Release 3 als auch Release 4 sind die Funktionen student/extrema, student/maximize und student/minimize fehlerhaft (in Release 4 bei trigonometrischen Ausdrücken). Als Ersatz lassen sich u.a. die Funktionen des Paketes math verwenden (math/extrema, math/inflection).
> with(student): > minimize(f(x)); 2 > maximize(f(x)); 6Natürlich können Sie mit solve die zugehörigen Abszissenwerte berechnen, nur werden dabei auch die x-Werte von Nicht-Extremstellen angezeigt, so daß man zur schnellen Identifizierung den Graphen der Funktion aufrufen muß. Zudem wird in diesem Beispiel jeweils eine Lösung doppelt angezeigt.
> solve(2=f(x), x); 2, -1, -1 > solve(6=f(x), x); -2, 1, 1Der sog. Differentiationsoperator D kombiniert die Berechnung der Ableitungen von Funktionen mit einer Funktionszuweisung und ist somit eine Verkürzung bzw. einfacher in der Handhabung als diff gefolgt von unapply. Die Funktion wird in der Pfeilschreibweise definiert. Dem Operator D wird nur der Funktionsname in Klammern übergeben.
> restart; > f := x -> x^3: > f1 := D(f); 2 f1 := x -> 3 x > f1(2); 12Setzt man bei D hinter den Funktionsnamen das Argument der Funktion in Klammern, so wird ein unapply nicht durchgeführt. Dieses ist dann äquivalent zu der bekannten Anwendung des Befehles diff.
> D(f)(x) = diff(f(x), x); 2 2 3 x = 3 xZur Berechnung der n-ten Ableitung einer Funktion stellen Sie hinter D den Wiederholungsoperator @@, gefolgt von der Angabe der gewünschten Ableitung. Die entstandene Zeichenfolge wird von Klammern eingeschlossen.
> f2 := (D@@2)(f); f2 := x -> 6 x
Zur Berechnung der partiellen Ableitung einer Funktion zweier Veränderlicher wie
> f := (x, y) -> -4*x^3*y^2+3*x*y^4-3*x+2*y+5; 3 2 4 f := (x,y) -> - 4 x y + 3 x y - 3 x + 2 y + 5übergibt man dem Befehl diff als zweiten Parameter diejenige Variable, nach der differenziert werden soll - die jeweils andere Veränderliche wird dann als Konstante aufgefaßt.
> diff(f(x, y), x); 2 2 4 - 12 x y + 3 y - 3 > f1x := unapply(", x, y); 2 2 4 f1x := (x,y) -> - 12 x y + 3 y - 3 > f1y := unapply(diff(f(x, y), y), x, y); 3 3 f1y := (x,y) -> - 8 x y + 12 x y + 2 > f1x(1, 2); -3 > f1y(1, 2); 82Die n-te Ableitung wird wie bei Funktionen mit nur einer Unbekannten ermittelt.
> diff(f(x, y), x$3); 2 - 24 yAuch bei partiellen Ableitungen erspart der Differentiationsoperator D Tipparbeit. Die Angabe der zu differenzierenden Variablen erfolgt nicht durch Nennung jener Unbekannten (z.B. 'x'), also der alphanumerischen Zeichenfolge, sondern durch Angabe des (numerischen) i-ten Argumentes der partiell zu differenzierenden Funktion in eckigen Klammern.
> restart: > f := (x, y) -> x^3*y^3:Differentiation nach 'x':
> f1x := D[1](f); 2 3 f1x := (x,y) -> 3 x yDifferentiation nach 'y':
> f1y := D[2](f); 3 2 f1y := (x,y) -> 3 x yDie Berechnung der n-ten partiellen Ableitung geschieht (abweichend von Funktionen mit einer Unbekannten) durch n-malige Anwendung des Differentiationsoperators.
> f2x := (D@@2)[1](f); syntax error: f2x := (D@@2)[1](f); ^ > f2x := D[1](D[1](f)); 3 f2x := (x,y) -> 6 x y
Vorab möchte ich bemerken, daß bei Release 3 für MS Windows bei einigen Graphikkarten Probleme mit der Darstellung von Integralzeichen und Klammern existieren, d.h. sie werden nicht angezeigt. Siehe hierzu den Abschnitt Probleme mit der Windows-Version von Maple V Release 3 im Kapitel 7.
Gegeben sei eine Funktion f mit einer Unabhängigen x.
> restart; > f := x -> x^3-sin(x)+ln(x); 3 f := x -> x - sin(x) + ln(x)Das unbestimmtes Integral (indefinite integral) berechnen Sie mit dem Befehl int, wobei als erstes Argument die zu integierende Funktion und als zweites Argument die unabhängige Variable genannt wird.
> int(f(x), x); 4 1/4 x + cos(x) + x ln(x) - xBei bestimmten Integralen (definite integral) gibt man die Grenzen mit dem Zusatz x=untere_Grenze .. obere_Grenze an, z.B.:
> int(1/3*x^3+2*x^2-x, x=0 .. 2); 14/3Achten Sie bei der der bestimmten Integration auf den Wertebereich der Integralfunktion.
> f := x -> sin(x): > int(f(x), x=-Pi/2 .. Pi/2); 0Verwenden Sie daher für Flächenberechnungen die Absolutfunktion: R3 gibt ein unausgewertetes Integral zurück, welches mit evalf numerisch bestimmt werden kann. R4 ermittelt sofort - ohne Umweg über evalf - die Lösung.
> int(abs(f(x)), x=-Pi/2 .. Pi/2);
> evalf("); 2.000000000Existieren mehrere Nullstellen, so kann die Eingabezeile sehr lang werden. Es empfiehlt sich, die Nullstellen in einer Liste abzuspeichern. Danach kann der Befehl sum auf diese Liste zugreifen. nops gibt die Anzahl der in der Liste befindlichen Einträge an. Damit der Indexbereich der Liste durch den Zugriff N[n+1] nicht überschritten wird (dieses würde zu einem Syntaxfehler führen), muß zur Festlegung der rechten Grenze von n der Wert 1 von nops(N) abgezogen werden.
> N := [-Pi/2, 0, Pi/2]; N := [- 1/2 Pi, 0, 1/2 Pi] > sum(abs(int(f(x), x=N[n] .. N[n+1])), n=1 .. nops(N)-1); 2 > n := 'n':Integration durch Substitution: Zunächst wird der träge Integrationsbefehl Int (mit großem Buchstaben i) eingesetzt und der unausgewertete Ausdruck einer Variablen zugewiesen.
> restart: with(student): > i1 := Int(2*x*sin(x^2+1), x);
> changevar(x^2+1 = z, i1, z);
Das Integral wird nun ermittelt, bei trägen Kommandos bzw. Ausdrücken erzwingt value die Berechnung:
> value("); - cos(z)Resubstitution:
> changevar(z=x^2+1, ", x^2+1); 2 - cos(x + 1)oder via
> subs(z=x^2+1, ""); 2 - cos(x + 1)Partielle Integration:
> restart; > with(student): > intparts(Int(x*exp(x), x), x);
> evalf(Int(exp(x), x=1 .. 2)); 4.6707742704716049919Bemerkung: Bei unbestimmten Integralen fehlt bei der Berechnung grundsätzlich die Integrationskonstante 'c'.
Der Befehl series entwickelt entweder Taylor-, Laurent- oder allgemeine Potenzreihen, je nach Typ des übergebenen Ausdruckes; der Entwicklungspunkt wird als zweiter Parameter dem Kommando mitgeteilt:
> series(sin(x), x=0); 3 5 6 x - 1/6 x + 1/120 x + O(x )Ein optionaler dritter Parameter legt die maximale Ordnung fest, der Vorgabewert ist 6:
> series(sin(x), x=0, 10); 3 5 7 9 10 x - 1/6 x + 1/120 x - 1/5040 x + 1/362880 x + O(x )Den Vorgabewert können Sie auch allgemein durch Änderung der Systemvariable Order bestimmen:
> Order := 7; Order := 7 > reihe0 := unapply(series(sin(x), x=0), x); 3 5 7 reihe0 := x -> x - 1/6 x + 1/120 x + O(x )Es fällt auf, daß die Reihenentwicklung jedes Mal mit dem Ordnungsterm O(...) endet, dabei ist O der Buchstabe 'O'.
> plot(reihe0(x), x=-4 .. 4); Warning in iris-plot: empty plot > reihe0(3); Error, (in reihe0) invalid substitution in seriesMit dieser Ausgabe lassen sich so oftmals keine weiteren Berechnungen durchführen, man muß den Term O(...) eliminieren; dies geschieht am sichersten mit subs, indem Sie den Ordnungsterm O() gleich Null setzen:
> reihe1 := unapply(series(sin(x), x=0), x); 3 5 7 reihe1 := x -> x - 1/6 x + 1/120 x + O(x ) > reihe2 := unapply(subs(O(1)=0, reihe1(x)), x); 3 5 reihe2 := x -> x - 1/6 x + 1/120 x > plot({reihe2(x), sin(x)}, x=-4 .. 4, scaling=constrained);
Taucht das Argument nicht in dessen Wurzelschreibweise auf, so kann der Ordnungsterm auch eleganter und einfacher mit convert/polynom umgeformt werden:
> reihe3 := convert(series(cos(x), x=Pi), polynom); 2 4 reihe3 := - 1 + 1/2 (x - Pi) - 1/24 (x - Pi)Gegenbeispiel:
> reihe4 := convert(series(sqrt(tan(x)), x=0), polynom); 1/2 5/2 19 9/2 11/2 reihe4 := x + 1/6 x + --- x + O(x ) 360Die Angabe der Reihenentwicklung als Summenformel erfolgt mit FPS aus der Share-Library. Weitere Informationen zu dieser sind in Kapitel 7 enthalten. Der zweite Parameter von FPS gibt den Entwicklungspunkt an.
> with(share); See ?share and ?share,contents for information about the share library [] > readshare(FPS, calculus); FormalPowerSeriesMaple V4-Anwender müssen statt calculus den Namen analysis verwenden.
> FPS(sin(x), x=0);
> FPS(1/x, x=1);
> reihe2(3); 21 ---- 40 > diff(reihe2(x), x); 2 4 1 - 1/2 x + 1/24 x > int(reihe2(x), x); 2 4 6 1/2 x - 1/24 x + 1/720 x > restart;
Abschnittweise definierte Funktionen können Sie mit der Anweisung piecewise realisieren. Das Kommando muß aber zuvor mit
> readlib(piecewise); proc(n,a,t,f) ... endaktiviert werden. Beachten Sie, daß die Ergebnisse dieses Befehles mit Vorsicht zu genießen sind, wie gleich demonstriert wird.
Angenommen Sie möchten eine Funktion S mit folgenden Bereichen definieren:
Für jeden Abschnitt werden in piecewise zwei Argumente eingesetzt: das erste für den Definitionsbereich in Form einer Relationsbedingung, das zweite für den Funktionsterm; dieses können Sie beliebig oft wiederholen. Die Bedingung kann alle mathematischen Vergleichsoperationen enthalten: <, <=, = , >, >=. Die Booleschen Operatoren and, or und not sind nicht zugelassen.
> S := x -> piecewise(x < 0, -x^3, x < Pi/2, 1, x >= Pi/2, sin(x)); 3 S := x -> piecewise(x < 0, - x , x < 1/2 Pi, 1, 1/2 Pi <= x, sin(x))Einige Anwendungen:
> for f from -2 to 2 do > lprint(f, S(f)) > od; -2 8 -1 1 0 1 1 1 2 sin(2)S ist an der Stelle x=0 unstetig, daher gibt man zur Berechnung des Grenzwertes an dieser Stelle bei limit an, von welcher Seite Maple sich der Stelle nähern soll.
> limit(S(x), x=0, left); 0 > limit(S(x), x=0, right); 1Differenzieren können Sie ebenfalls:
# Release 3-Berechnung > s := unapply(diff(S(x), x), x); s := x -> piecewise(-1, 2 x < 0, - 3 x , x = 0, undefined, x < 1/2 Pi, 0, x = 1/2 Pi, undefined, 1/2 Pi < x, cos(x), 1/2 Pi = x, undefined, undefined)Da die Ausgabe etwas unübersichtlich ist, wurde sie hier strukturiert, um die einzelnen Bereiche besser erkennen zu können. Es fällt auf, daß an der Schnittstelle x=Pi/2 der Funktionswert der Ableitung fälschlicherweise undefiniert ist und dies sogar zweimal angegeben wird.
> s(0), s(Pi/2); undefined, undefinedEtwas genauer, d.h. (fast) richtig, rechnet Release 4:
> s := unapply(diff(S(x), x), x); 2 s := x -> piecewise(x <= 0, -3 x , x <= 1/2 Pi, 0, 1/2 Pi < x, cos(x), x = 0, undefined) > s(0), s(Pi/2); 0, 0Einmal wird hier -3*x^2 für x aus dem Intervall (unendlich .. 0] (also incl. dem Wert Null) und zum Schluß der Hinweis auf die Definitionslücke der Ableitung s an der Stelle x=0 ausgegeben. Dennoch berechnet Release 4 für s(0) einen Wert.
Der Graph der Funktion S und deren Ableitung:
> plS := plot(S(x), x=-1 .. 4, y=-2 .. 2): > txS := textplot([2.8, S(2.8)+0.3, `S(x)`], align={above, right}): > pls := plot(s(x), x=-1 .. 4, y=-2 .. 2, linestyle=5): > txs := textplot([2, s(2)-0.2, `s(x)`], align={below, left}): > display({plS, txS, pls, txs}, axes=frame);
In Release 3 ist die Integration von piecewise-Funktionen nicht möglich. In Release 4 weist piecewise deutliche Verbesserungen und Erweiterungen auf: Die Ausgabe ist sehr übersichtlich geworden, die Ergebnisse sind meist genauer und auch Integrationen können Sie vornehmen:
> diff(S(x), x); { 2 { -3 x x <= 0 { { 0 x <= 1/2 Pi { { cos(x) 1/2 Pi < x { { undefined x = 0 > int(S(x), x); { 4 { - 1/4 x x <= 0 { { x x <= 1/2 Pi { { 1/2 Pi - cos(x) 1/2 Pi < xAber auch hier tritt in der letzten Spalte eine Ungereimtheit auf: Im Gegensatz zu int im allgemeinen bzw. den anderen Spalten der obigen Ausgabe wird eine genau spezifizierte Integrationskonstante (1/2*Pi) angegeben, welches äußerst unglücklich ist.
Wenn die Funktionswerte in einem bestimmten Bereich undefiniert bleiben sollen, so wird der 'Wert' undefined benutzt:
> k := x -> piecewise(x < 0, -1, x = 0, 0, x < 2, undefined, x >= 2, 1); k := x -> piecewise(x < 0, -1, x = 0, 0, x < 2, undefined, 2 <= x, 1) > k(-1), k(0), k(1), k(2); -1, 0, undefined, 1Der Bereich des letzten Abschnittes braucht nicht angegeben zu werden, es genügt allein die Angabe des Funktionstermes:
> l := x -> piecewise(x < 0, -1, 1); l := x -> piecewise(x < 0, -1, 1) > l(0); 1Die Ergebnisse von piecewise sollten Sie generell auf ihre Richtigkeit überprüfen. Im folgenden Beispiel wurde das Intervall [1 .. 2) schlichtweg vergessen. Release 3 gibt dafür korrekterweise 'undefined' zurück:
> k := x -> piecewise(x < 0, -1, x = 0, 0, x < 1, undefined, x >= 2, 1); k := x -> piecewise(x < 0, -1, x = 0, 0, x < 1, undefined, 2 <= x, 1) > k(-1), k(0), k(1.5), k(2); -1, 0, undefined, 1Release 4 gibt aber für den Bereich [1 .. 2) den Wert 0 an, obwohl nicht definiert:
> k(-1), k(0), k(1.5), k(2); -1, 0, 0, 1Bei der Angabe der Intervalle sollten Sie grundsätzlich bis auf den letzten Abschnitt mit <=, < oder = arbeiten. Geben Sie 'mittendrin' eine >= oder >-Relation an, so führt dies in Release 3 und 4 zu falschen Ergebnissen:
> S := x -> piecewise(x < 0, -x^3, x >= 0, 1, x >= Pi/2, sin(x)); ^ | 3 S := x -> piecewise(x < 0, - x , 0 <= x, 1, 1/2 Pi <= x, sin(x)) > S(2); 1Die Stelle x=2 fällt in den Wertebereich von sin(x), daher sollte der Funktionswert sin(2) bzw. 0.9092974268 zurückgegeben werden, was hier nicht geschehen ist. Durch die Relation x >= 0 werden offensichtlich alle nachfolgenden Bedingungen von Maple V mißachtet.
Allgemeine Darstellung einer komplexen Zahl (complex number) mittels I:
> z := x + I*y; z := x + I ySpezielles Beispiel:
> a := 2 + 3*I; a := 2 + 3 IRealteil (real part) von a:
> Re(a); 2Imaginärteil (imaginary part) von a:
> Im(a); 3Betrag (absolute value) von a:
> abs(a); 1/2 13a konjugiert (complex conjugation) :
> conjugate(a); 2 - 3 IPhasenwinkel (principal value of argument) :
> argument(a); arctan(3/2)Normierung von a auf die Länge 1:
> signum(a); 1/2 (2/13 + 3/13 I) 13Polarschreibweise:
> convert(a, polar); 1/2 polar(13 , arctan(3/2)) > polar(2, 3); polar(2, 3)Komplexe Ausdrücke können Sie mit evalc kombiniert mit Re bzw. Im in ihre 'reellen' Bestandteile (also Real- und Imaginärteil) zerlegen. Dieses ist beispielsweise dann sinnvoll, wenn Sie umfangreiche ursprünglich komplexe Berechnungen durch reelle Fließkommaarithmetik beschleunigen möchten.
Ein Ausdruck, der mit evalc ausgewertet werden soll, darf nur komplexe Zahlen der Form 'z=x+I*y' beinhalten.
> restart; > z := x+I*y; z := x + I y > c := a+I*b; c := a + I bAus diesen komplexen Zahlen besteht die Formel
> formula := z^2+c; 2 formula := (x + I y) + a + I bDie reellen Entsprechungen dieser Formel werden ermittelt:
> real := evalc((Re(formula))); 2 2 real := x - y + a > imag := evalc((Im(formula))); imag := 2 x y + b