Kapitel Zwei:
Einfache mathematische
Berechnungen und Manipulationen
bilingual Hauptseite  Einführung Hauptseite  Kapitel 2
Kapitel 1 Kapitel 3

Inhalt

Wichtige mathematische Funktionen

Allgemeine Funktionen

abs
Betragsfunktion / Absolutwert (absolute value)
Syntax: abs(ausdruck);
Beispiel: abs(-5); -> 5

ceil
Nächstgelegene natürliche Zahl, die größer oder gleich dem Ausdruck ist (ceiling)
Syntax: ceil(ausdruck);
Beispiel: ceil(4.5); -> 5

factorial
Fakultät, auch in der Form (ausdruck)! möglich
Syntax: factorial(ausdruck);
Beispiel: factorial(3); -> 6; 3!; -> 6;

floor
Nächstgelegene natürliche Zahl, die kleiner oder gleich dem Ausdruck ist
Syntax: floor(ausdruck);
Beispiel: floor(4.5); -> 4

frac
Ermittlung des Nachkommateiles, bei negativen Zahlen incl. Vorzeichen (fraction)
Syntax: frac(ausdruck);
Beispiel: frac(-4.5); -> -0.5

iquo
Ermittlung der ganzzahligen Quotienten zweier ganzen Zahlen (wie DIV in vielen Programmiersprachen)
Syntax: iquo(integer1, integer2);
Beispiel: iquo(10, 3); -> 3

irem
Ermittlung des Restes der Division zweier ganzen Zahlen (siehe auch: ?mod)
Syntax: irem(integer1, integer2);
Beispiel: irem(10, 3); -> 1

max
Ermittlung der größten der angegebenen Zahlen (maximum)
Syntax: max(variable1, variable2, ...);
Beispiel: max(3, 4, 5); -> 5

min
Ermittlung der kleinsten der angegebenen Zahlen (minimum)
Syntax: min(variable1, variable2, ...);
Beispiel: min(3, 4, 5); -> 3

round
Auf- bzw. Abrundung zur nächsten ganzen Zahl
Syntax: round(ausdruck);
Beispiel: round(1.6); -> 2

signum
Vorzeichenfunktion
Syntax: signum(ausdruck);
Beispiel: signum(-5); -> -1

trunc
Ermittlung des Vorkommateiles einer Zahl (truncation)
Syntax: trunc(ausdruck);
Beispiel: trunc(4.5); -> 4, trunc(-4.5); -> -4
Exponential-, Logarithmus- und Potenzfunktionen
exp
Exponentialfunktion (exponential function)
Syntax: exp(ausdruck);
Beispiel: exp(0); -> 1

ln
Natürlicher Logarithmus (natural logarithm)
Syntax: ln(ausdruck);
Beispiel: ln(1); -> 0

log
Logarithmus zur Basis a (logarithm in the base a)
Syntax: log[a](ausdruck);
Beispiel: log[2](8.); -> 3.000000000
Besonderheiten: Wenn [a] weggelassen wird, wird der natürliche Logarithmus berechnet.

sqrt
Quadratwurzel (square root)
Syntax: sqrt(ausdruck);
Beispiel: sqrt(2.); -> 1.414213562

surd
n-te reelle Wurzel einer Zahl (n-th root)
Syntax: surd(ausdruck, n);
Beispiel: surd(-2., 3); -> -1.259921050
Bemerkung: In Maple V Release 3 muß dieser Befehl vorher mit 'readlib(surd)' geladen werden.
Logische Funktionen (boolean operators)
and
UND-Verknüpfung (AND logical connector)
Syntax: ausdruck1 and ausdruck2
Beispiel: 1 = 0 and 2 < 3; -> false

not
Negation (negation) eines Booleschen Ausdruckes
Syntax: not ausdruck
Beispiel: not 1 < 2; -> false

or
ODER-Verknüpfung (OR logical connector)
Syntax: ausdruck1 or ausdruck2
Beispiel: 1 = 0 or 2 < 3; -> true
Trigonometrische Funktionen

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 := Pi/2.;
radians := .5000000000*Pi
> radians*180./Pi;
90.00000000
> degrees := %;
degrees := 90.00000000
> radians := degrees*Pi/180;
radians := .5000000000*Pi

