Einführung in Maple. Universität Regensburg Fakultät für Physik

Einführung in Maple Universität Regensburg Fakultät für Physik Januar 05

Inhaltsverzeichnis: I. Grundlagen.... Was ist Maple?.... Lernziel des Kurses... 3. Die Arbeitsumgebung... 4. Die Hilfsfunktionen... 5. Die ersten Graphiken... 6. Initialisierung, Restart... 4 7. Konstanten in Maple... 4 i. Elementare Konstanten... 4 ii. Algebraische Konstanten... 5 iii. Strings... 5 8. Variable... 5 9. Zusammengesetze Datentypen... 6 i. Algebraische Ausdrücke... 6 ii. Gleichungen... 6 iii. Range (Bereich)... 6 iv. Sequence (Folge)... 6 v. List (Liste)... 7 vi. Set (Menge)... 7 vii. Array... 8 0. Operatoren... 8. Funktionen zur Vereinfachung eines Ausdrucks... 9 i. Simplify... 9 ii. Factor... 9 iii. Collect... 9 iv. Combine... 9 v. Expand... 9 vi. Convert... 9. Reihenentwicklung... 0 3. Numerische Berechnungen... 0 4. Lösen von Gleichungen... 0 i. Einfache Gleichungen (und Ungleichungen)... 0 ii. Lineare Gleichungssysteme... iii. Nicht-lineare Gleichungssysteme... 5. Summen und Produkte: Eigenschaften von Variablen... 6. Differenzieren, Integrieren und Grenzwerte... 3 i. Differenzieren... 3 ii. Integrieren... 3 iii. Grenzwerte... 4 7. Funktionen... 4 i. Definition von Funktionen... 4 ii. Differenzieren von Funktionen, Integrieren... 5 iii. Funktionen mehrerer Variablen... 5 iv. Funktionen und Ausdrücke... 6 II. Graphik mit Maple... 8. Noch ein paar einfache Plots... 8. Darstellung von (externen Daten)... 9 3. Animationen und implizite Abbildungen... i. animate (create an animation of d plots of function)... ii. animatecurve (create animation of the drawing of d plots)... iii. implicitplot (two dimensional implicit plotting)... 4. Dreidimensionale Darstellungen... 5 i. spacecurve (plotting of 3d space curves)... 5 ii. surfdata (create a 3-d surface plotting from data)... 5 iii. implicitplot3d (three-dimensional implicit plotting)... 6 III. Lösung von Differentialgleichungen mit Maple... 8. Generelle Konzepte... 8. Umgang mit den Lösungen... 9 3. Systeme von DGLn... 30 4. Beispiel: Gedämpfte Schwingung... 3 5. Numerische Lösung und graphische Darstellung... 3 6. Anhang für Fortgeschrittene: das Paket DEtools... 33 IV. Programmieren und Prozeduren... 37. Hinführung... 37. Bedingungen und Schleifen (if, while, for)... 38 3. Prozeduren... 40 V. Lineare Algebra... 44. Arrays... 44. Vektoren und Matrizen... 44 3. Lineare Gleichungssysteme... 47 4. Eigenwerte und Eigenvektoren... 47 5. Ein bisschen Vektoranalysis... 49

Einführung in Maple Stand Januar 05 (Version 3.0) - F.Wünsch Dieses Skript basiert auf Kursen von Julian Berwanger, Martin Decker, Thomas Pruschke, Joachim Keller, Harald Dobler, Florian Chmela und Roland Winkler. Kap. : Grundlagen Kap. : Graphik mit Maple Kap. 3: Lösung von Differentialgleichungen mit Maple Kap. 4: Programmierung und Prozeduren Kap. 5: Lineare Algebra Grundlagen Was ist Maple? Maple ist ein weit verbreitetes mathematisches Softwarepaket (ähnlich dazu: Mathematica); akuell ist z.z. die Version 8. Die Universität besitzt eine Campuslizenz von Maple für Windows, Linux, Mac. Die Version 8 kann sehr viel, ist aber furchtbar träge, auch als Classic Worksheet ohne Java. Die ältere Version VR5 ist schlank und kann alles, was wir für den Kurs benötigen. Sie ist (unter Windows) zu finden in F :\MAPLE\V5\BIN3\wmaple.exe. Eine neuere Version befindet sich auf dem Windows-Desktop, andere lassen sich bei Bedarf mit RZSetup installieren. Im Kurs können wir ruhig mit Maple V Release 5 arbeiten. Die Kurs-Worksheets sind im Maple VR5-Format abgespeichert, lassen sich über ohne Probleme auch in Maple 8 öffnen. Unter Unix/Linux startet der Befehl xmaple normalerweise die aktuelleste Version, ältere (auch VR5) sind per enable verfügbar. Der Hersteller (Maple Waterloo Inc.) beschreibt sein Produkt so: Maple is a comprehensive computer system for advanced mathematics. It includes facilities for interactive algebra, calculus, discrete mathematics, graphics, numerical computation, and many other areas of mathematics. It also provides a unique environment for rapid development of mathematical programs using its vast library of built-in functions and operations. Besondere Stärke: symbolische Mathematik, also Finden von allgemeinen Lösungsformeln simples Beispiel: quadratische Gleichung: # immer sinnvoll am Anfang jedes Abschnitts > equ:=a*x^+b*x+c=0; > solve(equ,x); equ := a x + b x + c = 0 Page > b + 4 a c b 4 a c, a a b Maple kann auch numerisch rechnen, allerdings nicht so effizient wie andere Programmpakete wie z.b. Matlab, dafür aber mit beliebig einstellbarer Genauigkeit (Feststellung/Vermeidung von Rundungsfehlern, die oft völlig falsche Ergebnisse verursachen, ideal für die Entwickler von numerischen Algorithmen). Schnittstellen von Maple zu Programmiersprachen wie C oder Fortran sind vorhanden. Maple hat hervorragende Graphik-Fähigkeiten, z.b. Visualisierung von Funktionen(scharen), großen Datenmengen, auch mit Animation Maple ist für Mathematiker, Chemiker, Physiker, Ingenieure, Wirtschaftler bzw. Student(inn)en dieser Fächer von Anfang an ein sehr hilfreicher Werkzeugkasten. Lernziele des Kurses Ein komplexes Pakte wie Maple kann man nicht im klassischen Sinne komplett "lernen". Wir zeigen Ihnen die grundsätzlichen Konzepte, die Sie an Hand der Übungsaufgaben trainieren. Anschließend präsentieren wir Ihnen aus dem großen Maple-"Werkzeugkasten" einige wenige Tools aus den Paketen für erweiterte Graphik, für Differentialgleichungen und zur Linearen Algebra. Wir wollen Sie soweit bringen, dass Sie in der Lage sind, sich in die Komponenten von Maple, die Sie gerade benötigen, selbstständig einzuarbeiten, und Maple als selbstverständliches Werkzeug für Ihre tägliche Arbeit einsetzen können. Maple kann viel mehr als das, was wir im Kurs ansprechen, z.b. Statistik, Optimierung usw.. Mit?packages sehen Sie, welche große Menge an Paketen Bestandteil der jeweiligen Maple-Version ist. Darüberhinaus lohnt es sich, die Webpage www.maplesoft.com zu besuchen. U.a. sind hier Maple-Lösungen für zahlreiche Problemstellungen aus allen möglichen Wissensgebieten zusammengetragen. Die Arbeitsumgebung Die Menu- und Symbolleisten entsprechen zunächst mal weitgehend Windows-Standard (z.b. File, Edit, View). Es gibt aber viel spezifische Erweiterungen, die i.d.r. kontext-abhängig sind. Worksheet-Konzept Alles passiert auf einem Arbeitsblatt im Computer. Man unterscheidet: Text-Regionen wie hier gerade; viele Elemente einer normalen Textverarbeitung verfügbar (siehe 3. Fensterleiste) Input-Regionen (gekennzeichnet mit [> ). Hier wird mathematische Eingabe erwartet (Umschalten mit Σ / T) Output-Regionen: hier gibt Maple seine Ergebnisse aus (bzw. die Eingabe schön Page b

