Bemerkung: Die Ausgabe der Werte erfolgt grundsätzlich im Bogenmaß (radians). Um sie in Gradwerte (degrees) umzuwandeln, müssen sie wie folgt umgerechnet werden:
> radians := evalf(sin(2)); radians := .90929742682568169540 > degrees := evalf(radians*180/Pi); degrees := 52.098904879217364065 > radians := evalf(degrees*Pi/180); radians := .90929742682568169538oder mittels convert:
> restart; > evalf(convert(sin(2), degrees)); 52.098904879217364067 degrees > evalf(convert(", radians)); .90929742682568169541
> 3*4+5; 17 > 3*(4+5); 27 > 2^3^4; syntax error: 2^3^4; ^Mehrere aufeinanderfolgende Exponenten müssen bei der Hütchen-Schreibweise in Klammern gesetzt werden.
> 2^(3^4); 2417851639229258349412352
Ausmultiplizierung von Polynomen (expansion of polynomials):
> expand((x-2)^2); 2 x - 4 x + 4Faktorisierung (factoring)
> factor("); 2 (x - 2)Vereinfachung (simplification)
> (x-1)^2+(x+4)^2; 2 2 (x - 1) + (x + 4) > simplify("); 2 2 x + 6 x + 17Zusammenfassung mittels collect in bezug auf eine bestimmte Variable (hier das zweite Argument):
> p := 5*x+a*x-a; p := 5 x + a x - a > collect(p, x); (5 + a) x - a > collect(p, a); (x - 1) a + 5 xAuswahl der Teile eines Polynomes, die eine bestimmte 'Eigenschaft' besitzen:
> select(has, p, a); a x - ahas ist hierbei ein fester Bezeichner, der das Polynom p auf die Eigenschaft, ob es den Term a besitzt, untersucht. select zeigt die betreffenden Teile an.
Quadratische Ergänzung:
> restart; > p := x^2+2*x+2; 2 p := x + 2 x + 2 > with(student): > completesquare(p, x); 2 (x + 1) + 1completesquare ist nicht Bestandteil der Standardbibliothek Maples, in welcher die fundamentalen Befehle und Funktionen gespeichert sind, sondern ist in einem sog. Paket (hier student) enthalten, welches Sie vor Nutzung der dort definierten Kommandos erst mit with(Paketname) aufrufen müssen, damit alle enthaltenen Befehle zur Verfügung stehen. Der Sinn des Konzeptes nachladbarer Pakete ist, den Arbeitsspeicherbedarf Maples so gering wie möglich zu halten, damit dieses Computeralgebrasystem auch auf 'kleineren' Computern arbeiten kann. Daher sind nur die meist genutzten Befehle sofort beim Start verfügbar, nicht aber spezielle. Mehr zur Konstruktion und Geschichte Maples finden Sie im Anhang.
Sortieren nach absteigendem Grad der Glieder eines Polynomes:
> restart; > poly := x^2-3*x^5+x; 2 5 poly := x - 3 x + x > sort(poly); 5 2 - 3 x + x + xAuflistung aller Glieder des Polynomes mit op:
> glieder := op(poly); 5 2 glieder := - 3 x , x , xHerausgriff des n-ten Gliedes der Variable 'glieder', hier n=1:
> glieder[1]; 5 - 3 xMan beachte die eckigen Klammern.
Koeffizient der höchsten Potenz (leading coefficient):
> lcoeff(poly); -3Ermittlung aller Koeffizienten der Unbestimmten x in einem Ausdruck:
> coeffs(poly, x); 1, 1, -3Grad (degree) des Polynomes:
> degree(poly); 5Niedrigster Grad des Polynomes:
> ldegree(poly); 1
Ein Vergleich von Ausdrücken (expressions) geschieht durch die Operatoren
> u := 50: > if u=50 then > lprint(`richtig`) > else > lprint(`falsch`); > fi; richtigDie oben erfolgte Eingabe erfolgt entweder in einer Zeile oder auf mehreren Zeilen, die durch Betätigung der Tasten SHIFT & RETURN voneinander getrennt werden, aber für Maple als eine Zeile erkannt werden.
Die if-Anweisung untersucht Bedingungen. Wenn (if) eine Bedingung (hier u=50) zutrifft, dann wird der then-Teil abgearbeitet, ansonsten (d.h. wenn die Bedingung nicht zutrifft) der else-Teil. Eine if-Anweisung muß generell mit einem fi abgeschlossen werden. Siehe auch: ?if.
Text wird durch lprint(`text`) oder mittels print(`text`) auf dem Bildschirm ausgegeben, hierbei muß der Text in sog. back quotes ` (ASCII Kontrollcode 96) eingeschlossen sein. Die Taste hierfür befindet sich rechts neben dem 'ß', das Zeichen wird folgendermaßen erzeugt: 1) Drücken der Shift-Taste zusammen mit der `-Taste, 2) Loslassen und 3) nachfolgendes Betätigen der Leertaste.
evalb(gleichung) untersucht (evaluates) eine Gleichung auf ihren Booleschen Wahrheitswert:
> evalb(u=50); true > evalb(u<50); false
Definition einer Gleichung (equation):
> 4+x*3=y*sqrt(2); 1/2 4 + 3 x = y 2Zuweisung an eine Variable durch:
> eq1 := "; 1/2 eq1 := 4 + 3 x = y 2Ermittlung der linken (left-hand) und rechten Seite (right-hand side) der Gleichung:
> lhs(eq1); 4 + 3 x > rhs(eq1); 1/2 y 2Auflösung der Gleichung nach der Variablen y durch isolate:
> readlib(isolate); proc(expr,x,n) ... end > isolate(eq1, y); 1/2 y = - 1/2 (- 4 - 3 x) 2 > simplify("); 1/2 y = 1/2 (4 + 3 x) 2Der Befehl isolate steht nicht sofort zur Verfügung, Sie müssen ihn erst durch den besonderen Aufruf readlib(isolate) aktivieren.
Die Lösung von Gleichungen oder Gleichungssystemen geschieht mittels solve bzw. fsolve, letzteres für Fließkommalösungen; als erstes Argument wird die Gleichung und als zweites die Variable, nach der aufgelöst werden soll, angegeben.
> eq2 := 1/4*x^3-4*x=0; 3 eq2 := 1/4 x - 4 x = 0 > solve(eq2, x); 0, 4, -4 > fsolve(eq2, x); 0, -4.0000000000000000000, 4.0000000000000000000Achtung: Fließkommaberechnungen sind bei Maple wie bei allen Computerberechnungen nur Approximationen bzw. Näherungen. Besonders bei sehr großen Zahlen können sich leicht Fehler einschleichen. Hierbei empfiehlt sich das Heraufsetzen von Digits auf einen höheren Wert oder auch die Umwandlung eines Ausdruckes in einen rationalen Wert, welcher generell absolut genau ist. Siehe: convert/rational im Abschnitt 'Brüche' dieses Kapitels.
solve bzw. fsolve ermitteln nur bei Polynomen alle Lösungen.
Die Sinusfunktion hat unendlich viele Nullstellen.
> f := x -> sin(x); f := sin(Es ist normal, daß das alleinige Argument 'x' der Sinus-Funktion, wie bei allen mathematischen Funktionen, nicht angezeigt wird.)
Wird ein Term (oder Funktion) als erstes Argument in solve bzw. fsolve eingesetzt, so kann dieses entweder in der Form 'Term=Zahlenwert' oder nur 'Term' geschehen. Im letzteren Falle wird dann der Term / die Funktion gleich Null gesetzt.
> solve(f(x), x); 0Auch die Angabe des Intervalles (interval), z.B. [0, 10], in dem nach Nullstellen (zeros, x-intercept points) gesucht werden soll, führt hierbei nicht weiter:
> fsolve(f(x), x=0 .. 10); 6.2831853071795864769aber bei Polynomen funktioniert es:
> fsolve(1/4*x^3-4*x, x=-1 .. 10); 0, 4.0000000000000000000Eine Lösung hierzu findet sich im Anhang.
assign bewirkt, daß eine durch solve ermittelte Lösungsmenge auch der entsprechenden Variable zugewiesen wird:
> equ := x+1; equ := x + 1 > sol := solve(equ, {x}); sol := {x = -1} > x; xHier besitzt die Variable x noch nicht den Lösungswert -1.
> assign(sol); > x; -1Berücksichtigen Sie bitte, daß die Variable x jetzt einen Wert trägt, also nicht mehr als Unbestimmte dienen kann. Wenn nötig, setzen Sie sie mit
zurück.
solve liefert, wenn vorhanden, immer auch komplexe Lösungen.
> restart; > equ := 2*x^4-2=-1; 4 equ := 2 x - 2 = -1 > solve(equ); 3/4 3/4 3/4 3/4 1/2 2 , - 1/2 2 , 1/2 I 2 , - 1/2 I 2 > evalf("); .84089641525371454305, -.84089641525371454305, .84089641525371454305 I, - .84089641525371454305 Ifsolve hingegen errechnet reelle Lösungen, mit der Option 'complex' können Sie aber neben den reellen auch komplexe Ergebnisse ermitteln lassen:
> fsolve(equ); -.84089641525371454303, .84089641525371454303 > fsolve(equ, x, complex); -.84089641525371454303, - .84089641525371454303 I, .84089641525371454303 I, .84089641525371454303Werden die Lösungen sehr umfangreich, so setzt Maple für mehrfach vorkommende Teilterme sog. 'Labels' der Form %n ein, so daß das Ergebnis etwas übersichtlicher wird.
> k := x -> x^3+x^2; 3 2 k := x -> x + x > solve(k(x)=1);
1/3 1 1/3 1 1/2 / 1/3 1 \ %1 + ------- - 1/3, - 1/2 %1 - -------- - 1/3 + 1/2 I 3 |%1 - -------|, 1/3 1/3 | 1/3| 9 %1 18 %1 \ 9 %1 / 1/3 1 1/2 / 1/3 1 \ - 1/2 %1 - -------- - 1/3 - 1/2 I 3 |%1 - -------| 1/3 | 1/3| 18 %1 \ 9 %1 / 25 1/2 %1 := ---- + 1/18 69 54Bei solchen ausufernden Lösungstermen empfielt es sich, die Ergebnisse als Liste in einer Variablen zwischenzuspeichern, um auf die einzelnen Resultate über ihren Index zugreifen zu können. Zur Abspeicherung in eine Liste setzen Sie den solve-Befehl in eckige Klammern [ ]. Bei einem Index-Zugriff tritt das Label nicht mehr auf, es wird die komplette Lösung angezeigt. (Auf die komplette Maple-Ausgabe wird in den folgenden Beispielen verzichtet.)
> loesung := [solve(k(x)=1)]; 1/3 1 loesung := [%1 + ------- - 1/3, usw .. ] 1/3 9 %1Erste Lösung:
> loesung[1]; / 25 1/2\1/3 1 |---- + 1/18 69 | + ------------------------ - 1/3 \ 54 / / 25 1/2\1/3 9 |---- + 1/18 69 | \ 54 /Durch Verwendung einer for-Schleife lassen sich alle Lösungen anzeigen. Mit nops ermittelt man die totale Anzahl der Einträge in die Liste.
> for i to nops(loesung) do > loesung[i] > od; ...Mit interface(labelling=false); weisen Sie Maple V an, Labels nicht zu verwenden und statt dessen die Ausgabe ungekürzt zu vollziehen. Durch interface(labelling=true); können Sie diese Einstellung wieder rückgängig machen. Ein restart bewirkt dieses nicht.
Bei Polynomen mit einem Grad größer oder gleich 5 findet solve in den meisten Fällen keine expliziten Lösungen. Es wird dann die RootOf- Darstellung benutzt.
> k := x -> x^5+x^4; 5 4 k := x -> x + x > solve(k(x)=1); 5 4 RootOf(_Z + _Z - 1)Die numerischen Lösungen lassen sich aber mit allvalues berechnen.
> allvalues("); - 1.0783889326367361508 - .49693966514745255765 I, - 1.0783889326367361508 + .49693966514745255765 I, .15005149070948471336 - .89746032637339371018 I, .15005149070948471336 + .89746032637339371018 I, .85667488385450287485In einigen Fällen gelingt durch Setzen der Umgebungsvariablen _EnvExplicit auf den Wert true eine symbolische Berechnung:
> _EnvExplicit := true:
> y := 2*x-5; y := 2 x - 5 > solve(y<3, x); {x < 4}Release 4 benutzt standardmäßig statt der praktischen und aus der mathematischen Literatur gewohnten Mengenschreibweise (s.o.) die unübersichtliche 'RealRange'-Darstellung:
> solve(y<3, x); RealRange(-infinity, Open(4))Dies sagt aus, daß das offene Intervall (-Unendlich, 4) die Ungleichung erfüllt. Durch Setzen des zweiten Argumentes, also 'x', in geschweifte Klammern läßt sich die Release 3-Ausgabe erzwingen:
> solve(y<3, {x}); {x < 4}Wie bei einfachen Gleichungen kann auch isolate die Ungleichung lösen.
> readlib(isolate): > isolate(y<3, x); x < 4
Sind zwei Punkte P1(x1, x2) und P2(x2, y2) gegeben, so läßt sich daraus die Geradengleichung y=mx+n ermitteln.
> restart; > with(student): > gl := y = m*x+n; gl := y = m x + nDie Steigung der Geraden wird mit dem Befehl slope aus dem Paket 'student' berechnet:
> m := slope([x1, y1], [x2, y2]); y1 - y2 m := ------- x1 - x2Der y-Achsenabschnitt n wird mit der zugegebenermaßen hier etwas kryptischen Anweisung
> assign(isolate(subs(x=x1, y=y1, gl), n)); > n := n; (y1 - y2) x1 n := y1 - ------------ x1 - x2gefunden. subs setzt in der Gleichung gl für die dort enthaltenen Unbestimmten x und y jeweils x1 und y1 ein, danach wird mit isolate die Gleichung gl nach n aufgelöst und mit assign das Ergebnis der Variablen n zugewiesen. Für die nächsten Anweisungen muß n gelöscht werden.
> n := 'n';Ein konkretes Beispiel: Gegeben seien die Punkte (1, 5) und (2, 9). Die Punkte werden in eckigen Klammern gefaßt dem Befehl slope als Argument übergeben.
> m := slope([1, 5], [2, 9]); m := 4Die Koordinaten eines Punktes werden jetzt in die Gleichung für x und y eingesetzt. Man beachte, daß der Wert für die Steigung m bereits in die Gleichung von Maple eingesetzt wurde. Die obige allgemeine Anweisung zur Ermittlung von n wird jetzt auseinandergezogen und auf mehrere Zeilen verteilt.
> subs(x=1, y=5 , gl); 5 = 4 + n > isolate(", n); n = 1 > assign("); > gl; y = 4 x + 1Fertig !
Schnittpunkte einer Geraden mit den Koordinatenachsen oder zwischen zwei Geraden können Sie mit intercept berechnen, welches ebenfalls im Paket 'student' enthalten ist. Es hat im ungefähren dieselbe Funktion wie solve, wobei letzteres aber universeller einsetzbar ist.
Schnittpunkt mit der y-Achse:
> intercept(gl); {x = 0, y = 1}Schnittpunkt mit der vertikalen Gerade x=2:
> intercept(gl, x=2); {x = 2, y = 9}Schnittpunkt mit der Abszisse:
> intercept(gl, y=0); {y = 0, x = -1/4}Schnittpunkt zweier Geraden gl und z:
> z := y=x-2; z := y = x - 2 > intercept(gl, z); {x = -1, y = -3}
> restart; > solve({3*x-2*y=8, 5*x-3*y=4}, {x, y}); {x = -16, y = -28}Die einzelnen Gleichungen können auch Variablen zugewiesen werden, welche dann in solve eingesetzt werden.
> gl1 := -2*x+2*y+7*z = 0; gl1 := - 2 x + 2 y + 7 z = 0 > gl2 := x-y-3*z = 1; gl2 := x - y - 3 z = 1 > gl3 := 3*x+2*y+2*z = 5; gl3 := 3 x + 2 y + 2 z = 5 > solve({gl1, gl2, gl3}, {x, y, z}); {z = 2, x = 3, y = -4}Eine weitere Variation:
> gl_systeme := {gl1, gl2, gl3}; gl_systeme := {- 2 x + 2 y + 7 z = 0, x - y - 3 z = 1, 3 x + 2 y + 2 z = 5} > gl_variablen := {x, y, z}; gl_variablen := {y, x, z} > solve(gl_systeme, gl_variablen); {z = 2, x = 3, y = -4}Die Reihenfolge der einzelnen Lösungen erfolgt willkürlich. Die einzelnen Werte können wie bei einfachen Gleichungen mit assign den jeweiligen Variablen zugewiesen werden.
> assign("); > x, y, z; 3, -4, 2Auch die Lösung von Systemen, bei denen die Anzahl der Unbekannten ungleich der der Gleichungen ist, beherrscht solve.
> restart; > solve({x-y+z=4, 2*x+3*y-z=-1}, {x, y, z}); {z = 5/3 y + 3, x = - 2/3 y + 1, y = y}
Gegeben sei folgendes gebrochen-rationale Polynom:
> restart; > f := x->(0.5*x^3-1.5*x+1)/(x^2+3*x+2); 3 .5 x - 1.5 x + 1 f := x -> ----------------- 2 x + 3 x + 2Die Division erfolgt durch Einsatz von convert/confrac; das erste Argument von convert ist das gebrochen-rationale Polynom selbst, das zweite die Option confrac, welche die Art der Division bestimmt, und das dritte Argument die im Polynom enthaltene Unbestimmte.
> bruch:=convert(f(x), confrac, x); 2.000000000 bruch := .5000000000 x - 1.500000000 + ----------- x + 1Umwandlung des Fließkommaausdruckes in einen rationalen Term:
> convert(bruch, rational); 2 1/2 x - 3/2 + ----- x + 1Bestimmung des Zählers (numerator):
> fz := numer(f(x)); 3 fz := .5 x - 1.5 x + 1Bestimmung des Nenners (denominator):
> fn := denom(f(x)); 2 fn := x + 3 x + 2Ermittlung des Quotienten bei einer Division von Polynomen:
> qu := quo(fz, fn, x); qu := .50000000000000000000 x - 1.5000000000000000000Ermittlung des Restes (remainder):
> re := rem(fz, fn, x); re := 4.0000000000000000000 + 2.0000000000000000000 x > convert(qu, rational); 1/2 x - 3/2 > convert(re, rational); 4 + 2 xZuweisung des Quotienten an eine neue Funktion mittels unapply:
> asymptote := unapply("", x); asymptote := x -> 1/2 x - 3/2Hierbei wird als erster Parameter der zuzuweisende Ausdruck angegeben und als zweites das Argument (oder die Argumente) der neuen Funktion. Man ist oft versucht, eine unapply-Funktion mittels der Pfeilnotation zu definieren:
> func := x -> unapply(ausdruck, x);Richtig aber ist nur die Syntax:
> func := unapply(ausdruck, x);normal faßt nicht-gleichnamige Brüche zusammen (gemeinsamer Hauptnenner: common denominator):
> y := 3/x+4/x^2; 4 y := 3/x + ---- 2 x
> normal("); 3 x + 4 ------- 2 xPartialbruchzerlegung (partial fractions):
> partialbruch := (x^2-3)/(x^3-x); 2 x - 3 partialbruch := ------ 3 x - x > convert(partialbruch, parfrac, x); 1 1 3/x - ----- - ----- x - 1 x + 1'Echte' Teilbarkeit von Polynomen. divide bestimmt, ob die beiden angegebenen Polynome ohne Rest teilbar sind. Wenn ja, so wird 'true' ausgegeben und das Ergebnis dem dritten Parameter übergeben:
> divide(x^3-2*x^2-5*x+6, x-1, sol1); true > sol1; 2 x - x - 6 > divide(0.5*x^3-1.5*x+1, x^2+3*x+2, sol2); false > sol2; sol2