oder mittels convert:

> restart:

> convert(Pi/2, degrees);
90*degrees
> evalf(convert(%, radians));
1.570796327

cos
Kosinus (cosine)
Syntax: cos(ausdruck);
Beispiel: cos(0); -> 1

cot
Kotangens (cotangent)
Syntax: cot(ausdruck);
Beispiel: cot(Pi/2); -> 0

csc
Kosekans (cosecant)
Syntax: csc(ausdruck);
Beispiel: csc(Pi/2); -> 1

sec
Sekans (secant)
Syntax: sec(ausdruck);
Beispiel: sec(0); -> 1

sin
Sinus (sine)
Syntax: sin(ausdruck);
Beispiel: sin(Pi/2); -> 1

tan
Tangens (tangent);
Syntax: tan(ausdruck);
Beispiel: tan(Pi/4); -> 1
Zu den oben angegebenen sechs trigonometrischen (trigonometric) Funktionen existieren die entsprechenden hyperbolischen (hyperbolic) Funktionen. Die Syntax ist dieselbe.

cosh
coth
csch
sech
sinh
tanh
Inverse trigonometrische Funktionen
arccos
Inverser Kosinus (inverse cosine)
Syntax: arccos(ausdruck);
Beispiel: arccos(-1); -> Pi

arccot
Inverser Kotangens (inverse cotangent)
Syntax: arccot(ausdruck);
Beispiel: arccot(1); -> 1/4 Pi

arccsc
Inverser Kosekans (inverse cosecant)
Syntax: arccsc(ausdruck);
Beispiel: arccsc(sqrt(2)); -> 1/4 Pi

arcsec
Inverser Sekans (inverse secant)
Syntax: arcsec(ausdruck);
Beispiel: arcsec(1); -> 0

arcsin
Inverser Sinus (inverse sine)
Syntax: arcsin(ausdruck);
Beispiel: arcsin(sqrt(1/2)); -> 1/4 Pi

arctan
Inverser Tangens (inverse tangent)
Syntax: arctan(ausdruck);
Beispiel: arctan(0); -> 0

Die Hyperbelfunktionen zu den obigen Umkehrfunktionen:
arccosh
arccoth
arccsch
arcsech
arcsinh
arctanh

Vordefinierte Konstanten

In Maple V sind folgende Konstanten standardmäßig eingestellt. Ihr Wert kann (bzw. sollte) nicht geändert werden.
Catalan
Catalan-Konstante
Wert: 0.91596559417721901505

E
Eulersche Zahl
Wert: 2.7182818284590452354
Bemerkung: In Maple V Release 4 und 5 nicht mehr vordefiniert.
Abhilfe: alias(E=exp(1)): maple.ini (s.u.) hinzufügen oder in das Arbeitsblatt eintippen.

FAIL
Prozedurausführung fehlgeschlagen oder abgebrochen
Wert: FAIL

gamma
Euler-Konstante gamma
Wert: 0.57721566490153286061

I
imaginäre Einheit
Wert: sqrt(-1)

infinity
Unendlich
Wert: infinity

NULL
Leerfolge

Pi
Kreisteilungszahl
Wert: 3.1415926535897932385
Bemerkung: Pi ist auf 10.000 Stellen fest einprogrammiert.

false
Boolescher Wahrheitswert 'falsch'
Wert: false

true
Boolescher Wahrheitswert 'wahr'
Wert: true

constants
gibt alle vordefinierten Konstanten aus
constants; -> false, gamma, infinity, true, Catalan, FAIL, Pi
Bemerkung: I fehlt, da es von Maple auf andere Art (via alias) initialisiert wird. E fehlt in Release 4 und 5, da dort nicht vordefiniert.

Prioritäten mathematischer Operationen