dargestellt). > +3; # da fehlt ein ; als Befehls-Abschluß 5 > 3*sqrt(); # sqrt() wird NICHT genähert! 3 > evalf(%); # berechne die letzte Zeile numerisch 4.4640686 > Beachte: die Berechnungen werden Zeile für Zeile in zeitlicher (nicht örtlicher Reihenfolge) abgearbeitet. Algebraische Ausdrücke werden zunächst nicht numerisch ausgewertet, sondern in der exakten Form gespeichert. Die üblichen Editor-Befehle wie Markieren, Ausschneiden, Kopieren usw. gehen (meist) wie unter Windows gewohnt. Manches ist allerdings etwas skurill - einfach ausprobieren, und immer wieder Gebrauch von der Undo-Funktion machen. Um bei größeren Projekten nicht die Übersicht zu verlieren, sollte man die Arbeitsblätter strukturieren (so wie dieses hier). Unter Edit bzw. Format kann man markierte Bereiche zu Sections zusammenfassen, die auf- und zugeklappt werden können (auch manchmal skurill...) Execution Groups sind mit einer Klammer versehene Eingabebereiche (oder auch Textbereiche) (am Zeilenende Shift Return drücken!). Solche Eingabebereiche werden gemeinsam ausgeführt: > x:=sqrt(); > evalf(x); x :=.44356 Maple VR5 läuft eigentlich sehr stabil und stürzt nur ganz selten ab. Nichtsdestotrotz sollte man Save often, save early beherzigen (unter File in der Kopfleiste oder Button mit der Diskette in der Menüleite oder Tastenkombination <Strg>+<s>). Ab und zu möchte man auch vermeiden, dass Maple einem alle Zwischenergebnisse mitteilt: > a:=3+7;b:=4-;a*b; a := 0 b := 0 Dazu kann man einen Maplebefehl alternativ auch mit : abschließen: > a:=3+7:b:=4-:a*b; Page 3 0 Die Hilfsfunktionen Die eingebaute Online-Hilfe ist sehr gut, muss aber auch immer wieder kontaktiert werden. Was gibt's alles an Hilfe? Balloon Help: wenn man mit der Maus über einen Knopf in der Menüleiste fährt, wird die Bedeutung erklärt Maus auf ein Schlüsselwort, dort Strg F oder einfach F drücken. Alternativ kann man im Eingabefeld z.b.?solve eingeben. Beidesmal kommt die ausführliche Hilfeseite mit Beispielen. Unter Maple 8 schaut das ganze etwas schicker aus als in der Version 5: >?solve Über den Hilfe-Knopf in der Menüleiste kann man über die gesamte Doku Volltextsuche machen. Die komplette Online-Doku kann man natürlich auch durchblättern, sie ist gegliedert in die Kapitel Introduction, New User's Tour, Mathematics usw. Wir gehen mit der Maus auf ein blaues Ausgabefeld. Die rechte Maustaste macht uns Vorschläge, welche Operationen vielleicht noch sinnvoll wären. > g:=a*x^+b*x+c; > R0 := diff(g,x); g := a x + b x + c R0 := a x + b Vorgeschlagen wird differenzieren, integrieren, faktorisieren usw. Neue Versionen von Maple bieten da eine viel größere Auswahl. Die ersten Graphiken Die elementaren Graphik-Befehle heißen plot und plot3d. Probieren wir's mal: > plot(sin); Page 4

Ohne weitere Angaben wird eine Funktion in einem automatisch gewählten Bereich dargestellt. Es gibt viele Online-Optionen (Click auf die Graphik! dann rechte Maustaste bzw. Menuleiste). Hunderte Optionen und sehr viele schöne Beispiele (Holen mit Cut&Paste) gibt's über die Online-Hilfe bzw. die Eingabe?plot; Mal ein ganz einfacher 3D-Plot (Darstellung einer Funktion, die von x und y abhängig ist, mit explizit angegebenen Bereichen): > plot3d(sin(x)*cos(y),x=-3..3, y=-3..3); Bitte unbedingt mal damit herumspielen, drehen, die Perspektive, das Lichtmodell usw. ändern! Jetzt noch eine 3D-Animation. Was heißt das? Ich will eine Funktion darstellen, die von x und y und darüber hinaus auch noch von der Zeit abhängt. Also probieren wir: > animate3d(sin(x*t)*cos(y*t),x=-3..3,y=-3..3,t=..); animate3d ( sin( x t ) cos( y t ), x = -3.. 3, y = -3.. 3, t =.. ) Wenn Maple nicht versteht, was man will, wird einfach die Eingabe wieder ausgegeben. Warum tut sich nicht? Viele weitergehende Funktionalitäten von Maple sind in Paketen zusammengefasst, die erst hereingeladen werden müssen, so auch erweiterte Plot-Funktionen > with(plots); [ animate, animate3d, animatecurve, changecoords, complexplot, complexplot3d, conformal, contourplot, contourplot3d, coordplot, coordplot3d, cylinderplot, densityplot, display, display3d, fieldplot, fieldplot3d, gradplot, gradplot3d, implicitplot, implicitplot3d, inequal, listcontplot, listcontplot3d, listdensityplot, listplot, listplot3d, loglogplot, logplot, matrixplot, odeplot, pareto, pointplot, pointplot3d, polarplot, polygonplot, polygonplot3d, polyhedra_supported, polyhedraplot, replot, rootlocus, semilogplot, setoptions, setoptions3d, spacecurve, sparsematrixplot, sphereplot, surfdata, textplot, textplot3d, tubeplot ] Da gibt es also zahlreiche neue Befehle, u.a. auch animate3d : > animate3d(sin(x*t)*cos(y*t),x=-3..3,y=-3..3,t=..0); Page 5 Page 6 3

