dh-Materialien
Einführung in Maple    
Übersicht
 

Packages
(ausgewählte Prozeduren)


combinat
Kombinatorische Funktionen

  with (combinat):

binomial (n, k);
berechnet den Binomialkoeffizienten
(n über k).
binomial(7, 3);
35
choose (n, k);
berechnet alle Kombinationen von k Elementen aus einer n-elementigen Menge.
choose([a, b, c]);

choose(3, 2);
[[1, 2], [1, 3], [2, 3]
composition (n, k);
berechnet alle Listen mit k Zahlen, deren Summe jeweils n ergeben.
composition(4, 3);
{ [2, 1, 1], [1, 2, 1], [1, 1, 2] }
numbcomb (n, k);
berechnet die Anzahl aller k-elementigen Kombinationen aus einer n-elementigen Menge.
numbcomb(10, 2);
45
numbpart (n);
berechnet die Anzahl aller Partitionen einer integer-Zahl n.
numbpart(4);
5
numbperm (n, k);
berechnet die Anzahl aller k-elementigen Permutationen aus einer n-elementigen Menge.
numbperm(10, 2);
90
partition (z);
berechnet alle Partitionen einer integer-Zahl z.
partition(4);
permute (n, k);
berechnet alle k-elementigen Permutationen aus einer n-elementigen Menge.
permute(3, 2);

permute([a, b, c], 2);
randcomb (n, k);
berechnet eine Zufallsfolge von k Zahlen zwischen 0 und n.
randcomb(49, 7);
randpart (z);
berechnet eine zufällig gewählte Partition einer integer-Zahl z.
randpart(24);

Eigenschaften einer Binomialverteilung


geometry
2-dimensionale euklidische Geometrie

  with (geometry):

circle (K, [M, r]);
definiert einen Kreis K durch seinen Mittelpunkt M und seinen Radius r.
point(M, [-2, 0]):
circle(K, [M, 2.3], [x, y]);
K
line (g, [P, Q]);
definiert eine Gerade g durch zwei Punkte P und Q.
line (g, gl, [x, y]);
definiert eine Gerade g durch eine Gleichung.
line(g,[P, Q]);
g

line(g, y = 3*x + 1, [x, y]);

g
point (P, [x, y]);
definiert einen Punkt P durch seine ebenen Koordinaten.
point(P, [-7, 3]):
P
square (Q, [A, B, C, D]);
definiert ein Quadrat Q durch vier Punkte.
square(Q, [A, B, C, D]);
Q
triangle (T, [A, B, C]);
definiert ein Dreieck T durch drei Punkte.
triangle(T, [A, B, C]);
T
triangle (T, [a, b, c]);
definiert ein Dreieck T durch drei Seitenlängen.
triangle(T, [5, 12, 13]);
T
 
coordinates (M);
liefert die Koordinatenwerte eines Punktes M.
coordinates(M);
[-2, 0]
detail (Obj);
informiert über das geometrische Objekt Obj.
detail(K);
name of the object: K ...
Equation (Obj);
liefert die Koordinatengleichung von Obj.
Equation(K, [x,y]);
-1.29+x^2+y^2+4*x = 0
 
area (Obj);
berechnet die Fläche von bestimmten ebenen Figuren.
area(K);
5.29*Pi
center (K);
berechnet den Mittelpunkt eines Kreises.
center(K);
M
centroid (S, points);
berechnet den Schwerpunkt S eines Vielecks.
point(C,-2,7): point(D,-4,2):
centroid(S, [A, B, C, D]):
coordinates(S);

distance (Obj1, Obj2);
berechnet den Abstand zweier geometrischer Objekte Obj1 und Obj2.
distance(P, M);
sqrt(34)
distance(P, g);
23*sqrt(10)/10
FindAngle (Obj1, Obj2);
berechnet den Winkel zwischen Obj1 und Obj2 im Bogenmaß.
line(h, y = -1/3*x + 4, [x, y]):
evalf(FindAngle(g, h), 4);

1.571
intersection (s, O1,O2);
berechnet den Schnitt von zwei Objekten.

 
intersection(S, g, h):
detail(S);

 name of the object: S ...
midpoint (M, A, B);
berechnet den Mittelpunkt M der Strecke AB.
 
point(A,0,0): point(B,1,3):
midpoint(M, A, B):
coordinates(M);

[1/2, 3/2]
radius (K);
berechnet den Radius eines Kreises.
radius(K);
 2.3
slope (g);
berechnet die Steigung einer Geraden.
slope(g);
 3
 
incircle (k, T);
liefert den Inkreis k eines Dreiecks T.
triangle(T, [A, B, C]):
incircle(Inkreis, T):
radius(Inkreis);
Radius des Inkreises
circumcircle (k, T);
liefert den Umkreis k eines Dreiecks T.
circumcircle(Umkreis, T):
coordinates(center (Umkreis));
[1, 57/14]
 
AreParallel (Obj1, Obj2);
prüft, ob zwei Objekte Obj1 und Obj2 parallel zueinander sind oder nicht.
AreParallel(g, h);
 false
ArePerpendicular (O1, O2);
prüft, ob zwei Objekte O1 und O2 senkrecht aufeinander stehen oder nicht.
ArePerpendicular(g, h);
 true
AreSimilar (Obj2, Obj2);
prüft, ob zwei Objekte Obj1 und Obj2 ähnlich  zueinander sind oder nicht.
triangle(T1, [8, 15, 17]):
triangle(T2, [16, 30, 34]):
AreSimilar(T1, T2);

 true
IsOnLine (P, g);
prüft, ob ein Punkt P oder eine Liste von Punkten auf einer Geraden g liegt.
IsOnLine(P, g);
 false
IsOnCircle (A, K);
prüft, ob ein Punkt A oder eine Liste von Punkten auf einem Kreis K liegt.
IsOnCircle(M, K);
 false
IsRightTriangle (T);
prüft, ob ein Dreieck T rechtwinklig ist.
IsRightTriangle(T1);
 true

Das Sierpinski-Dreieck
Die Eulergerade


geom3d
3-dimensionale euklidische Geometrie

  with (geom3d):

line (g, [P, Q]);
definiert eine Gerade g durch zwei Punkte P und Q.
line (g, [P, v]);
definiert eine Gerade g durch einen Punkt und einen Richtungsvektor.
line(g,[P, Q]);
g

line(g,[point(P,[1,3,1]),[5,2,2]]);

g
point (P, [x, y, z]);
definiert einen Punkt P durch seine Koordinaten.
point(P, [-2, 3, -7]):
P
plane (E,Gleichung, [x,y,z]);
definiert eine Ebene E durch eine Koordinatengleichung.
plane (E, [A, B, C]);
definiert eine Ebene E durch drei Punkte.
plane(E, 2*x+3*y+z = 1, [x,y,z]);
E

point(A, [-1, 3, 2]):

point(B, [5, -7, 3]):
point(C, [1, 6, 4]) :
plane(E, [A, B, C]);
E
sphere (K, [M, r]);
definiert eine Kugel K durch ihren Mittelpunkt M und ihren Radius r.
point(M, [-2, 7, 5]):
sphere(K, [M, 2.3]);
K
triangle (T, [A, B, C]);
definiert ein Dreieck T durch drei Punkte.
triangle(T, [A, B, C]);
T
 
coordinates (P);
liefert die Koordinatenwerte eines Punktes P.
coordinates(A);
[-1,3,2]
detail (Obj);
informiert über das geometrische Objekt Obj.
detail(E);
Equation (Obj);
liefert die Koordinatengleichung von Obj.
Equation(E, [x,y,z]);
 
area (Obj);
berechnet die Fläche eines Dreiecks oder einer Kugel.
area(T);
center (K);
berechnet den Mittelpunkt einer Kugel.
coordinates(center (K));
[-2,7,5]
distance (Obj1, Obj2);
berechnet den Abstand zweier geometrischer Objekte Obj1 und Obj2.
distance(g, A);
1.749458790
FindAngle (Obj1, Obj2);
berechnet den Winkel zwischen Obj1 und Obj2 im Bogenmaß.
evalf(FindAngle(g, E), 2);
-0.23
intersection (s, O1,O2,O3);
berechnet den Schnitt von zwei oder drei Objekten.

 
intersection(S, g, E):
detail(S);

midpoint (M, A, B);
berechnet den Mittelpunkt M der Strecke AB.
 
midpoint(M, A, B);
radius (K);
berechnet den Radius einer Kugel.
radius(K);
 2.3
volume (K);
berechnet das Volumen einer Kugel (und auch anderer Körper).
volume(K);
 
AreCollinear(A, B,C);
testet auf Kollinearität dreier Punkte.
AreCollinear(A, B, C);
 false
AreCoplanar (A, B, C, D);
testet auf Koplanarität von vier Punkten.
AreCoplanar(A, B, C, M);
 false
AreParallel (Obj1, Obj2);
prüft, ob zwei Objekte Obj1 und Obj2 parallel zueinander sind oder nicht.
AreParallel(g, E);
 false
ArePerpendicular (O1, O2);
prüft, ob zwei Objekte O1 und O2 senkrecht aufeinander stehen oder nicht.
line(n, [A, [-23, -10, 38]]):
ArePerpendicular(E, n);

 true
IsOnObject (A, Obj);
prüft, ob ein Punkt A oder eine Liste von Punkten auf Obj liegt.
IsOnObject([A, B, C], E);
 true

Punkte im Raum
Relative Lage von Geraden
Punkte, Geraden und Ebenen
Der Schnitt von Ebenen
Kugeln, Ebenen und Geraden


LinearAlgebra
Lineare Algebra

  with (LinearAlgebra):

<x| y| z>;
definiert einen dreidimensionalen Zeilenvektor.
v:= <2| 4| -1>;
w:= <3| -2| 1/2>;

<x, y, z>;
definiert einen dreidimensionalen Spaltenvektor.
u:= <3, 1, -2>;
Matrix (m, n, Liste);
definiert eine mxn - Matrix.
koeff:=[[a,b,c],[d,e,f],[g,h,i]]:
M:= Matrix(3, 3, koeff);

 
CrossProduct (v, w);
berechnet das Kreuzprodukt von v und w.
CrossProduct(v, w);
[0, -4, -16]
DeleteColumn (M, colums);
löscht Spalten der Matrix M.
DeleteColumn(M, 2..3);
<a, d, g>
DeleteRow (M, rows);
löscht Zeilen der Matrix M.
DeleteRow(M, [1,2]);
<g| h| i>
Determinant (M);
berechnet die Determinante der Matrix M.
Determinant(M);
DotProduct (v, w);
berechnet das Skalarprodukt von v und w.
DotProduct(v, w);
MatrixAdd (M1, M2);
addiert zwei Matrizen.
MatrixAdd(M, M);
M + M
MatrixInverse (M);
berechnet die inverse Matrix von M.
MatrixInverse(<<a,b>|<c,d>>);
Multiply (M, N);
multipliziert zwei Matrizen miteinander.
Multiply(M, u);
M * u
Transpose (M);
transponiert die Matrix M.
Transpose(M);
VectorAdd (v, w);
addiert zwei Vektoren mit gleicher Orientierung.
VectorAdd(v, w);
[5, 2, -1/2]
VectorAngle (v, w);
berechnet den Winkel zwischen v und w im Bogenmaß.
evalf(VectorAngle (v, w), 2);
1.7
VectorNorm (v, 2);
berechnet die 2-Norm (den "Betrag") eines Vektors.
v:= <2| 4| -1>:
VectorNorm(v, 2);

Rechnen mit Vektoren
Rechnen mit Matrizen


plots
Grafik

with (plots):

animate (f(t,x), x = a..b,
    t = c..d,
Optionen);
definiert eine Animationsfolge von Schaubildern einer Funktionenschar. Hierbei ist t der Scharparameter; der frames-Wert gibt die Anzahl der zu zeichnenden Schaubilder an.
f(t,x):= x + t*sin(x):
animate(f(t,x), x= -8..8, t= 0..4,
  view = -10..10, frames = 50);

 Animation
arrow (vA, vEOptionen);
arrow
(v, Optionen);
definieren jeweils einen Vektor in einem dreidimensionalen Koordinatensystem.

arrow([4,3,5], shape = arrow,
  color = red,
  thickness = 2,
  orientation = [-39, 63],
  axes = normal);
coordplot (cartesian,
    view = [a..b, c..d]
,
    Optionen);
zeichnet ein kartesisches Koordinatensystem.
KoordSys:= coordplot(cartesian,
  view = [-5..5, -5..5],
  grid = [3, 3],
  color = grey,
  linestyle = [SOLID,SOLID]):
display(KoordSys);
display ([Plot1, Plot2, ...],
   
Optionen);
zeichnet Plot1, Plot2, usw. in ein gemeinsames Diagramm.
Plot1:= plot(sin(x), x = -Pi..Pi,
  color = red):
Plot2:= plot(cos(x), x = -Pi..Pi,
  color = blue):
display([Plot1, Plot2]);
sin und cos
implicitplot (Gl, x = a..b,
   
y = c..d,
    Optionen
);
zeichnet gemäß der Gleichung Gl ein zweidimensionales Diagramm.
implicitplot (x^4 + y^2 = 1,
  x = -1..1,
  y = -1..1,
  numpoints = 6000);

pointplot ([P1, P2, ...],
 
 Optionen);
zeichnet die Punkte P1, P2, usw. in ein zweidimensionales Diagramm.
Pkte:= {seq([i,sqrt(i)],i= 1..5)}:
pointplot(Pkte,view=[0..5,0..2]);

polygonplot ([F1, F2, ...],
  
Optionen);
zeichnet ein Polygon, bzw. mehrere Polygone.
Fig:= [[1,1],[5,1],[5,4]];
polygonplot(Fig, view=[0..5,0..5]);
textplot ([x, y, Txt],
   Optionen);
schreibt den Text Txt an der Position [x,y] in ein Koordinatensystem.
textplot([1,1,`Mitte`],
  view = [0..2, 0..2],
  align = BELOW);
tubeplot ([x(t), y(t), z(t),
   t = a..b, radius = r(t)],
  
Optionen);
zeichnet eine dreidimensionale Schlauchgrafik.
tubeplot({[0,0,t, t = -1..0,
  radius = t^2 + 1],
  [0,0,t, t = 0..1,
  radius = 1 - t^2]},
  view = [-2..2,-2..2,-1..1],
  orientation = [112, 107],
  numpoints = 10,
  tubepoints = 30);
 tubeplot

Funktionen und Funktionsterme
Konvergenz einer Folge
Darstellungen einer Funktionenschar
Funktionen von zwei Veränderlichen
Die Addition von Vektoren
Flächen im Raum

plottools
Elementare Grafikobjekte

with (plots): with (plottools):
KoordSys ist ein mit plots[coordplot] definiertes Koordinatensystem (siehe oben).

arc (M, r, a..b, Optionen);
definiert einen Kreisbogen mit dem Mittelpunkt M und dem Radius r.
a ist der Anfangs-, b ist der Endwinkel im Bogenmaß.
bg:= arc([1, 2], 1.5, 0..3/4*Pi):
display({KoordSys, bg});

circle (M, r, Optionen);
definiert einen Kreis mit dem Mittelpunkt M und dem Radius r.
kr:= circle([0.5, 1], 3):
display({KoordSys, kr});

disk (M, r, color = farbe);
definiert eine farbige Kreisfläche mit dem Mittelpunkt M und dem Radius r.
kf1:= disk([-0.5,2],.3,color=blue):
kf2:= disk([1.9,0.9],.3,color=blue):
display({KoordSys, kf1, kf2});

ellipse (M, rx, ry, Optionen);
definiert eine Ellipse mit dem Mittelpunkt M;
rx und ry sind die Längen der Halbachsen.
el:= ellipse([0, 0.4], 0.6, 1.5):
el:= rotate(el, 2*Pi - 0.43):
display({KoordSys, el});

line ([xa, ya], [xb, yb],
  
Optionen);
definiert eine Strecke mit dem Anfangspunkt (xa|ya) und dem Endpunkt (xb|yb).
li:= line([-1.2, -1], [0, -1.55],
  thickness = 3):
display({KoordSys, li});

rectangle ([x1, y1], [x2, y2],
  
Optionen);
definiert ein Rechteck mit dem linken oberen Eckpunkt (x1|y1) und dem rechten unteren Eckpunkt (x2|y2).
rt:= rectangle([-1,4.7], [2,4],
  color = gray):
display({KoordSys, rt});

  display({KoordSys,
         bg,kr,kf1,kf2,el,li,rt});

cone (M, r, h, Optionen);
definiert einen Kegel mit dem Grundkreismittelpunkt M, dem Grundkreisradius r und der Höhe h.
M:= [0,0,0]:
cn:= cone(M, 2, 4):
display(cn, orientation = -44,74);

cuboid (P, Q , Optionen);
definiert einen Würfel. P und Q sind die Endpunkte einer Raumdiagonalen des Würfels.
wf:= cuboid([0,0,0], [1,1,1]):
display(wf, style = patch);

cylinder (M, r, h, Optionen);
definiert einen Zylinder. M ist der Grundkreismittelpunkt, r der Grundkreisradius und h die Höhe des Zylinders.
M:= [0,0,0]:
zy:= cylinder (M, 2, 3):
display(zy,
  style = patch,
  scaling = CONSTRAINED,
  orientation = [-170,65]);

dodecahedron (M,
  
Optionen);
definiert einen Dodekaeder mit dem Mittelpunkt M.
dh:= dodecahedron([0, 0, 0]):
display(dh, scaling = CONSTRAINED);

icosahedron (M, Optionen);
definiert einen Ikosaeder mit dem Mittelpunkt M.
ic:= icosahedron([0, 0, 0]):
display(ic, scaling=CONSTRAINED);
octahedron (M, Optionen);
definiert einen Oktaeder mit dem Mittelpunkt M.
oc:= octahedron([0, 0, 0]):
display(oc, scaling=CONSTRAINED
  orientation = [18,-106]);

sphere (M, r, Optionen);
definiert eine Kugel mit dem Mittelpunkt M und dem Radius r.
kg:= sphere([0, 0, 0], 2):
  display(kg, scaling=CONSTRAINED);

tetrahedron (M, Optionen);
definiert einen Tetraeder mit dem Mittelpunkt M.
tr:= tetrahedron([0, 0, 0]):
display(tr, scaling=CONSTRAINED);


student
Spezielle Prozeduren für den Mathematikunterricht; inzwischen ersetzt durch das Package Student.

with (plots):
  with (student):

pol:= A*x^2 + B*x + C:
completesquare (pol);
rechnet das gegebene Polynom um in einen Ausdruck der Form a(x+b)2+ c.
pol:= 3*x^2 + 2*x + 4:
completesquare(pol);

Diff (f(x), x);
gibt den entsprechenden Ausdruck in mathematisch üblicher Schreibweise aus.
Diff(1/x, x);

value(%);
Limit (f(x), x = x0);
gibt den entsprechenden Ausdruck in mathematisch üblicher Schreibweise aus.
Limit(sin(x)/x, x = 0);

value(%);
 1
Limit (cos(x)/x, x = 0);
 undefined
showtangent (f(x), x = x0,
  
Optionen);
zeichnet das Schaubild von f und die Tangente an das Schaubild an der Stelle x0.
showtangent(x^2+1, x = 1, x = 0..2,
  color = [black, red],
  thickness = 2);

simpson (f(x), x = a..b, n);
berechnet das Integral von f(x) in den Grenzen a und b nach der Simpsonregel. n ist die Anzahl der benutzten Rechtecke.
simpson(sqrt(x)*sin(x),x= 0..3, 10):
evalf(%, 4);

2.418
trapezoid (f(x), x = a..b);
berechnet das Integral von f(x) in den Grenzen a und b nach der Trapezregel.
trapezoid(sqrt(x)*sin(x), x= 0..3);

evalf (%, 4);
2.326
 
leftbox (f(x), x = a..b, n,
  
Optionen);
definiert eine Folge von n Rechtecken, deren linke obere Eckpunkte auf dem Schaubild einer Funktion f liegen.
LB:= leftbox(x^2, x = 0..1, 6):
Schaubild:= plot(x^2, x = 0..1):
display(Schaubild, LB);

middlebox (f(x), x = a..b, n, 
   Optionen);
definiert eine Folge von n Rechtecken, bei denen die oberen Endpunkte ihrer Mittellinien auf dem Schaubild einer Funktion f liegen.
MB:= middlebox(x^2, x = 0..1, 6):
Schaubild:= plot(x^2, x = 0..1):
display(Schaubild, MB);

rightbox (f(x), x = a..b, n,
  
Optionen);
definiert eine Folge von n Rechtecken, deren rechte obere Eckpunkte auf dem Schaubild einer Funktion f liegen.
RB:= rightbox(x^2, x = 0..1, 6):
Schaubild:= plot(x^2, x = 0..1):
display(Schaubild, RB);

leftsum (f(x), x = a..b, n);
liefert die Summe der Flächeninhalte aller durch leftbox (f(x), x = a..b, n) gegebenen Rechtecke.
evalf(leftsum(x^2, x= 0..1, 6),3);
0.256
middlesum (f(x), x=a..b, n);
liefert die Summe der Flächeninhalte aller durch middlebox (f(x), x = a..b, n) gegebenen Rechtecke.
evalf(middlesum(x^2,x= 0..1,6),3);
0.332
rightsum (f(x), x = a..b, n);
liefert die Summe der Flächeninhalte aller durch rightbox (f(x), x = a..b, n) gegebenen Rechtecke.
evalf(rightsum(x^2,x= 0..1, 6),3);
0.423

Näherungsverfahren zur Bestimmung von Pi
Numerische Integration: das Simpsonverfahren



Student

  with (Student[Precalculus]):

pol:= A*x^2 + B*x + C:
CompleteSquare (pol);
rechnet das gegebene Polynom um in einen Ausdruck der Form a(x+b)2+ c.
pol:= 3*x^2 + 2*x + 4:
CompleteSquare(pol);

CenterOfMass (pkte);
berechnet den Schwerpunkt
eines Punktensembles.
pkte:= [-2,2],[1,5],[3,3],[2,-3]:
CenterOfMass(pkte);

[1, 7/4]
 
Distance ([a,b], [c,d]);
berechnet den Abstand
zwischen den Punkten
(a|b) und (c|d).
Distance([1,2],[5,6]);
4*sqrt(2)
 
Line ([a,b], [c,d]); oder
Line ([a,b], m);

liefert die zugehörige
Geradengleichung, den
Steigungsfaktor, den y- und
den x-Achsenabschnitt.
Line([1,2], [3,5]);
Line([1,2], 3/2);
y = 3/2*x + 1/2, 3/2, 1/2, -1/3
 
Midpoint ([a,b], [c,d]);
berechnet den Mittelpunkt
zwischen den Punkten
(a|b) und (c|d).
Midpoint([1,2],[5,6]);
[3,4]
 
Slope ([a,b], [c,d]);
berechnet die Steigung der
Geraden durch die Punkte
(a|b) und (c|d).
Slope([1,2],[3,12]);
5

  with (Student[Calculus1]):

ApproximateInt (f(x), 
    x = a..b, 
    method =
Verfahren,
   
Optionen);
berechnet das Integral von f(x) in den Grenzen a und b nach dem angegebenen Verfahren (lower, upper, trapezoid, simpson, boole und andere).
Mögliche Werte für output:
value, sum, plot,  animation.

 

f(x):= sqrt(x)*sin(x):
ApproximateInt(f(x),
  x= 0..3,
  method = simpson):
evalf(%, 4);

2.417

ApproximateInt(f(x),
  x= 0..3,
  method = trapezoid,
  output = sum,
  partition = 4):
simplify(%);
evalf(%, 4);
term

2.325
 

DerivativePlot (f(x), 
   x = a..b,
Optionen);
zeichnet das Schaubild von f und f ’.
 
DerivativePlot(sin(x), x= 0..Pi,
  title = "");

f(x) and 1st derivative
FunctionAverage (f(x), 
   x = a..b,
Optionen);
liefert den Mittelwert einer Funktion auf dem Intervall [a,b].
 
FunctionAverage(sin(x), x = 0..Pi);

2/Pi
  

 

FunctionChart (f(x), 
   x = a..b,
Optionen);
zeichnet das Schaubild von f unter Berücksichtigung besonderer Eigenschaften von f.
 
FunctionChart(x^3-5*x, x= -3..3,
  title = "",
  slope = color(blue,red),
  concavity = [],
  pointoptions = [symbolsize=15,
                  color=black]);

FunctionChart
  

 

RiemannSum (f(x), 
   x = a..b,
Optionen);
berechnet Riemannsummen bzw. zeichnet die zugehörigen Diagramme.
 
RiemannSum(exp(x)-x^2, x=-2..2,
  method = midpoint,
  output = plot,
  partition = 8,
  title = "",
  showarea = false);

RiemannSum
  

 

Numerische Berechnung eines Integrals


 Home   Back   Top