dh-Materialien
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  nach oben
2-dimensionale euklidische Geometrie

   with(geometry):

circle (K, [P, Q, R]);
definiert einen Kreis K durch drei Punkte P, Q und R.
point(P, [1,2]):
point(Q, [2,3]):
point(R, [3,5]):

circle(K, [P,Q,R]);
K
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,[P, Q]);
g
line (g, gl, [x, y]);
definiert eine Gerade g durch eine Gleichung.
line(g, y = 3*x + 1, [x,y]);
g
point (P, [x, y]);
point (P, x, y);
definiert einen Punkt P durch seine ebenen Koordinaten.
point(P, [-7,3]);
P
square (Q, [R, S, T, U]);
definiert ein Quadrat Q durch vier Punkte.
point(R, [0,0]):
point(S, [0,1]):
point(T, [1,1]):
point(U, [1,0]):
square(Q, [R,S,T,U]);

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 eines Objekts.
Equation(K, [x,y]);
-1.29+x^2+y^2+4*x = 0

area (Obj);
berechnet die Fläche einer ebenen Figur.
area(K);
5.29*Pi
center (K);
ermittelt den Mittelpunkt eines Kreises.
center(K);
M
centroid (C, points);
ermittelt den Schwerpunkt C eines Vielecks.
point(P,0,0):
point(Q,1,3):
point(R,-2,7):
point(S,-4,2):
centroid(C, [P,Q,R,S]):
coordinates(C);

distance (Obj1, Obj2);
berechnet den Abstand zweier geometrischer Objekte Obj1 und Obj2.
point(P, [-7,3]):
point(M, [-2,0]):
distance(P, M);

sqrt(34)
line(g, y = 3*x + 1, [x,y]):
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, Obj1, Obj2);
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.
circle(K, [[-2,0], 2.3], [x,y]):
radius(K);

 2.3
slope (g);
berechnet die Steigung einer Geraden.
line(g, y = 3*x + 1, [x,y]):
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.
line(g, y = 3*x + 1, [x,y]):
line(h, y = -1/3*x + 4, [x,y]):
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 (Obj1, 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.
point(P, [-7,3]):
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  nach oben
3-dimensionale euklidische Geometrie

   with(geom3d):

line (g, [P, Q]);
definiert eine Gerade g durch zwei Punkte P und Q.
line(g,[P, Q]);
g
line (g, [P, v]);
definiert eine Gerade g durch einen Punkt und einen Richtungsvektor.
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, 2*x+3*y+z = 1, [x,y,z]);
E
plane (E, [A, B, C]);
definiert eine Ebene E durch drei Punkte.
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 eines Objekts.
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.
point(A, [-1,3,2]):
line(g, [point(P, [1,3,1]), [5,2,2]]):
evalf(distance(g, A));

1.749458790
FindAngle (Obj1, Obj2);
berechnet den Winkel zwischen Obj1 und Obj2 im Bogenmaß.
line(g, [point(P, [1,3,1]), [5,2,2]]);
plane(E, 2*x+3*y+z = 1, [x,y,z]);
evalf(FindAngle(g, E), 5);

0.99256
intersection (s, Obj1, Obj2, Obj3);
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.
point(A, [-1,3,2]):
point(B, [5,-7,3]):
midpoint(M, A, B):
coordinates(M);

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.
point(A, [-1,3,2]):
point(B, [5,-7,3]):
point(C, [1,6,4]) :
AreCollinear(A, B, C);

 false
AreCoplanar (A, B, C, D);
testet auf Koplanarität von vier Punkten.
point(M, [-2,7,5]):
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 (Obj1, Obj2);
prüft, ob zwei Objekte Obj1 und Obj2 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  nach oben
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);

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  nach oben
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, 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]);
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  nach oben
Elementare Grafikobjekte

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

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  nach oben
Spezielle Prozeduren für den Mathematikunterricht;
inzwischen ersetzt durch das Package Student.

   with(plots):
   with(student):

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äherungsweise Bestimmung von Pi
Das Simpsonverfahren


Student  nach oben
Spezielle Prozeduren für den Mathematikunterricht

   with(Student[Precalculus]):

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