> Initialisierung, Restart Eine (von diversen) Fallen von Maple: > x:=3; # weisen wir mal x die Zahl 3 zu ( := NICHT =) x := 3 > plot(sin(x)*exp(-x/5),x=0..0); Error, (in plot) invalid arguments Maple8 sagt es etwas konkreter: Error, (in plot) unexpected option: 3 = 0.. 0 Gemeint ist: x ist fest 3 und kann nicht auf einmal von 0 bis 0 laufen! Außer wir vergessen alles: > plot(sin(x)*exp(-x/5),x=0..0); Der wichtigste Befehl am Beginn einer jeden Maple-Sitzung oder neuen Rechnung heißt also Er löscht alle Zuordnungen und beseitigt eventuellen Datenmüll der vorhergehenden Berechnungen. Sollte mal etwas nicht so klappen, wie man sich das denkt und liegt augenscheinlich auch kein Fehler in den Befehlen vor, so ist es oft hilfreich, ganz von vorne mit einem restart anzufangen. restart kann man auch an späterer Stelle beliebig oft einfügen. Bei jedem restart (und beim Starten von Maple) wird die Datei.mapleinit abgearbeitet, falls sie im Arbeitsverzeichnis / Homedirectory vorhanden ist. Sie darf beliebige Maple-Befehle enthalten. Z.B. könnte man damit das Hinzuladen von Paketen automatisieren. Eine kleine Randanmerkung: in diesem Trivialbeispiel hätte auch gereicht: > x=3;x:='x';x; x = 3 x := x x Damit erhält x wieder seine ursprüngliche Bedeutung als (freie) Variable. Page 7 Konstanten in Maple Elementare Konstanten Integer 3, 37, -04; 3, 37, -04 Page 8 4

Fraction (Brüche) Brüche werden automatisch soweit als möglich gekürzt, aber nicht numerisch ausgewertet: > 3 / 37, -09/8; > 7/8, -57/9; > 7/9+3/; Complex Die imaginäre Einheit heißt I (großes I!) > I^; > u := 3 + 4*I; > u^; 3-09, 37 8 3, -3 04 99 - u := 3 + 4 I 7 + 4 I Float (Fließkomma-Zahlen) Fließkomma-Zahlen werden durch einen Dezimalpunkt oder durch die Exponentialschreibweise als solche gekennzeichnet: > 0.3333, -.345, e-3;.3333, -.345,.00 Achtung Wenn man mit Maple exakt (analytisch) rechnen möchte, sollte man es soweit als möglich vermeiden, Fließkommazahlen zu verwenden, also > phi := /4 * Pi; statt > phi := 0.5 *Pi; φ := 4 π φ :=.5 π Sonst bekommt man Schwierigkeiten beim weiterrechnen: > sin (/4 * Pi), evalf(sin (0.5 * Pi));,.70706783 > P := Pi; sin (P); P := π 0 > p := pi; sin (p); # pi ist nicht definiert p := π sin( π) Die Eulersche Zahl steht in Maple als 'exp()' zur Verfügung:. > exp(); e Algebraische Konstanten Algebraische Konstanten bestehen aus den vordefinierten mathematischen Funktionen, angewandt auf elementare Konstante: > sqrt ( + sqrt ()); + Irrationale und transzendente Zahlen werden also nicht numerisch ausgewertet, wie wir schon sahen, sondern so weit wie möglich exakt behandelt. Maple zeichnet sich dadurch aus, das solche Ausdrücke `Ernst' genommen werden: > s := sqrt ( + sqrt ()) * sqrt ( - sqrt ()); > combine (s); s := + I mit combine: Combine terms into a single term. Solche Vereinfachungen werden nicht standardmäßig durchgeführt. Sie müssen jeweils erzwungen werden. Maple 8 liefert im übrigen das Ergebnis I erst nach dem Aufruf eines weiteren Umformungsbefehls namens simplyfy. Zu diesen Umformungsbefehlen später mehr. Strings Maple kann auch mit Textstrings arbeiten. Ein Textstring darf beliebige Zeichen enthalten, die von "... " (doppelte Anführungsstriche) eingeschlossen werden. > str := "Hello world": > str; Variable "Hello world" Achtung: Maple kennt keine Typ-Deklarationen für die Werte, die eine Variable annehmen darf. Jeder Variable dürfen beliebige Werte zugewiesen werden. Variablennamen dürfen in Maple praktisch beliebig lang sein (maximal ^9- Zeichen): > ^9-; Kreiszahl Pi (großes 'P'!! Maple ist case-sensitiv) Page 9 Page 0 5