Der Vorrang (precedence) mathematischer Operationen vor anderen (z.B. Punkt- vor Strichrechnung) gilt natürlich auch für Maple (siehe ?precedence). Soll dieses außer Kraft gesetzt werden, so müssen entsprechend Klammern gesetzt werden.
  1. .
  2. %
  3. &-Operatoren
  4. !
  5. Funktionen
  6. ^, **, @@
  7. *, &*, /, @, intersect
  8. +, -, union, minus
  9. mod
  10. ..
  11. <, <=, >, >=, =, <>
  12. $
  13. not
  14. and
  15. or
  16. ->
  17. ,
  18. :=
'.' hat die höchste, ':=' die niedrigste Priorität. Beispiele:
> 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

Manipulation von Polynomen

coeffs
collect
completesquare
degree
expand
factor
has
lcoeff
ldegree
op
select
simplify
sort

Ausmultiplizierung von Polynomen (expansion of polynomials):

> expand((x-2)^2);

Faktorisierung (factoring)

> factor(%);

Vereinfachung (simplification)

> (x-1)^2+(x+4)^2;
> simplify(%);

Zusammenfassung 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 x

Auswahl der Teile eines Polynomes, die eine bestimmte 'Eigenschaft' besitzen:

> select(has, p, a);
a x - a

has 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;
> with(student):

> completesquare(p, x);

completesquare 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;
> sort(poly);

Auflistung aller Glieder des Polynomes mit op:


> glieder := op(poly);

Herausgriff des n-ten Gliedes der Variable 'glieder', hier n=1:

> glieder[1];

Man beachte die eckigen Klammern.

Koeffizient der höchsten Potenz (leading coefficient):

> lcoeff(poly);
-3

Ermittlung aller Koeffizienten der Unbestimmten x in einem Ausdruck:

> coeffs(poly, x);
1, 1, -3

Grad (degree) des Polynomes:

> degree(poly);
5

Niedrigster Grad des Polynomes:

> ldegree(poly);
1

Vergleich von Ausdrücken

evalb
if .. then .. else .. fi
lprint

Ein Vergleich von Ausdrücken (expressions) geschieht durch die Operatoren

=
gleich (equals)

<
kleiner als (less than)

<=
kleiner gleich (less or equals)

>
größer (greater)

>=
größer gleich (greater or equals)

<>
ungleich (unequal)
Beispiel:
> u := 50:

> if u=50 then 
>    lprint(`richtig`)
>   else
>    lprint(`falsch`);
> fi;
richtig

Die 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

Gleichungen

allvalues
assign
fsolve
student/isolate
lhs
rhs
solve

Definition einer Gleichung (equation):

> 4+x*3=y*sqrt(2);

Zuweisung an eine Variable durch:

> eq1 := %;

Ermittlung der linken (left-hand) und rechten Seite (right-hand side) der Gleichung:

> lhs(eq1);
4 + 3 x
> rhs(eq1);

Auflösung der Gleichung nach der Variablen y durch isolate:

> readlib(isolate):

> isolate(eq1, y);
> simplify(%);

Der 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;
> solve(eq2, x);
0, 4, -4
> fsolve(eq2, x);
-4.000000000, 0, 4.000000000

Achtung: 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);
0

Auch 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.2831853071795864769

aber bei Polynomen funktioniert es:

> fsolve(1/4*x^3-4*x, x=-1 .. 10);
0, 4.0000000000000000000

Das math-Paket enthält die Funktion fnull, welche alle Nullstellen innerhalb eines bestimmten Intervalles auch bei periodischen Funktionen bestimmt.

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;
x

Hier besitzt die Variable x noch nicht den Lösungswert -1.

> assign(sol);

> x;
-1

Berü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

x := 'x':

zurück.

solve liefert, wenn vorhanden, immer auch komplexe Lösungen.

> restart:

> equ := 2*x^4-2=-1;
> solve(equ);
> evalf(%);
.8408964155, -.8408964155, .8408964150*I, -.8408964150*I

fsolve hingegen errechnet reelle Lösungen, mit der Option 'complex' können Sie aber neben den reellen auch komplexe Ergebnisse ermitteln lassen:

> fsolve(equ);
-.8408964153, .8408964153
> fsolve(equ, x, complex);
-.8408964153, -.8408964153*I, .8408964153*I, .8408964153

Werden 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;
> solve(k(x)=1);

Bei 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)];

Erste Lösung:

> loesung[1]; 

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;
> solve(k(x)=1);

Die numerischen Lösungen lassen sich aber mit allvalues berechnen.

> allvalues(");
-1.078388933-.4969396651*I, -1.078388933+.4969396651*I,
.1500514907-.8974603264*I, .1500514907+.8974603264*I, .8566748839

In einigen Fällen gelingt durch Setzen der Umgebungsvariablen _EnvExplicit auf den Wert true eine symbolische Berechnung:

> _EnvExplicit := true:

Ungleichungen (inequalities)

> y := 2*x-5;
y := 2 x - 5
> solve(y<3, x);

Release 4 und 5 benutzen standardmäßig statt der aus der mathematischen Literatur gewohnten Mengenschreibweise (s.o.) die 'RealRange'-Darstellung. Das obige Ergebnis sagt aus, daß das offene Intervall (-Unendlich, 4) die Ungleichung erfüllt. Durch Setzen des zweiten Argumentes, also 'x', in geschweifte Klammern wird das Ergebnis inb der aus Release 3 bekannten Mengenschreibweise ausgegeben:

> 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

Punktrichtungsform und Schnittpunkte von Geraden

student/intercept
student/slope
subs

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 + n

Die Steigung der Geraden wird mit dem Befehl slope aus dem Paket 'student' berechnet:

> m := slope([x1, y1], [x2, y2]);

Der y-Achsenabschnitt n wird mit der zugegebenermaßen hier etwas kryptischen Anweisung

> assign(isolate(subs(x=x1, y=y1, gl), n));

> n := n;

gefunden. 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 := 4

Die 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 + 1

Fertig !

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}

Gleichungssysteme

Auch bei Gleichungssystemen können solve und fsolve angewandt werden. Die einzelnen Gleichungen werden in geschweiften Klammern als erstes, die enthaltenen Unbekannten ebenfalls in geschweiften Klammern als zweites Argument übergeben.
> 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, 2

Auch 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}

Quotienten

convert/confrac, parfrac, rational
denom
divide
normal
numer
quo
rem
unapply

Gegeben sei folgendes gebrochen-rationale Polynom:

> restart:

> f := x->(0.5*x^3-1.5*x+1)/(x^2+3*x+2);

Die 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);

Umwandlung des Fließkommaausdruckes in einen rationalen Term:

> convert(bruch, rational);

Bestimmung des Zählers (numerator):

> fz := numer(f(x));

Bestimmung des Nenners (denominator):

> fn := denom(f(x));

Ermittlung des Quotienten bei einer Division von Polynomen:

> qu := quo(fz, fn, x);
qu := .5000000000*x-1.500000000

Ermittlung des Restes (remainder):

> re := rem(fz, fn, x);
re := 4.000000000+2.000000000*x
> convert(qu, rational);
> convert(re, rational);
4 + 2 x

Zuweisung des Quotienten an eine neue Funktion mittels unapply:

> asymptote := unapply(%%, x);

Hierbei 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);

> y := 3/x+4/x^2;

normal faßt nicht-gleichnamige Brüche zusammen (gemeinsamer Hauptnenner: common denominator):

> normal(y);

Partialbruchzerlegung (partial fractions):

> partialbruch := (x^2-3)/(x^3-x);
> convert(partialbruch, parfrac, x);

'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;
> divide(0.5*x^3-1.5*x+1, x^2+3*x+2, sol2);
false
> sol2;
sol2


Kapitel 1 Hauptseite Anfang der Seite Kapitel 3

MAPLE EINFÜHRUNG - MPLINTRO 04.00a vom 14. Dezember 1998
Author: Alexander F. Walz, alexander.f.walz@t-online.de
Original file location: http://www.math.utsa.edu/mirrors/maple/m2.htm