Packages
(ausgewählte Prozeduren)

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

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);
Equation (Obj); liefert die Koordinatengleichung von Obj.	Equation (K, [x,y]);
area (Obj); berechnet die Fläche von bestimmten ebenen Figuren.	area (K);
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); distance (P, g);
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);
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);
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);
circumcircle (k, T); liefert den Umkreis k eines Dreiecks T.	circumcircle (Umkreis, T): coordinates (center (Umkreis));
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

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

vector ([x, y, z]); definiert einen dreidimensionalen Vektor.	v:= vector ([2, 4, -1]); w:= vector ([3, -2, 1/2]);
Vector ([x, y, z]); definiert einen dreidimensionalen Spaltenvektor.	u:= Vector ([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);
angle (v, w); berechnet den Winkel zwischen v und w im Bogenmaß.	evalf (angle (v, w), 2); 1.7
crossprod (v, w); berechnet das Kreuzprodukt von v und w.	crossprod (v, w); [0, -4, -16]
det (M); berechnet die Determinante der Matrix M.	det (M);
dotprod (v, w); berechnet das Skalarprodukt von v und w.	dotprod (v, w);
inverse (M); berechnet die inverse Matrix von M.	inverse (matrix ([[a,b],[c,d]]));
matadd (M, N); addiert zwei Matrizen oder Vektoren.	matadd (u, v); [5, 5, -3]
multiply (M, N); multipliziert zwei Matrizen miteinander.	multiply (M, u);
norm (M, 2); berechnet die 2-Norm (den "Betrag") einer Matrix oder eines Vektors.	norm (v, 2);
transpose (M); transponiert die Matrix M.	transpose (M);

Rechnen mit Vektoren
Rechnen mit Matrizen

<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);
DeleteRow (M, rows); löscht Zeilen der Matrix M.	DeleteRow (M, [1,2]);
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);
MatrixInverse (M); berechnet die inverse Matrix von M.	MatrixInverse (<<a,b>|<c,d>>);
Multiply (M, N); multipliziert zwei Matrizen miteinander.	Multiply (M, u);
Transpose (M); transponiert die Matrix M.	Transpose (M);
VectorAdd (v, w); addiert zwei Vektoren mit gleicher Orientierung.	VectorAdd (v, w);
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

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);
arrow (vA, vE, Optionen); 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]);
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);

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

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

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

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);
Distance ([a,b], [c,d]); berechnet den Abstand zwischen den Punkten (a|b) und (c|d).	Distance ([1,2],[5,6]);
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);
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); 2.325
DerivativePlot (f(x),     x = a..b, Optionen); zeichnet das Schaubild von f und f '.	DerivativePlot (sin(x), x= 0..Pi,    title = "");
FunctionAverage (f(x),     x = a..b, Optionen); liefert den Mittelwert einer Funktion auf dem Intervall [a,b].	FunctionAverage (sin(x), x = 0..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]);
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);

Numerische Berechnung eines Integrals