5487 Man sollte daher soweit als möglich selbsterklärende Variablennamen verwenden: > Geschwindigkeit = Weg / Zeit; Zusammengesetzte Daten-Typen Geschwindigkeit = Es ist essentiell, sich einzuprägen, was Bereiche, Folgen, Listen und Mengen sind. Diese Konstrukte finden permanent in Maple Verwendung. Algebraische Ausdrücke, Gleichungen und Arrays sind ziemlich selbsterläuternd. Algebraische Ausdrücke Variable und Konstanten lassen sich zu beliebigen neuen Ausdrücken kombinieren > exp (sqrt ((sin (x) + Pi)/7 + x)); Weg Zeit e ( / 7 7 sin ( x ) + 7 π + 49 x ) Gleichungen Gleichungen verbinden zwei algebraische Ausdrücke mit = > x=y+z; x = y + z Das Maple-Objekt Gleichung kann auch einen Namen haben: > eq := x=y+z; > eq; eq := x = y + z x = y + z Man beachte wieder die Verwendung von := und =!!! > Range (Bereich) Viele Operationen (Summen, Integrale) erfordern einen (Summations-/Integrations-) Bereich. Bei ersteren handelt es sich um eine Menge ganzer Zahlen, bei zweiten Fall um einen kontinuierlichen Bereich. Immer haben Bereiche haben die Form 'Untergrenze.. Obergrenze' intervall := 0..*Pi;intervall; intervall := 0.. π 0.. π Damit läßt sich dann arbeiten: > int (sin (x), x = 0.. Pi); # Integriere Oder aber auch: > int (sin (x), x = intervall); Oder auch: > fkt := sin (x); Page 0 fkt := sin( x ) > x_range := x = intervall; x_range := x = 0.. π > x:=3;x:='x';int (fkt, x_range); x := 3 x := x 0 Zur Erinnerung: Bei diesen Rechnungen kommt es darauf an, dass wir mit der Variable 'x' als unbestimmte Variable arbeiten. Deshalb geht obiges Spiel in die Hose, wenn der Variable 'x' bereits ein Wert zugewiesen worden ist. Auch der Plot-Befehl arbeitet mit Ranges, wie wir schon gesehen haben. Hier noch ein Beispiel mit einer Summe: > sum(/n^,n=..5); 569 3600 Sequence (Folgen) Eine Sequence ist eine mit Kommas getrennte Folge von Maple-Objekten (Ausdrücken usw.): > x:=,,3; > sqrt (), sin (3/); x :=,, 3, sin 3 Was auch geht: > x:='x':int_arg := fkt, x_range; > int (int_arg); int_arg := sin( x ), x = 0.. π 0 Dieses Beispiel zeigt: eine Funktion, die mehrere Argumente annimmt, bekommt eigentlich nur ein Argument vom Typ Sequence. x muss zuvor zurückgesetzt werden, es zwei Zeilen vorher einer Folge zugewiesen wurde. Die Glieder der Folge sind geordnet. Mithilfe des Auswahloperators [ ] kann man gezielt ein Glied der Folge auswählen, Numerierung ab : > s:=x,y,z; s[]; s := x, y, z y Beispielsweise erhält man beim Lösen von Gleichungen mit Hilfe von solve eine Folge Page 6

von Lösungen, die im Falle einer eindeutigen Lösung die Länge eins hat. erg:=solve(x^-x+=0,x); > erg[]; erg :=, I 3 + I 3 + I 3 Die Funktion seq erzeugt eine Folge aus einer vorzugebenden Vorschrift und wird sehr oft verwendet: > seq(n^,n=..5);, 4, 9, 6, 5 List (Liste) Eine Liste ist eine mit eckigen Klammern eingeschlossene Folge. Sie kann wieder als ein Ausdruck verwendet werden. Die Elemente der Liste haben eine feste Reihenfolge, womit identische Elemente an verschiedenen Stellen immer wieder auftauchen können. > list := [, exp(), exp(0), sqrt(), 0, sqrt()]; list := [, e,,, 0, ] Ein einzelnes Element kann wieder mit dem Auswahloperator [ ] herausgegriffen werden. > list[]; Oder auch > my_seq :=,,3,,,6; > [my_seq]; e my_seq :=,, 3,,, 6 [,, 3,,, 6 ] Listen werden wir z.b. beim Plotten von Datenfeldern benutzen. Dort tauchen dann sogar listlists auf: > plot([[,],[3,4]]); # zeichne simple Gerade Page 3 Set (Menge) Eine Menge ist eine mit geschweiften Klammern eingeschlossene Folge. In einer Menge kommt jedes Element genau einmal vor: > my_set := {,,3,,,6};my_set; Oder auch > my_seq;{my_seq}; my_set := {,, 3, 6 } {,, 3, 6 } my_seq { my_seq } > set := {, exp(), exp(0), sqrt(), 0, sqrt()}; set := {, e, 0, } Man kann zwar auch wieder ein beliebiges Element auswählen, aber: die Reihenfolge der Elemente in einer Menge ist nicht festgelegt (Maple optimiert sie hinsichtlich Zugriffszeit). Sie kann sich für die gleiche Menge von einem Aufruf zum nächsten (auch innerhalb des gleichen Worksheets) ändern! > set[]; restart; set := {, exp(), exp(0), sqrt(), 0, sqrt()}; set[]; e set := {, 0,, e} 0 Es gibt Mengen-Operationen, mit denen man Schnittmengen (intersect), Vereinigungen (union) und Differenzen (minus) bestimmen kann. Page 4 7

> set := {seq(n,n=0..4)}; set := { 0,,, 3, 4} > set intersect set; > set union set; > set minus set; { 0, } {, 0,,, 3, 4, e } {, e } Mithilfe der Funktion member kann man überprüfen, ob ein Ausdruck Element einer Menge ist. > member(sqrt(),set); > member(sqrt(),set); false Lösungen von Gleichungssystemen werden z.b. als Menge zurückgegeben. Array Ein Array ist ein Feld mit einem oder mehreren Indizes. Für jeden Index muß ein Werte-Bereich als Range 'Untergrenze.. Obergrenze' festgelegt werden. Jedes Feld-Element kann beliebige Maple-Objekte enthalten, die nichts miteinander gemeinsam haben müssen: > arr := array (-.. 3, ["he", "ll", "o", "world", 4, sin (alpha)]); arr := array( -.. 3, [ (- ) = "he" (- ) = "ll" ( 0 ) = "o" ( ) = "world" ( ) = 4 ( 3 ) = sin( α) ]) > arr [-]; true "ll" > > arr := array (..4,.., [[,],[3,4],[5,6],[7,8]]); > arr [,]; arr := 3 4 5 6 7 8 4 Bei der Linearen Algebra werden wir uns noch genauer mit Arrays beschäftigen. Dort Page 5 werden wir hauptsächlich mit Spezialfällen von Arrays arbeiten, nämlich mit Vektoren und Matrizen. Bei diesen beginnt das Feld automatisch immer mit dem Index. Noch eine nützliche Anmerkung: Maple behandelt intern Arrays als Listen. Folgendes ist äquivalent: > a:=[seq(i,i=..0)]; > a[3]; > a[3]:=7; > a[3]; a := [,, 3, 4, 5, 6, 7, 8, 9, 0] 3 a 3 := 7 7 > b:=array(..0,[,,3,4,5,6,7,8,9,0]); b := [,, 3, 4, 5, 6, 7, 8, 9, 0] > b[3]; b[3]:=7; b[3]; Operatoren 3 b 3 := 7 Die Standard-Operatoren zum Rechnen sind * / + - ^! (7 * X + 3)^3 / (4 * Y + ); > 4!; 7 ( 7 X + 3 ) 3 4 Y + 4 Vergleichsoperatoren sind < <= => = > Je nach Zusammenhang muss die Auswertung einer solchen Vergleichsoperation gegebenfalls mit evalb (eval boolean) erzwungen werden (analog zu evalf für eine Floatingpoint-Berechnung): > 7>3; > evalb (7 < 3); Logische Operatoren sind not, and und or > not 7<3; Rangordnung - Fakultät! - *, /, mod Page 6 3 < 7 false true 8

