mupad.mus - Fakultät für Mathematik und Informatik
Werbung
MuPAD
Session
Notebook
Das Computeralgebrasystem MuPAD
0. Bemerkungen
Vor dem Arbeiten mit diesem Notebook bitte im Menu View -> Options "Word Wrap" auf
"Wrap to Window" setzen.
Sollte das Ausführen von Befehlen zu Fehlern oder zu gar keiner Ausgabe führen, schließen Sie
bitte das Notebook und öffnen Sie es erneut, um an der entsprechenden Stelle fortzufahren.
Achtung: Hierbei kann es nötig sein, vorangegangene Befehle nochmals ausführen zu müssen,
da MuPAD sonst selbstdefinierte Funktionen oder Variablen nicht bekannt sind.
Bei der grafischen Darstellung von Funktionen in der VCam kann es zu Problemen kommen.
Abhilfe schafft meist das Umstellen des Scaling auf "UnConstrained" in den VCam Properties.
1. Einführung
Ursprünglich: Verwendung von Computern ausschließlich für numerische Berechnungen.
---->
Numerische Berechnung:
Funktionswert
Wissenschaftliche Berechnung:
Formeln)
"symbolischer Text" (Argumente)
(1) Algebraische Berechnung (Umformung von
(2) Numerische Berechnung
Steigende Bedeutung algebraischer Berechnungen:
1. Vorbereitung effizienter
numerischer Berechnungen
2. theoretische Zwecke
(Theorembeweise)
3. liefern im Gegensatz zur
Numerik exakte Ergebnisse
Algebraische Berechnung:
"Äquivalenzumformer"
"symbolischer Text" -----------------------------------> "äquivalenter symbolischer
Text"
Beispiel: Äquivalente Umformung von Polynomen
(a) Ausmultiplizieren
expand ((x-1)^10);
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
(b) Faktorisieren
factor (1 - 10*x + 45*x^2 - 120*x^3 + 210*x^4 - 252*x^5 + 210*x^6 - 120*x^7 + 45*x^8x^10);
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
10*x^9 +
·
·
Computeralgebra ist der Teil der Informatik, der sich mit der Erstellung,
Analyse, Implementierung und Anwendung algebraischer Algorithmen
befaßt.
Merkmale von Computeralgebrasystemen:
(a) großer Hauptspeicherbedarf
(b) relativ langsam bei zu kleinem Speicher
(c) meist interaktive Nutzung
(d) bearbeitete Daten sind meist mathematische Ausdrücke und haben Listen- bzw.
Baumstruktur
(e) Implementierung meist in LISP (List Programming Language)
(f) dynamische Speicherplatzverwaltung
(g) ältere Computeralgebrasysteme waren ungeeignet für Numerik und Graphik
Bemerkungen zu MuPAD:
(A) Version 1.1 (1993), Version 1.2.9a (1996), Version 2.0 (2001), aktuell Version 2.5.2
(B) Einheit von Computeralgebra, Numerik und Graphik
(C) lauffähig unter Windows, Apple-Macintosh, Linux, Solaris, ...
(D) Festplattenbedarf:
- Version 1.2.9a ca. 16 MByte
(E) ab Version 2.0 Unterscheidung zwischen:
- MuPAD Light (kostenlos)
Einschränkungen:
- kein Notebook-Konzept
- Light hat nur 2D-ASCII-Ausgabe, sogenannte Prettyprints
- keine interaktive Manipulation von Grafiken
- es muss alles per Befehl in MuPAD-Syntax spezifiziert werden
- MuPAD Pro (ca.1000 Euro)
zusätzliche Eigenschaften von MuPAD Pro:
- interaktive Erstellung von Grafiken
- Grafiken können in Notebooks eingebettet werden
- neue Objekte können interaktiv mittels Dialogen definiert und in
eine bestehende Szene eingefügt werden
- alle Eigenschaften von Objekten und Szenen können interaktiv
mittels Dialoge konfiguriert werden
- beliebiges Vergrößern, Verkleinern und Drehen von Szenen und
mausgesteuerte Verschiebung von Beschriftungen
- PostScript-Ausgabe (EPSF)
- Speichern der Grafiken in diversen Formaten, u.a. Windows
Metafiles, BMP, JPEG, PNG, TIF
- VCam Pro-Grafiken sind OLE-Objekte
- HTML-Export der MuPAD Notebooks (ab V 2.5)
Weitere Computeralgebrasysteme:
* Maple V
* Derive
* Axiom
* Macsyma
* Mathematica
2. Numerik
Allgemeine Merkmale:
* keine Typvereinbarungen für Variablen oder Funktionen (integer, real, array, ...)
* soweit möglich, exakte Ergebnisse
Beispiele:
1/3 + 2/7;
·
·
·
3^100;
·
·
·
fact (330)
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
# Fakultät #
·
·
;
·
·
ifactor(70612139395722186);
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
* "beliebige" Genauigkeit erreichbar
Beispiel:
DIGITS :=100: float(sqrt(10))
·
·
·
·
·
·
# auf 100 Stellen gerundet; float erzwingt Gleitkommazahl # ;
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
* es existiert eine Vielzahl numerischer Funktionen
Beispiele:
float(sum (1/(i^3), i = 1..infinity));
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
solve(x^2-2 = 0, x) ;
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
float ( solve( (x^5) + x + 1 = 0, x ) );
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
plot2d( Axes = None, Ticks = 1,
TitlePosition = Below,
Scaling=UnConstrained, # Skalieren der Funktion: die Festlegung auf unconstrained
wird aber ignoriert, Einstellung über VCam -> Properties #
[ Mode = Curve,
[x, x^3 - 2 * x^2 + 2 ], x = [-5, 5], Grid = [100] ] );
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
f := proc(x) # die Deklaration einer Funktion erfolgt in MuPAD über eine Prozedur #
begin
a:=x^3-2*x^2+2
end_proc ;
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
solve (diff(f(x), x) =0, x);
·
·
·
·
·
·
·
·
·
·
f(4/3);
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
weitere Beispiele:
2.4^45;
·
·
·
·
·
·
·
(( 24 *( 10 ^ (-1)) ) ^ 45);
·
·
·
·
·
·
·
·
·
·
float (%);
·
·
·
·
·
·
·
·
·
·
f:=NIL; a:=NIL # Freigabe von a und f #;
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
3. Computeralgebra
Arbeitsweise: Es werden solange Transformationsregeln auf den gegebenen Ausdruck
angewendet, bis sich dieser nicht mehr ändert. Dabei sind auch rein formale Variablen
verwendbar.
In traditionellen Programmiersprachen werden Variablen nur als Namen für Objekte (Zahlen
etc.) benutzt.
Einige Beispiele:
(a) Summen und Grenzwerte
sum (1/(i^2), i = 1..infinity);
·
·
·
·
·
·
·
limit( sin (x ) / x, x =0 );
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
(b) Mengenoperationen
m1 := {a, b, c, d};
m2 := {c, d, f, g};
allmenge := {a, b, c, d, e, f, g, h};
·
·
·
·
·
·
·
·
·
·
m1 union m2;
·
·
·
·
·
·
·
·
·
·
m1 intersect m2
# Schnittmenge # ;
·
·
·
·
·
·
·
·
·
·
allmenge minus m1;
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
(c) Lösen von Gleichungen und Gleichungssystemen
solve( x ^ 2 + 2* x - 7 = 0, x );
·
·
·
·
·
·
·
·
·
·
solve( { a*x + y = 0, 2*x + (1 - a)*y = 1 }, { x, y });
·
·
·
·
·
·
·
·
·
·
solve (x^2 -2=0, x);
·
·
·
·
·
·
·
·
·
·
(d) Listen
Listen sind grundlegende Strukturen der Computeralgebra. Sie können für Mengen, Felder
(Arrays),... verwendet werden. Die in MuPAD benutzte Grundform für beliebige Ausdrücke
basiert auf dem Listenkonzept; man erinnere sich auch an die den meisten
Computeralgebrasystemen zugrundeliegende Programmiersprache LISP.
Liste := table (n=fact(n) $ n=1..15)
# die Schrittweite ist immer auf 1 festgelegt #
·
·
·
·
·
·
·
·
·
for i from 1 to 15 step 1 do
Liste [i] := float (ln(Liste[i]))
·
·
·
·
·
·
;
·
# neue Liste über for-Schleife berechnet #
end_for
# mit Doppelpunkt statt Semikolon wird die
Ausgabe des Ergebnisses unterdrückt # :
·
·
·
·
·
·
·
·
·
·
·
·
·
·
DIGITS := 10: Liste
# Ausgabe der neuen Liste mit Rundung auf 10
Stellen # ;
·
·
·
·
·
·
·
·
·
·
·
·
·
·
Liste1 := []:
for i from 1 to 15 step 1 do
Liste1 := Liste1.[point(i,Liste[i])]
# Erstellen einer Liste mit x- und y- Punkten #
end_for:
·
·
·
·
·
·
·
·
·
·
·
·
·
·
plot2d ([ Mode = List, Liste1 ])
# diese wird hier gezeichnet # ;
·
·
·
·
·
·
·
·
·
·
·
MuPAD hat keine vordefinierte Funktion zur Bestimmung einer
·
·
·
Approximationsfunktion für diese Punkte.
(f) Transformationsregeln
Transformationsregeln sind ein wesentliches Werkzeug zur Steuerung der Arbeit von MuPAD.
Neben der Vielzahl systemspezifischer Transformationsregeln besteht die Möglichkeit der
Verwendung nutzerdefinierter Transformationsregeln, die universell einsetzbar sind. Als globale
Transformationsregeln finden Definitionen der folgenden Form Verwendung:
f := proc(x)
begin
a:=x^2
end_proc;
·
·
·
·
·
( f(3) + f(b+c) );
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
oder auch globale Wertzuweisungen der Art
d:=3:
d^3;
·
·
·
·
·
·
·
·
·
a:=NIL;b:=NIL;c:=NIL;d:=NIL;f:=NIL;
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
Lokale Transformationsregeln benutzt man folgendermaßen:
f := proc(x)
begin
a:=1 + x^2 + 3* x^3
end_proc;
·
# lokale Variablen werden in die Prozedur geschrieben #
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
f(1+b);
·
f:=NIL; a:=NIL;
·
·
·
·
(g) Integration
int (x^n, x);
·
·
·
·
·
·
int ( (ln(x)^2) * ((1 + x^2 ) / x), x );
·
·
·
·
·
·
·
·
diff (%,x);
·
·
·
·
·
·
·
·
float ( int (sin( sin( x)), x=0..1 ) );
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
4. Grafik
Die graphischen Möglichkeiten von MuPAD sind faszinierend, sie umfassen zweidimensionale
sowie "dreidimensionale" Darstellungen. Dabei sind auch Darstellungen von in Parameterform
gegebenen Kurven und Flächen möglich. Die Darstellung kann interaktiv beeinflusst werden.
(a) 2D-Graphik
- Polynome
Wir definieren eine Funktionenschar mit Parameter a:
f := proc(x)
begin
b:=a*x^3 + 3*x^2 - 2
end_proc:
·
·
·
·
·
·
·
·
·
·
df1:= diff(f(x),x);
·
·
·
·
·
·
·
·
·
·
df2:= diff(f(x),x,x);
·
·
·
·
·
·
·
·
·
·
a:=1;
·
·
·
·
·
·
·
·
·
·
plot2d( Axes = None, Ticks = 1,
TitlePosition = Below,
Scaling=UnConstrained,
[
Mode = Curve,
[x, f(x)], x = [-5, 5], Grid = [50]
]
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
);
·
·
·
plot2d(
·
·
·
·
·
·
·
·
·
·
·
·
·
plot2d( Axes = None, Ticks = 1,
TitlePosition = Below,
Scaling=UnConstrained,
[
Mode = Curve,
[x, f(x)], x = [-5, 5], Grid = [50]
],
[
Mode = Curve,
[x, df1], x = [-5, 5], Grid = [50]
],
[
Mode = Curve,
[x, df2], x = [-5, 5], Grid = [50]
]
);
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
Axes = None, Ticks = 1,
TitlePosition = Below,
Scaling=UnConstrained,
[
Mode = Curve,
[x, df1], x = [-5, 5], Grid = [50]
]
);
plot2d( Axes = None, Ticks = 1,
TitlePosition = Below,
Scaling=UnConstrained,
[
Mode = Curve,
[x, df2], x = [-5, 5], Grid = [50]
]
);
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
Nun demonstrieren wir den Einfluss des Parameters a auf die Funktionen der Schar f(x) =
a*x^3 + 3*x^2 - 2, indem wir a von 0 bis 2 variieren:
Als erstes wird eine Tabelle definiert, in der die 20 einzelnen Funktionen abgespeichert werden.
Danach wird mit Hilfe der Tabelle eine Liste erstellt, worin die Parameter für die Plotfunktion
zusammen mit den zu zeichnenden Funktionen abgelegt werden. Dies geschieht u. a., um im
Plotbefehl Schreibarbeit zu sparen. Nun wird der Plotbefehl mit allen Elementen der Liste
ausgeführt. Dabei ist es in MuPAD leider nicht möglich, innerhalb des Plotbefehls den
Sequenzoperator( plot2d=(Liste [i] $ i=1..21) ) zu verwenden. Weiterhin ist es nicht möglich, das
Element 0 einer Liste im Plotbefehl auszuwählen. Deshalb zählen wir von 1 bis 21.
a:=NIL;
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
Liste := table ((a+1)=(a/10)*x^3 + 3*x^2 - 2 $ a=0..20);
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
Liste2:=[]:
for i from 1 to 21 step 1 do
Liste2:=Liste2.[ [Mode= Curve, [x,Liste[i]], x=[-5,5], Grid=[100]] ]
end_for:
·
·
·
·
·
·
·
·
·
·
·
·
·
·
plot2d ( Liste2[1], Liste2[2], Liste2[3], Liste2[4], Liste2[5], Liste2[5], Liste2[6], Liste2[7], Liste2[8],
Liste2[9], Liste2[10], Liste2[11], Liste2[12], Liste2[13], Liste2[13], Liste2[14], Liste2[15], Liste2[16],
Liste2[17], Liste2[18], Liste2[19], Liste2[20], Liste2[21] );
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
a:=NIL; Liste:=NIL; Liste2:= NIL;
·
·
·
·
·
·
·
·
·
·
·
·
·
·
- Logarithmusfunktion
Wir definieren eine Funktionenschar mit Parameter a:
a:=NIL; b:=NIL;
·
·
·
·
·
·
·
·
·
·
h := proc(x)
begin
b:=ln((a*x + b)^2 )* sin(x)
end_proc;
·
·
·
·
·
·
·
d1h:=(diff(h(x),x));
·
·
·
·
·
·
·
d2h:=diff(h(x),x,x);
·
·
·
·
·
·
·
a:=1;
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
b:=2;
·
·
·
·
·
·
·
·
·
·
·
plot2d( Axes = None, Ticks = 1,
TitlePosition = Below,
Scaling=UnConstrained,
[ Mode = Curve,
[x, h(x)], x = [-7, 15], Grid = [50]
]
);
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
plot2d( Axes = None, Ticks = 1,
TitlePosition = Below,
Scaling=UnConstrained,
[ Mode = Curve,
[x, d1h], x = [-7, 15], Grid = [50] ]
);
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
plot2d( Axes = None, Ticks = 1,
TitlePosition = Below,
Scaling=UnConstrained,
[ Mode = Curve,
[x, d2h], x = [-7, 15], Grid = [50] ]
);
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
plot2d( Axes = None, Ticks = 1,
TitlePosition = Below,
Scaling=UnConstrained,
[ Mode = Curve,
[x, h(x)], x =[-7, 15], Grid = [50] ],
[ Mode = Curve,
[x, d1h], x = [-7, 15], Grid = [50] ],
[
Mode = Curve,
[x, d2h], x =[-7, 15], Grid = [50]
]
);
·
·
·
·
·
·
·
·
·
·
(b) 3D-Graphik
plot3d(Axes = Box, Ticks = 0,
TitlePosition = Below,
[ Mode = Surface,
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
[u, v, sin(u*v)],
u = [0, 3], v = [0, 3],
Grid = [30, 30],
Style = [HiddenLine, Mesh]
]
);
·
·
·
·
·
·
·
·
·
·
·
·
·
·
torus_y:=proc(u,v)
begin
sin(v)
end_proc;
·
·
·
·
·
·
·
·
·
·
torus_x := proc(u,v)
begin
(5+cos(v))*cos(u)
end_proc;
·
·
·
·
·
·
·
·
·
·
·
torus_z := proc(u,v)
begin
(5+cos(v))*sin(u)
end_proc;
·
·
·
·
·
·
·
·
·
·
·
plot3d ( Axes = None,
[
Mode = Surface,
[ hold(torus_x(u,v))-4,
hold(torus_y(u,v)),
hold(torus_z(u,v)) ],
u= [0, 2*PI],
v= [0, 2*PI],
Grid = [30,30],
Style = [ColorPatches, AndMesh]
],
[
Mode = Surface,
[ hold(torus_x(u,v))+3,
hold(torus_z(u,v)),
hold(torus_y(u,v)) ],
u= [0, 2*PI],
v= [0, 2*PI],
Grid = [30,30],
Style = [ColorPatches, AndMesh]
],
[
Mode = Surface,
[ hold(torus_x(u,v))+10,
hold(torus_y(u,v)),
hold(torus_z(u,v)) ],
u= [0, 2*PI],
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
v= [0, 2*PI],
Grid = [30,30],
Style = [ColorPatches, AndMesh]
],
[
Mode = Surface,
[ hold(torus_x(u,v))+17,
hold(torus_z(u,v)),
hold(torus_y(u,v)) ],
u= [0, 2*PI],
v= [0, 2*PI],
Grid = [30,30],
Style = [ColorPatches, AndMesh]
]
);
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
Animationsgrafik entfällt, da MuPAD dies nicht unterstützt.
5.5. Spezielle Anwendungen
5.1. Lineare Gleichungssysteme
(a) Eindeutig lösbar
solve (
{
x+3*y-z = 4,
-2*x+y+3*z = 9,
4*x+2*y+z = 11
},
{x, y, z}
);
·
·
·
·
·
·
·
·
·
·
·
·
·
plot3d (Axes = None,
[Mode = Surface,
[x,y,x + 3*y - 4],x= [0,3],y= [0,3],Grid = [10,10],
Style = [ColorPatches, AndMesh]],
[Mode = Surface,
[x,y,2/3*x - 1/3*y + 3],x= [0,3],y= [0,3],Grid = [10,10],
Style = [ColorPatches, AndMesh]],
[Mode = Surface,
[x,y,-4*x-2*y+11],x=[0,3],y= [0,3],Grid = [10,10],
Style = [ColorPatches, AndMesh]]
);
·
·
·
·
·
·
·
·
·
·
·
·
·
(b) Unendlich viele Lösungen
solve
( {
x + 2*y - z = 4,
2*x + 5*y + 2*z = 9,
x + 4*y + 7*z = 6
},
{x, y, z}
);
·
·
·
·
·
·
·
·
·
·
·
·
plot3d (Axes = None,
[Mode = Surface,
[x,y,x + 2*y - 4],x= [0,3],y= [0,3],Grid = [10,10],
Style = [ColorPatches, AndMesh]],
[Mode = Surface,
[x,y,-x- 5/2*y+9/2],x= [0,3],y= [0,3],Grid = [10,10],
Style = [ColorPatches, AndMesh]],
[Mode = Surface,
[x,y,-1/7*x - 4/7*y + 6/7],x= [0,3],y= [0, 3],Grid = [10,10],
Style = [ColorPatches, AndMesh]]
);
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
(c) Keine Lösung
solve(
{
- 2*y + z = -5 ,
2*x + y - z = -2,
4*x - z = -4
},
{x, y, z} );
·
·
·
·
·
·
·
·
·
·
·
plot3d (Axes = None,
[Mode = Surface,
[x,y,2*y - 5],x= [-6,0],y= [-3,0],Grid = [20,20],
Style = [ColorPatches, AndMesh]],
[Mode = Surface,
[x,y,2*x + y + 2],x= [-6,0],y= [-3,0],Grid = [20,20],
Style = [ColorPatches, AndMesh]],
[Mode = Surface,
[x,y,4*x + 4],x= [-6,0],y= [-3,0],Grid = [20,20],
Style = [ColorPatches, AndMesh]]
);
·
·
·
·
·
·
plot3d (Axes = None,
[Mode = Surface,
[x,y,x],x= [-6,6],y= [-3,0],Grid = [20,20],
·
Style = [ColorPatches, AndMesh]],
[Mode = Surface,
[x,y,-x],x= [-6,6],y= [-3,0],Grid = [20,20],
Style = [ColorPatches, AndMesh]],
[Mode = Surface,
[x,y,4],x= [-6,6],y= [-3,0],Grid = [20,20],
Style = [ColorPatches, AndMesh]]
);
·
·
·
·
·
plot3d (Axes = None,
[Mode = Surface,
[x,y,0],x= [0,6],y= [0,6],Grid = [20,20],
Style = [ColorPatches, AndMesh]],
[Mode = Surface,
[x,y,1],x= [0,6],y= [0,6],Grid = [20,20],
Style = [ColorPatches, AndMesh]],
[Mode = Surface,
[x,y,2],x= [0,6],y= [0,6],Grid = [20,20],
Style = [ColorPatches, AndMesh]]
);
·
·
·
·
·
·
plot3d (Axes = None,
[Mode = Surface,
[x,y,0],x= [0,6],y= [-1,2],Grid = [20,20],
Style = [ColorPatches, AndMesh]],
[Mode = Surface,
[x,y,1],x= [0,6],y= [-1,2],Grid = [20,20],
Style = [ColorPatches, AndMesh]],
[Mode = Surface,
[x,y,y],x= [0,6],y= [-1,2],Grid = [20,20],
Style = [ColorPatches, AndMesh]]
);
·
·
·
·
·
·
5.2. Kurvendiskussion von Funktionenscharen (Polynom 2. Grades)
(a) Definition
f:=NIL;
·
·
·
·
·
·
·
f := proc(x)
begin
b:=(a2*x^2 + a1*x + a0)
end_proc;
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
Berechnung von Funktionswerten:
f(3);
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
Die Parameter a0, a1, a2 können global mit Werten belegt werden:
a0:=1;a1:=0.5;a2:=0.3;
·
·
·
·
·
·
f(x);
·
·
·
·
·
·
f(3);
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
Oder (nach Löschen der Wertzuweisung):
a0:=NIL;a1:=NIL;a2:=NIL;
·
·
·
·
·
·
a0;a1;a2;
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
kann man die Parameter a0, a1, a2 lokal mit Werten belegen:
f:=NIL;
·
·
·
·
·
·
f := proc(x)
begin
a0:=1;
a1:=0.5;
a2:=0.3;
b:=(a2*x^2 + a1*x + a0)
end_proc;
·
·
·
·
·
·
a0;a1;a2;
·
·
·
·
·
·
f(3);
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
(b) Ableitung
Es sind Ableitungen mit Parametern in der Funktion möglich:
a0:=NIL;a1:=NIL;a2:=NIL;f:=NIL;
·
·
·
·
·
·
·
·
·
·
·
f := proc(x)
begin
b:=(a2*x^2 + a1*x + a0)
end_proc;
·
·
·
·
·
·
diff(f(x),x);
·
·
·
·
·
·
diff(f(x),x,x);
·
·
·
·
·
·
a0:=1;a1:=0.5;a2:=0.3;
·
·
diff(f(x),x);
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
(c) Graphische Darstellung
Die einfachste Form beinhaltet nur die Funktion und den darzustellenden x-Bereich, allerdings
brauchen wir nun natürlich konkrete Werte für die Parameter a0, a1, a2 (hier etwa permanent
(also global) zugewiesen). Die Parameter a0, a1 und a2 sind aus dem vorangegangenen
Abschnitt bereits mit 1, 0.5 und 0.3 belegt.
plot2d ( Axes = None, Ticks = 1,
TitlePosition = Below,
Scaling=UnConstrained,
[ Mode = Curve,
[ x, f(x) ], x = [-3,3], Grid = [50] ] );
·
·
·
·
·
·
·
·
·
·
·
·
g2:=diff(f(x),x);
·
·
·
·
·
·
·
·
·
·
g3:=diff(f(x),x,x);
·
·
·
·
·
·
·
·
·
·
plot2d ( Axes = None, Ticks = 1,
TitlePosition = Below,
Scaling=UnConstrained,
[ Mode = Curve,
[x, f(x)], x =[-1.5,5], Grid = [50] ],
[ Mode = Curve,
[x, g2], x = [-1.5,5], Grid = [50] ],
[ Mode = Curve,
[x, g3], x = [-1.5,5], Grid = [50] ] );
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
5.3. Funktionenscharen bei Parameteränderung (Polynom 2. Grades)
Ein Polynom 2. Grades
a0:=NIL;a1:=NIL;a2:=NIL;f:=NIL;
·
·
·
·
·
·
f := proc(x)
begin
b:=(a2*x^2 + a1*x + a0)
end_proc:
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
a0:=1; a1:=0.5;
·
·
·
·
·
·
·
·
·
·
Liste := table ((c+1)=c*x^2 +a1*x +a0 $ c=0..20):
·
·
·
·
·
·
·
·
·
·
Liste2:=[]:
for i from 1 to 21 step 1 do
Liste2:=Liste2.[ [Mode= Curve, [x,Liste[i]], x=[-5,5], Grid=[100]] ]
end_for:
·
·
·
·
·
·
·
·
·
·
plot2d ( Liste2[1], Liste2[2], Liste2[3], Liste2[4], Liste2[5], Liste2[5], Liste2[6], Liste2[7], Liste2[8],
Liste2[9], Liste2[10], Liste2[11], Liste2[12], Liste2[13], Liste2[13], Liste2[14], Liste2[15], Liste2[16],
Liste2[17], Liste2[18], Liste2[19], Liste2[20], Liste2[21] );
·
·
·
·
·
·
·
·
·
·
·
·
·
·
Befehle analog zu Kapitel 4, Teil (a).
Viel Spass mit MuPAD !
Marcel Wiehle
Thomas Ullrich
Michael Wenzel
TU Bergakademie Freiberg
April 2003