- +, - - Vergleichsoperatoren: < <= = >= > <> (ungleich) - not - and - or - der Sequence-Operator ',' - der Zuordnungsoperator ':=' Elementare Rechenfunktionen: abs, exp, ln, sqrt, sin, cos, etc. Maple kennt ihre Eigenschaften: > sin (Pi/3); 3 Eine komplette Liste aller Maple beim Start bekannten Funktionen (ein paar allgemeine und vor allem viel Mathematik) erhält man unter Help mit dem Begriff inifcns (Initially known mathematical functions) oder durch: >?inifcns Funktionen zur Vereinfachung eines Ausdrucks Hier sind nur jeweils ein paar Beispiele aufgeführt. Empfehlenswert: mal die Hilfe für die nachfolgenden Funktionen anschauen! simplify: "Allgemeine" (unspezifische / unkontrollierte) Vereinfachungen (a+b)^+(a-b)^; ( a + b) + ( a b ) Hier findet keine weitere Auswertung statt, obwohl man diesen Ausdruck sicher einfacher schreiben kann. > simplify(%); a + b Das Zeichen % bezieht sich, wie schon gesehen, auf die letzte Ausgabe von Maple, %% auf die vorletzte und %%% auf die drittletzte. simplify ist eine sehr mächtige Funktion, die allerdings ihre Tücken hat! Noch ein Beispiel: > exp_simp := exp(a + ln (b * exp (c))); exp_simp := e ( a + ln ( b ec ) ) > simplify (exp_simp); factor : Faktorisierung eines Ausdrucks b e ( a + c) > exp_fac := 6*x^ + 8*x - 4; > factor (exp_fac); Page 7 exp_fac := 6 x + 8 x 4 6 ( x + 4 ) ( x ) > factor (x^4-,sqrt()); # nur bei ganzen zahlen geht's automatisch ( x + ) ( x + ) collect: Zusammenfassen der Terme mit der gleichen Potenz einer Variablen > f := x*(x+)+y*(x+); > collect (f, x); > collect (f, y); f := x ( x + ) + y ( x + ) x + ( + y) x + y x ( x + ) + y ( x + ) combine: Zusammenfassen von Termen "unter Ausnutzung von Rechenregeln" Ein Beispiel für combine hatten wir ja schon kennengelernt. Hier ein weiteres: > exp_com := exp (sin (x) * cos (y)) * exp (cos (x) * sin (y)); exp_com := e ( sin( x ) ( )) > exp_c := combine (exp_com); cos y e ( cos( x ) sin( y) ) exp_c := e sin ( x + y) combine und expand führen die Umformungen jeweils in umgekehrter Richtung durch: > expand (exp_c); e ( sin( x ) cos( y) ) e ( cos( x ) sin( y) ) Noch ein Beispiel zu combine: > combine (sin(alpha)^3,trig); 3 sin( 3 α) + sin( α) 4 4 expand: "Expandiere" einen Ausdruck ("to distribute products over sums") > exp_exp [] := (x+)*(x+); exp_exp := ( x + ) ( x + ) > expand (exp_exp []); x + 3 x + > exp_exp [] := sin (x+y); exp_exp := sin ( x + y) > exp_exp [3] := expand (exp_exp []); exp_exp 3 := sin( x ) cos( y ) + cos( x ) sin( y ) > combine (exp_exp[3]); sin ( x + y) convert: Bringe Ausdruck in eine andere Form Page 8 9

> convert(exp(z),trig); cosh( z ) + sinh( z ) > convert(exp(i*z),trig); > convert(sin(x),exp); cos( z) + I sin( z) I e ( I x) e ( I x) Im nächsten Abschnitt bei den Reihen kommt noch ein Beispiel zu convert. Reihenentwicklung > reihe:=series( exp(x), x=0, 4 ); # entwickle um x=0 4 Glieder reihe := + x + + + x 6 x3 O( x 4 ) > convert( reihe, polynom ); # jetzt ist der O - Term weg + x + + x 6 x3 > series( /x, x=, 3 ); # entwickle um x= Numerische Berechnungen ( x ) + ( x ) + O ( ( x ) 3 ) In vielen Fällen benötigt man letztlich doch eine näherungsweise numerische Auswertung eines Ergebnisses. Dies bewerkstelligt die Funktion evalf: > sq:=sqrt(); > evalf(sq); oder man berechnet > sqrt(.0); sq :=.44356.44356 Die Zahl der Stellen, die Maple berechnen soll, ist ein weiteres optionales Argument zu evalf: > evalf(sq,0);.443563730950488 Aber Vorsicht: Numerische Rechnungen sind immer mit Rundungsfehlern behaftet: > sqrt()*sqrt(8)-4; 0 > evalf(sqrt())*evalf(sqrt(8))-4; -. 0-8 Page 9 Vielleicht hilft es ja, die Zahl der Stellen hochzusetzen. Dazu gibt es eine Maple-Variable namens Digits. Setzt man diese auf einen Integerwert, so rechnet Maple numerisch mit der angegeben Zahl von Stellen, bis Digits neu zugewiesen wird. So kann man die erweiterte numerische Genauigkeit für den gesamten Ausdruck gültig machen (standardmäßig ist für Digits der Wert 0 eingestellt): > Digits; Digits:=50; evalf(sqrt())*evalf(sqrt(8))-4; Digits:=0; 0 Digits := 50 -.3 0-48 Digits := 0 Achtung: Wie schon erwähnt: Maple wird alle Ausdrücke numerisch auswerten, in denen man explizit float-zahlen benutzt: > sqrt(0.)*sqrt(8)-4;.63455530 4 Auf jeden Fall sollte man also Argumente von Funktionen immer als rationale Zahlen schreiben, wenn man damit noch weiter rechnen will: > sqrt(/0)*sqrt(8)-4; > simplify(%); Noch ein Beispiel: > 00!; 5 0 4 5 5 4 93365443944568699388566670049075968643864685996389575\ 999939956089446397656588653697908737585850968640000\ 00000000000000000000 > evalf(%); Lösen von Gleichungen.9336544 0 58 Einfache Gleichungen (und Ungleichungen) Eine besondere Stärke von Maple ist das Lösen von Gleichungen: > solve(x^+x-=0,x); + 5, 5 Beachte: Maple gibt wieder die exakte Lösung (so vorhanden) aus. Natürlich geht auch Page 0 0

> eq:=x^+x-=0; > sol:=solve(eq,x); eq := x + x = 0 sol := + 5, 5 Die einzelnen Lösungen erscheinen hier als Folge (also geordnet). Wenn man auf die verschiedenen Lösungen zugreifen will, kann man das so machen: > a:=sol[];b:=sol[]; a := + 5 b := 5 Man kann auch Nebenbedingungen angeben (d.h. Gleichungen und Ungleichungen simultan lösen): > solve(x^-=0,x); > solve({x^-=0,x>0},x);, - { x = } Man beachte die Mengenklammer sowohl beim Argument von solve als auch beim Ergebnis. Wie man dieses Ergebnis dann weiterverwendet, werden wir gleich sehen. Lineare Gleichungssysteme Mit demselben Befehl solve lassen sich auch Gleichungssysteme (lineare und nichtlineare) behandeln. Hier erst mal ein lineares: > sol:=solve({x+*y-*z=5,3*x-y+z=-, -4*x+y-7*z=0},{x,y,z}); 3 5 sol := { z =, y =, x = } 4 4 7 Man beachte, dass das System von Gleichungen wieder in geschweiften Klammern als Menge übergeben wird. Ebenso müssen die Unbekannten als Menge übergeben werden. Die Reihenfolge der Lösungen ist hier willkürlich, sie werden als als Menge zurückgegeben! Um auf die einzelnen Lösungen zurückzugreifen, könnte man im Prinzip Folgendes machen: > sol[];sol[];sol[3]; Page 3 z = 4 5 y = 4 x = 7 Beim nächsten Durchlauf könnte aber die Zuordnung anders sein. Ausserdem hat man noch keine Zuordnung der Lösungen zu den Variablen bekommen, die Variablen x,y,z sind nicht belegt: > z; z Für solche Zwecke gibt es die Befehle subs und assign. subs ersetzt in einem Ausdruck eine Variable durch einen Wert (makes the substitution specified by the first argument in the last argument). In diesem Fall bedeutet das konkret: > subs(sol,z); z; # nur temporär! z > z:=subs(sol,z); z; # so ist's dauerhaft 3 4 3 z := 4 4 > z:='z'; assign(sol); x;y;z; # auch dauerhaft 3 z := z 4 assign ist doch ganz praktisch: "If the argument is a list or set of equations, then assign is applied to each equation in the list or set." > 7 5 Nicht-Lineare Gleichungssysteme eq:={x^+/y^=,y^-x^=},{x,y}; > sol:=solve(eq); 4 3 eq := { x + =, y x = }, { y, x} y sol := { y =, x = 0 }, { y = -, x = 0 }, { y = RootOf ( _Z ), x = }, { y = RootOf (_Z ), x = -} Die Lösung nichtlinearer Gleichungen oder Gleichungssysteme wird, speziell bei Polynomen, häufig in der impliziten RootOf-Notation angegeben ("any root of"). Maple erspart sich damit die explizite Berechnung, die bei Polynomen höheren Grades entweder nicht geschlossen möglich ist bzw. auf ziemlich unübersichtliche Ausdrücke führt. Ist man dennoch an den Lösungen interessiert, dann hilft der Befehl allvalues Page

weiter: > p3:=allvalues(sol[3]); p3 := { x =, y = }, { x =, y = } Jetzt kann man noch die Lösungen den Variablen zuordnen: > x:=subs(p3[],x); y:=subs(p3[],y); x := y := Natürlich kann man das Problem auch numerisch lösen: > #fsolve = solve using floating point arithmetic fsolve({x^+/y^=,y^-x^=},{x,y}); { x =.000000000, y = -.44356 } Offensichtlich fehlen hier einige Lösungen. Hier muss man experimentieren, indem man in den Variablen einen Startwert angibt: > fsolve({x^+/y^=,y^-x^=},{x=,y=-.4}); { x =.000000000, y = -.44356 } Die verschiedenen Lösungen findet man am besten, wenn man das System erst mal grafisch löst. Näheres später, aber hier schon ein Eindruck: > with(plots): > implicitplot({x^+/y^=,y^-x^=},x=-.., y=-..); > sum(n,n=..00); > sum(n,n=..n); > simplify(%); 5050 ( N + ) N + N N > sum( (*n-5)/(3*n^+4*n-0), n=0..0); > evalf(%); 406906865 77903043.805967899 Berechnung unendlicher Summen (unendlich heißt in Maple infinity): > sum(/n,n=..infinity); > sum(x^n,n=0..infinity); x Das Ergebnis macht natürlich nur Sinn (Konvergenz der geometrischen Reihe!), wenn x < ist. Wenn man nichts angibt, nimmt Maple oft günstige Bedingungen an. Manchmal muß Maple solche Bedingungen wissen. Mitteilen kann man sie mittels assume: > assume(x>); sum(x^n,n=0..infinity); Die Schlange hinter der Variablen deutet an, dass sie mit einer Bedingung verknüpft ist. Hier: x ist reell und zwischen - und +. Wenn man mehrere Bedingungen an dieselbe Variable stellen will, muss man das mit additionally machen. Natürlich kann man Maple auch andere Dinge über eine Variable mitteilen: > Re(a+I*b);Im(a+I*b); > assume(b,real,a,real); > Re(a+I*b);Im(a+I*b); R ( a + I b) I ( a + I b ) b~ > assume(p,integer);additionally(p,positive); about(p); a~ Summen und Produkte; Eigenschaften von Variablen Berechnung endlicher Summen: Page 3 Originally p, renamed p~: is assumed to be: AndProp(integer,RealRange(,infinity)) > assume(z,complex):about(z); # was ist über z bekannt? Originally z, renamed z~: Page 4

is assumed to be: complex Und so weiter. Die ganze Liste möglicher Eigenschaften findet man mittels?property >?property Die Berechung von Produkten erfolgt analog mit dem Befehl product. Beispielsweise kann man auch so Fakultäten berechnen: product(n, n=..0); 0!; 439000876640000 439000876640000 Oder etwas komplizierter: > product((n^-)/(n^+4), n=0..0); 635633969 4305630000 Auch hier kann man unendliche Produkte berechnen: > product(n, n=..infinity); > prod:=product((n^-)/(n^+4), n=0..infinity); prod := n = 0 n n + 4 Hier ist die Ausgabe eines geschlossenen analytischen Ergebnisses mit Maple 5 offenbar nicht möglich. Maple 8 schafft es! Probieren wir's numerisch: > evalf(prod); # geht leider auch nicht bei Maple V Error, (in evalf/product) cannot evaluate boolean > product((n^-.0)/(n^+4.0), n=0..infinity);.00545639645 Bei Maple 8 wird das Ergebnis nach einem Befehl analytisch exakt angegeben. Differenzieren, Integrieren und Grenzwerte Differenzieren >?diff; > diff(x^,x); > diff(exp(x),x); > diff(sin(x),x); x cos( x ) > diff(sin(x),x$); #. Ableitung Page 5 e x sin( x) Natürlich beherrscht Maple auch Produkt-, Quotienten- und Kettenregel: > diff(sin(x)*exp(x),x); cos( x) e x + sin( x ) e x > diff(x^/sin(x),x); > diff(sin(exp(x)),x); x sin( x) cos( e x ) e x x cos( x ) sin( x ) Statt des Befehls diff gibt es auch eine alternative Schreibweise mit dem D-Operator: > D(sin)(x); > (D@@)(sin)(x); >?D oder allgemeiner formuliert: > (D@@)(sin); > D(sin*cos); cos( x ) sin( x) cos sin Sie ist oft sehr praktisch (und manchmal auch unentbehrlich), allerdings klappt's nicht immer so wie gewünscht: > D(x^)(x); sin D( x )( x ) x( x ) Die korrekte Schreibweise wäre (mehr dazu weiter unten bei Funktionen) : > D(x->x^)(x); x Integrieren Integrieren geht analog. Unbestimmte Integrale (wieder mit "impliziter Wahl günstiger Verhältnisse"): > int(x^n,x); > int(sin(x),x); > int(sin(x)^,x); Bestimmte Integrale > int(x^n,x=a..b); x ( n + ) n + cos( x) cos( x ) sin( x) + x Page 6 3

b n b a a n n + Maple 8 meckert hier bereits: Warning, unable to determine if 0 is between a and b; try to use assumptions or use the > int(sin(x),x=0..*pi); > int(sin(x)^,x=0..*pi); AllSolutions option π > int(exp(-x),x=0..infinity); Beim Integrieren kann auch die assume-funktion sehr hilfreich sein: > a:='a':int(exp(-a*x),x=0..infinity); Definite integration: Can't determine if the integral is convergent. Need to know the sign of --> a Will now try indefinite integration and then take limits. lim 0 e ( a x ) x a Maple 8 läßt die Anmerkung weg, agiert aber ansonsten genauso. Ausweg: > assume(a>0):int(exp(-a*x),x=0..infinity);about(a); a~ Originally a, renamed a~: is assumed to be: RealRange(Open(0),infinity) Sollte Maple ein bestimmtes Integral nicht knacken können, so kann es dieses immer noch numerisch berechnen: > int(sin(sqrt(x^3+)+),x=0..*pi); > evalf(%); 0 π sin ( x 3 + + ) dx.64535635 Kleine abschließende Bemerkung: es gibt auch Diff und Int (gross geschrieben); sie rechnen nicht, sondern geben den Input nur schön aus: > Diff(exp(x),x); > Int(sin(x)/x,x=0..); Page 7 x ex sin( x ) dx x 0 Grenzwerte Auch Grenzwerte von Funktionen oder Folgen lassen sich mit Maple berechnen: > limit(sin(x)/x,x=0); > limit((n+/n)/(4*n-),n=infinity); 4 Auch hier ist es oft hilfreich, Maple mittels assume über die Eigenschaften von Variablen zu informieren: > limit(exp(-b*x), x=infinity); lim x e ( b x) > assume(b>0);limit(exp(-b*x), x=infinity); 0 Auch rechts und linksseitige Grenzwerte können bestimmt werden: > limit(/x, x=0); undefined Aber: > limit(/x, x=0, left); limit(/x, x=0, right); Funktionen Definition von Funktionen Die Definition von Funktionen geht mit dem -> Operator: > f:=x->x^5; f := x x 5 x ist nur eine formale Variable und nach außen hin nicht sichtbar! > x; > f(3); > f(y); > f(sin(z)); sin( z ) 5 Achtung: Die Variable auf der linken Seite darf kein Argument aufweisen! So nicht! Page 8 x 43 y 5 4

> g(x):=x->x^5; # so ist's ungut! > g(3); > g(x)(3); g( x ) := x x 5 g( 3 ) 43 Man hat hier also die Funktion g( x ) und nicht g genannt. Eine weitere nützliche Funktionskonstruktion ist piecewise, mit der man Funktionen zusammenstückeln kann: > f:=x->piecewise(x<0,0,x>0,x^); > f(-);f(); f := x piecewise ( x < 0, 0, 0 < x, x ) 4 Differenzieren von Funktionen, Integrieren Mit der neuen Funktion f kann man jetzt alle bekannten Manipulationen ausführen: > f:=x->x^5;f(x);f; > diff(f(x),x); 0 f := x x 5 Jetzt verwenden statt diff den Operator D. In der Online-Hilfe steht dazu: Calling Sequence: D(f) Parameters f: expression which can be applied as a function > D(f); # erste Ableitung, Ergebnis wieder als Funktion x 5 f 5 x 4 x 5 x 4 > D(f(x)); # so nicht! 5 D( x ) x 4 > D(f)(x); # erste Ableitung, Ergebnis als Ausdruck 5 x 4 > D(D(f)); # zweite Ableitung x 0 x 3 > (D@@)(f); # auch zweite Ableitung Page 9 x 0 x 3 > (D@@3)(f); # dritte Ableitung x 60 x > D(f@sin); # Ableitung von f(sin(x)) # nicht gerade günstig ( x 5 x 4 )@ sin cos > D(f@sin)(x); # als Ausdruck ist's hier praktischer 5 sin( x ) 4 cos( x ) > D(sin@f)(x); # Ableitung von sin(f(x)) 5 cos( x 5 ) x 4 Wie man sieht, lassen sich höhere Ableitungen durch (D@@m)(f)(x) mit natürlichen Zahlen m und Ableitungen von Verknüpfungen von Funktionen wie z.b.f(sin(x)) bzw. sin(f(x)) als D(f@sin)(x) und D(sin@f)(x) abkürzen. Der Operator @ bezeichnet also die Verknüpfung zweier Funktionen: > (f@sin)(x); > (sin@f)(x); sin( x) 5 sin( x 5 ) Auch Integrationen von Funktionen lassen sich wie gewohnt durchführen. > int(f(x),x); > int(f(x),x=-..); 6 x6 0 > int(sin(sqrt(f(x)+)+),x=0..pi); > evalf(%); sin ( x 5 + + ) dx 0 π.6630648383 Funktionen mehrerer Variabler Natürlich lassen sich in Maple auch Funktionen mehrerer Veränderlicher definieren. Hier als Beispiel die Bahnkurve beim schrägen Wurf mit Anfangsgeschwindigkeit v und Abwurfwinkel α: > y:=(x,alpha,v)->tan(alpha)*x-/*g/(v*cos(alpha))^*x^ ; Ableitungen gehen so: y := ( x, α, v ) tan( α) x Page 30 g x v cos( α) 5

> D[](y); # Ableitung nach erstem Parameter x g x ( x, α, v ) tan( α) v cos( α) > (D[]@@)(y); # und nochmal nach x abgeleitet g ( x, α, v) v cos( α) > diff(y(x,alpha,v),x); # wieder Ableitung nach x g x tan( α) v cos( α) > D[](y); # Ableitung nach zweitem Parameter alpha Funktionen und Ausdrücke ( x, α, v ) ( + tan( α) ) x g x sin( α) v cos( α) 3 Weiter oben hatten wir schon Ausdrücke kennengelernt. Ausdrücke und Funktionen sind miteinander verwandt, aber nicht identisch; bei manchen Anwendungen funktioniert aber nur die Darstellung als Funktion, woanders gehen nur Ausdrücke. Man kann aber leicht hin und her wandeln. a:=x^+*x+; > solve(a,x); a := x + x + -, - > a(7); # das ist Unsinn - geht nur mit Funktionen x( 7 ) + x( 7) + > subs(x=7,a); # das ist wohl gemeint 34 subs hatten wir ja schon kennengelernt in einer etwas anderen Form - dies hier ist die 'klassische' Variante. > eval(a,x=7); # so geht's auch: # evaluate an expression e at a given point 34 Funktionen wie oben sind eine Abbildungsvorschrift, man kann sie nicht "lösen"( Maple V und auch Maple 8 geben hier außnahmsweise gar nichts zurück - d.h. er kann mit irgendeiner Eingabe nichts anfangen): > f:=x->x^+*x+;f(7); solve(f,x); Page 3 f := x x + x + 34 f(x) ist aber wieder ein Ausdruck, den man lösen kann: > solve(f(x),x); -, - Umgekehrt kann man mit unapply aus Ausdrücken auch Funktionen machen: > h:=sin(x)*5; > fh:=unapply(h,x); > fh(x); > fh(); evalf(fh()); > j:=sin(x)*cos(y)+z^3; > unapply(j,x,y,z); Noch 'ne kleine Falle: f:=x->x^5; > f:=x->diff(f(x),x); > f(x); h := 5 sin( x) fh := x 5 sin( x ) 5 sin( x) 5 sin( ) 4.54648734 j := sin( x ) cos( y ) + z 3 ( x, y, z ) sin( x ) cos( y ) + z 3 f := x x 5 f := x diff ( f( x), x ) 5 x 4 > f(); Error, (in f) wrong number (or type) of parameters in function diff oder aussagekräftiger in Maple 8: Error, (in f) invalid input: diff received, which is not valid for its nd argument Kann so nicht ausgewertet werden. Es wird zuerst x = gesetzt und dann differenziert, was dann nicht mehr geht. Ausweg: > f:=unapply(diff(f(x),x),x); > f(); f := x 5 x 4 5 Arbeitet man gleich mit dem D-Operator, gibt's dieses Problem nicht: > f:=d(f); f := x 5 x 4 Page 3 6

> f(); 5 Page 33 7

Einführung in Maple Stand Januar 05 (Version 3.0) - F.Wünsch Dieses Skript basiert auf Kursen von Julian Berwanger, Martin Decker, Thomas Pruschke, Joachim Keller und Harald Dobler, Florian Chmela und Roland Winkler. Kap. : Grundlagen Kap. : Graphik mit Maple Kap. 3: Lösung von Differentialgleichungen mit Maple Kap. 4: Programmierung und Prozeduren Kap. 5: Lineare Algebra Graphik mit Maple Noch paar einfache Plots Ein paar Plots hatten wir ja schon. Maple ist sehr reich an Darstellungsmöglichkeiten. Hier zunächst noch ein paar einfache, in den anschließenden Abschnitten zeigen wir auch ziemlich komplizierte. Auch mehrere Funktionen pro Plot sind möglich. Dazu muss man als Argument eine Menge {f,f,...} oder eine Liste [f,f,...] mit den Funktionen übergeben: > plot([exp(-x),sin(x),cos(x),/(+x)],x=0..4*pi,color=[red, blue,green,black]); Plotten kann man eine Funktion f in der Form f(x), x=a..b. Verschiedene Darstellungsstile und Auflösungen sind beim Plot-Befehl möglich und können unter?plot eingesehen werden: > plot(sin(x),x=0..4*pi,style=point, symbol=circle,color=red,numpoints=00); Page Auch Parameterdarstellungen lassen sich plotten:. Funktion Abszisse (horizontal).. Funktion Ordinate (vertikal), auch der Bereich muss mit in den eckigen Klammern stehen: > plot([sin(*t),cos(t),t=0..00*pi],scaling=constrained,num Page 8