_____________________________________________________________________________________
Inhalt....: Simulationen von Wurfbewegungen unter Berücksichtigung des Luftwiderstands
Kategorie.: Unterrichtsmaterial
Mathematik: Physik
MuPAD.....: 3.1.0
Datum.....: 2006-02-23
Autoren...: Günter vom Stein <gvomstein@gmx.net>
Funktionen: plot::Point2d, plot::Curve2d, YAxesTitle, YAxesTitleOrientation
Funktionen: plot::PointList2, plot::Function2d, ViewingBox, GridVisible,
Funktionen: VisibleFromTo, repeat, float, print, NoNL, Unquoted, expr2text
Freitext..: Selbstlernmaterial/Dialog mit Experiment im Bereich Mechanik/Dynamik
_____________________________________________________________________________________
Die Berücksichtigung des Luftwiderstands wurde in der Physik der Mechanik in der
Vergangenheit oft vernachlässigt, weil ein Zugang über Gleichungen mit schulischen
Mitteln in der Jgst. 11 nicht möglich ist. Die Simulation benutzt jedoch nur konstante
Kräfte und Geschwindigkeiten auf geraden Streckenabschnitten. Dabei wird keine
kontinuierliche Bahnkurve berechnet, sondern ein Polygonzug. Die Bahnkurve erhält
man näherungsweise als Menge von Punkten, und zwar den Ecken des Polygonzugs.
Bei Wahl immer kleinerer Zeiteinheiten unterscheidet sich die simulierte Bahn immer
weniger von der "wahren" Bahn. Die Güte der Näherung kann studiert werden, wenn
man den Fall "Luftwiderstand gleich Null" simuliert und die so gewonnene Bahn mit
der aus Gleichungen berechneten theoretischen Bahn vergleicht.
________________________________________________________________________________
Inhalte:
Teil I Allgemeiner (schräger) Wurf, Basiselement
Teil II Simulation des Wurfes einer Holzkugel bzw. einer aus Alufolie geformten Kugel
mit experimenteller Kontrolle
Teil III Kugelstoßen, Wurfweite in Abhängigkeit vom Abwurfwinkel
Kugelstoßen in Mexiko City (2240 m ü. NN)
Teil IV Freier Fall eines Papier-Kegels
Luftwiderstand proportional zum Quadrat der Geschwindigkeit
_____________________________________________________________________________________
Teil I Allgemeiner (schräger) Wurf, Basiselement
Die Simulation beruht auf einem bewussten, prinzipiellen Fehler: Man stellt sich die Flugbahn als einen Polygonzug
(= Folge von Streckenabschnitten) vor. Die Kugel fliegt jeweils für eine Zeiteinheit dt geradeaus und führt am Ende
dieses Geradenstücks eine ruckartige Richtungsänderung durch.
Die Richtungsänderung wird in jedem Schleifendurchgang einer entsprechenden MuPAD-Prozedur neu berechnet.
Falls man den Zeitabschnitt klein genug wählt, kann man von einer hinreichend guten Näherung an den tatsächlichen
Kurvenverlauf ausgehen.
In der Skizze geht man von einer Momentaufnahme mit der Momentangeschwindigkeit v aus. Man stellt sich die
Geschwindigkeit aufgespalten in die Komponenten vx und vy vor.
Die Bewegung der Kugel in Richtung von v hat die Luftreibungs-Bremskraft zur Folge:
Auch die Bremskraft denken wir uns in die Komponenten FLx und FLy zerlegt. Die beiden Parallelogramme (bzw.
Rechtecke) sind zueinander ähnlich. Daher gilt
Die Bremskraft FLx in Richtung der x-Achse hat nun eine Bremsbeschleunigung in x-Richtung entgegen vx zur Folge:
Die Geschwindigkeit in x-Richtung wird also im nächsten Zeitintervall kleiner, und zwar sinkt sie auf
Ganz analog folgt derselbe Term für die Änderung der Geschwindigkeit in y-Richtung, wobei hier noch der Effekt
er Erdbeschleunigung (stets nach unten, d.h. in negative Richtung) berücksichtigt werden muss:
Man überzeuge sich, dass bei vy-neu der Bremsbeschleunigungsanteil mal subtrahiert und mal addiert wird,
je nach Vorzeichen (= Richtung) von vy.
reset():
DIGITS:=3:
m:= 10: // Masse in g
v0:= 5: // Abwurf-Geschwindigkeit in m/s
d:= 100: // Durchmesser der Kugel in mm
delta_t:= 50: // Dauer einer Zeiteinheit in ms
cw:= 0.45: // Luftwiderstansbeiwert (Kugel: 0.45)
w_beta:= 25: // Abwurf-Winkel in Grad
h:= 1.3: // Abwurfhöhe in m
g:= 9.814: // Erdbeschleunigung
ro:= 1.225: // Dichte der Luft in kg/m³
vx0:= float(v0*cos(w_beta*PI/180)): // Anfangskomponenten
vy0:= float(v0*sin(w_beta*PI/180)): // der Geschwindigkeit
Bahn:= proc(v0)
local C,C1,vx,vy,a,i;
begin
C:=float(cw*ro*PI*d^2/8);
C1:=float(C/(1000*m));
dt:=delta_t/1000; // dt bestimmt die Genauigkeit der Simulation
sx[0]:=0;sy[0]:=h;
smx[0]:=0;smy[0]:=h;
vx:=vx0;vy:=vy0;
i:=0; // Berechnungen ohne Luftwiderstand
repeat
vx:=vx;
vy:=vy-g*dt;
sx[i+1]:=sx[i]+vx*dt;
sy[i+1]:=sy[i]+vy*dt;
ab:=sy[i+1];
i:=i+1;
until ab<0 end_repeat;
maxx:=i;
vx:=vx0;vy:=vy0;
i:=0; // Berechnungen mit Luftwiderstand
repeat
a:=float(C1*sqrt(vx^2+vy^2)); // s. Text oben
vx:=vx*(1-a*dt); //
vy:=vy*(1-a*dt)-g*dt;
smx[i+1]:=smx[i]+vx*dt;
smy[i+1]:=smy[i]+vy*dt;
ab:=smy[i+1];
i:=i+1;
until ab<0 end_repeat;
maxm:=i;
end_proc:
delta_t:=20: // Dauer einer Zeiteinheit in ms
Bahn(v0):
Punkte_mit:= plot::Point2d([smx[i],smy[i]],
PointSize=1,
PointStyle=Circles,
Color=RGB::Red,
VisibleFromTo = i..i,
VisibleAfterEnd
) $ i=0..maxm:
Punkte_ohne:= plot::Point2d([sx[i],sy[i]],
PointSize=1,
PointStyle=Circles,
Color=RGB::Blue,
VisibleFromTo = i..i,
VisibleAfterEnd
) $ i=0..maxx:
x:=t --> vx0*t: //mathematisch ohne Luftwid.
y:=t --> vy0*t-0.5*g*t^2+h:
Curve_o:= plot::Curve2d([x(t), y(t)], t=0..k, k=0..maxx*dt,
PointSize=1, PointStyle=Circles, Color=RGB::Green):
Bemerkung: Die folgende Grafik ist animiert, man kann sich die theoretische Flugbahn (nach Formel) einzeichnen lassen
und bzgl. der roten und blauen Bahnkurven Orte von Gleichzeitigkeit betrachten.
Am Vergleich mit der simulierten Flugbahn ohne Luftwiderstand erkennt man die Güte der Simulation bzw. der
Näherung, die dann auch für die Simulation mit Luftwiderstand gilt.
Sc:= Punkte_mit, Punkte_ohne, Curve_o,
ViewingBox = [0..5, -1..3],
AxesTitles = ["Wurfweite(m)", "Wurfhöhe(m)"],
YAxisTitleOrientation = Vertical:
plot(Sc, GridVisible):
Teil II Experimentelle Kontrolle
Simulation des Wurfes einer Holzkugel bzw. einer aus Alufolie geformten Kugel
und Vergleich mit dem tatsächlichen Experiment
Eine Holzkugel bzw. eine aus Alufolie geformte Kugel werden mit einem Schussapparat abgeschossen.
Die Startgeschwindigkeit wird vermittels der Durchgangszeit mit einem Lichtschranken-Paar gemessen,
außerdem die Flugweite in x-Richtung. Der Abstand der Lichtschranken beträgt 40,5 mm. Alle übrigen
Werte (Winkel, Massen usw.) findet man unten im MuPAD-Quelltext.
Die Schussweiten werden mit einer Simulation verifiziert bzw. verglichen.
Messwerte:
Holz Weite (m) 5,55 6,30 6,14 5,60 6,55
Zeit (ms) 5,726 5,095 7,690 7,130 8,110
Alu Weite (m) 6,10 6,40 6,50 6,60 6,55 6,52
Zeit (ms) 4,898 4,614 4,648 4,613 4,573 4,629
reset():
DIGITS:=3:
w_beta:=25: // Abwurf-Winkel in Grad
h:=1.3: // Abwurfhöhe in m
g:=9.81: // Erdbeschleunigung
ro:=1.25: // Dichte der Luft in kg/m³
Bahn:=proc(v0)
local vx,vy,a,i,dt;
begin
vx0:=float(v0*cos(w_beta*PI/180)):; // Anfangskomponenten
vy0:=float(v0*sin(w_beta*PI/180)):; // der Geschwindigkeit
C1:=float(cw*ro*PI*d^2/(8000*m)):;
dt:=delta_t/1000; // dt bestimmt die Genauigkeit der Simulation
sx[0]:=0;sy[0]:=h;
smx[0]:=0;smy[0]:=h;
vx:=vx0;vy:=vy0;
i:=0; // Berechnungen ohne Luftwiderstand
repeat
vx:=vx;
vy:=vy-g*dt;
sx[i+1]:=sx[i]+vx*dt;
sy[i+1]:=sy[i]+vy*dt;
ab:=sy[i+1];
i:=i+1;
until ab<0 end_repeat;
maxx:=i;
vx:=vx0;vy:=vy0;
i:=0; // Berechnungen mit Luftwiderstand
repeat
a:=float(C1*sqrt(vx^2+vy^2)); // s. Text oben
vx:=vx*(1-a*dt); //
vy:=vy*(1-a*dt)-g*dt;
smx[i+1]:=smx[i]+vx*dt;
smy[i+1]:=smy[i]+vy*dt;
ab:=smy[i+1];
i:=i+1;
until ab<0 end_repeat;
maxm:=i;
L:= solve(vy0*t-0.5*g*t^2+h,t); // Berechnung ohne Luftwiderstand nach Gleichung
s_theo:=op(L,1)*vx0;
print(NoNL,Unquoted,expr2text(s_theo)."\t\t".expr2text(sx[maxx])."\t\t\t".expr2text(smx[maxm])."\t\t\t")
end_proc:
Holzkugel:
delta_t:= 2: // Dauer einer Zeiteinheit in ms
cw:= 0.45: // Luftwiderstandsbeiwert (Kugel: 0.45)
d:= 34: m:= 15.7: // Durchmesser in mm / Masse in g
ds:= 40.5: //Abstand der Lichtschranken
// Geschwindigkeitsfeld:
v:=[ds/5.725, ds/5.095, ds/5.265, ds/5.68, ds/4.992]:// v in m/s
// Schuss-Weiten
s_messung:=[5.55, 6.30, 6.14, 5.60, 6.55]:;
print(NoNL,Unquoted,"Wurfweiten (* = ohne Luftwiderstand)\n");
print(NoNL,Unquoted,"Theorie*\tSimulation*\tSimulation\tgemessen\t\tAbweich. in %\n");
for j from 1 to 5 do
Bahn(v[j]):;
print(NoNL,Unquoted,expr2text(s_messung[j])."\t\t\t".expr2text(100*(1-s_messung[j]/smx[maxm]))."\n");
end_for
Wurfweiten (* = ohne Luftwiderstand)
Theorie* Simulation* Simulation gemessen Abweich. in %
5.79 5.78 5.51 5.55 -0.659
6.91 6.92 6.52 6.3 3.43
6.57 6.58 6.22 6.14 1.34
5.86 5.85 5.58 5.6 -0.379
7.14 7.15 6.72 6.55 2.48
Aus Alu-Folie geformte Kugel:
Offensichtlich muss der Widerstandsbeiwert der rauen "Kugel" (die außerdem etwas abgeplattet ist)
korrigiert werden. Mit cw = 0,55 erhält man gute Näherungswerte, man rechne aber zunächst mit cw=0,45.
Man kann die Simulation also zur cw-Wert-Bestimmung umfunktionieren.
delta_t:=2: // Dauer einer Zeiteinheit in ms
cw:=0.45: // Luftwiderstandsbeiwert einer glatten Kugel
//cw:=0.55: // Luftwiderstandsbeiwert der rauen Kugel
d:=34: m:=5.8: ds:=40.5:
v:=[ds/4.898, ds/4.614, ds/4.648, ds/4.613, ds/4.573, ds/4.629]:
s_messung:=[6.10, 6.40, 6.50, 6.60, 6.5, 6.52]:
print(NoNL,Unquoted,"Wurfweiten (* = ohne Luftwiderstand)\n");
print(NoNL,Unquoted,"Theorie*\tSimulation*\tSimulation\tgemessen\t\tAbweich. in %\n");
for j from 1 to 6 do
Bahn(v[j]):;
print(NoNL,Unquoted,expr2text(s_messung[j])."\t\t\t".expr2text(100*(1-s_messung[j]/smx[maxm]))."\n");
end_for
Wurfweiten (* = ohne Luftwiderstand)
Theorie* Simulation* Simulation gemessen Abweich. in %
7.36 7.36 6.28 6.1 2.94
8.08 8.08 6.79 6.4 5.8
7.99 7.99 6.74 6.5 3.55
8.09 8.08 6.81 6.6 3.03
8.2 8.2 6.88 6.5 5.54
8.05 8.04 6.77 6.52 3.76
Teil III Kugelstoßen
- Wurfweite in Abhängigkeit vom Abwurfwinkel
- Kugelstoßen in Mexiko City (2240 m ü. NN)
reset():
DIGITS:=6:
Bahn:=proc(winkel)
local vx,vy,a,i,dt;
begin
vx0:=float(v0*cos(winkel*PI/180)); // Anfangskomponenten
vy0:=float(v0*sin(winkel*PI/180)); // der Geschwindigkeit
C1:=float(cw*ro*PI*d^2/(8000*m));
dt:=delta_t/1000; // dt bestimmt die Genauigkeit der Simulation
sx[0]:=0;sy[0]:=h;
smx[0]:=0;smy[0]:=h;
vx:=vx0;vy:=vy0;
i:=0; // Berechnungen ohne Luftwiderstand
repeat
vx:=vx;
vy:=vy-g*dt;
sx[i+1]:=sx[i]+vx*dt;
sy[i+1]:=sy[i]+vy*dt;
ab:=sy[i+1];
i:=i+1;
until ab<0 end_repeat;
maxx:=i;
vx:=vx0;vy:=vy0;
i:=0; // Berechnungen mit Luftwiderstand
repeat
a:=float(C1*sqrt(vx^2+vy^2)); // s. Text oben
vx:=vx*(1-a*dt); //
vy:=vy*(1-a*dt)-g*dt;
smx[i+1]:=smx[i]+vx*dt;
smy[i+1]:=smy[i]+vy*dt;
ab:=smy[i+1];
i:=i+1;
until ab<0 end_repeat;
maxm:=i;
L:= solve(vy0*t-0.5*g*t^2+h,t); // Berechnung ohne Luftwiderstand nach Gleichung
s_theo:=op(L,1)*vx0;
print(NoNL,Unquoted,expr2text(s_theo)."\t\t".expr2text(sx[maxx])."\t\t"
.expr2text(smx[maxm])."\t\t".expr2text(winkel))
end_proc:
Gemeinsame Daten für beide Höhen über NN:
delta_t:=0.5: // Dauer einer Zeiteinheit in ms
cw:=0.45: // Luftwiderstandsbeiwert (Kugel: 0.45)
v0:=13: // Abstoßgeschwindigkeit in m/s
h:=2: // Abstoßhöhe in m
d:=120.88: //Durchmesser in mm
m:=7270: // Masse in g
w_beta:=[39.5, 40.0, 40.5, 41.0, 41.5, 42.0, 42.5, 43.0, 43.5, 44.0, 44.5]:
Simulation auf Meereshöhe
g:=9.814: // Ortsfaktor
ro:=1.225: // Dichte der Luft in kg/m³
print(NoNL,Unquoted,"Wurfweiten (* = ohne Luftwiderstand)\n");
print(NoNL,Unquoted,"Theorie*\t\tSimulation*\tSimulation\tWinkel\n");
for j from 1 to 11 do
Bahn(w_beta[j]):
print(NoNL,"\n");
end_for
Wurfweiten (* = ohne Luftwiderstand)
Theorie* Simulation* Simulation Winkel
19.0561 19.0541 18.9473 39.5
19.0775 19.0756 18.9685 40.0
19.0942 19.0934 18.986 40.5
19.1062 19.1025 18.9948 41.0
19.1134 19.1126 19.0047 41.5
19.1159 19.114 19.006 42.0
19.1137 19.1117 19.0035 42.5
19.1066 19.1055 18.9972 43.0
19.0948 19.0908 18.9824 43.5
19.0781 19.0769 18.9638 44.0
19.0565 19.0545 18.9415 44.5
Simulation in Mexiko 2240 m ü. NN (Erdbeschleunigung, Luftdichte),
Die große Höhe bringt immerhin eine um ca. 3,6 cm größere Weite, davon macht
die Änderung des Ortsfaktors ca. 1,2 cm aus.
g:=9.807: // Ortsfaktor in 2240 m Höhe
ro:=0.773*1.225: // Dichte der Luft in 2240 m Höhe
//Berechnung: www.wetter-herrenberg.de/interaktives/Druck/barometrische.htm
print(NoNL,Unquoted,"Wurfweiten (* = ohne Luftwiderstand)\n");
print(NoNL,Unquoted,"Theorie*\t\tSimulation*\tSimulation\tWinkel\n");
for j from 1 to 11 do
Bahn(w_beta[j]):
print(NoNL,"\n");
end_for
Wurfweiten (* = ohne Luftwiderstand)
Theorie* Simulation* Simulation Winkel
19.0683 19.0641 18.9868 39.5
19.0897 19.0856 19.008 40.0
19.1065 19.1033 19.0205 40.5
19.1185 19.1172 19.0342 41.0
19.1258 19.1223 19.0392 41.5
19.1283 19.1285 19.0404 42.0
19.1261 19.1261 19.0379 42.5
19.119 19.115 19.0315 43.0
19.1072 19.1049 19.0214 43.5
19.0905 19.0862 19.0027 44.0
19.0689 19.0684 18.9802 44.5
Teil IV Freier Fall eines Papier-Kegels
Luftwiderstand proportional zum Quadrat der Geschwindigkeit
Die Werte im MuPAD-Quelltext beziehen sich auf einen konkreten Unterrichtsversuch im Treppenhaus
der Schule, der leider vor Fertigstellung dieser Simulation stattfand. Man erkennt aus den Berechnungen,
dass die Fallhöhe von 8,50 m für die relativ hohen Massen der Kegel nicht ausreichend ist, um auf eine
konstane Endgeschwindigkeit zu kommen. Umgekehrt kann man mit der Simulation bei gegebener
Fallstrecke bestimmen, mit welchen Kegelmassen man arbeiten kann.
Die Prozedur wurde an die Eindimensionalität der Bewegung angepasst.
reset():
DIGITS:=3:
h:=8.5: // Abwurfhöhe in m
g:=9.81: // Erdbeschleunigung
ro:=1.25: // Dichte der Luft in kg/m³
cw:=0.5: // Luftwiderstandsbeiwert eines offenen Kegels
d:=0.28: // Durchmesser des Trichters in m
A:=PI*d^2/4: // Querschnittsfläche in m²
C:=float(0.5*cw*ro*A): // Konstante
Fall:=proc(m)
local vy, a, i, C1, dt;
begin
//C1:=float(cw*ro*PI*d^2/(8000*m));
C1:=float(1000*C/m);
dt:=delta_t/1000; // dt bestimmt die Genauigkeit der Simulation
sy[0]:=h;smy[0]:=h;
vy:=0;vmy[0]:=0;
i:=0; // Berechnungen ohne Luftwiderstand
repeat
vy:=vy-g*dt;
sy[i+1]:=sy[i]+vy*dt;
ab:=sy[i+1];
i:=i+1;
until ab<Endhoehe end_repeat;
maxx:=i;
i:=0; // Berechnungen mit Luftwiderstand
repeat
a:=float(C1*abs(vmy[i])); // s. Text oben
vmy[i+1]:=vmy[i]*(1-a*dt)-g*dt;
smy[i+1]:=smy[i]+vmy[i+1]*dt;
ab:=smy[i+1];
i:=i+1;
until ab<Endhoehe end_repeat;
// Mit ab<-5 (z.B.) kann man "tiefer" fallen
maxm:=i;
//print(NoNL,Unquoted,expr2text(sy[maxx])."\t\t\t".expr2text(smy[maxm])."\t\t\t")
end_proc:
delta_t:=100: // Dauer einer Zeiteinheit in ms
Endhoehe:=0:
Fall(101): // Masse in g
Die folgende Grafik ist animiert. Sie stellt die Geschwindigkeit in Abhängigkeit
vom Ort dar und läuft "rückwärts".
OrtGeschw:= plot::Point2d([smy[i],-vmy[i]],
PointSize=2,
PointStyle=Circles,
Color=RGB::Red,
VisibleFromTo = i..i,
VisibleAfterEnd
) $ i=0..maxm:
Sc:= OrtGeschw,
ViewingBox = [ab-1..h, -0.5..8],
AxesTitles = ["Ort (m)", "Geschwindigkeit (m/s)"],
YAxisTitleOrientation = Vertical:
plot(Sc, GridVisible):
print([smy[i],vmy[i]] $ i=0..maxm)
[8.5, 0], [8.4, -0.981], [8.21, -1.94], [7.92, -2.85], [7.55, -3.68],
[7.11, -4.4], [6.61, -5.01], [6.06, -5.52], [5.47, -5.92],
[4.85, -6.23], [4.2, -6.47], [3.53, -6.66], [2.85, -6.79],
[2.16, -6.89], [1.47, -6.97], [0.765, -7.03], [0.0589, -7.07],
[-0.651, -7.1]
v²/m sollte konstant sein, bei den gegebenen Massewerten ist das aber nicht der Fall.
Erst wenn die Kegel tiefer fallen könnten, z.B. Endhoehe:=-10, erhält man konstante
Quotienten. Alternativ wähle man leichtere Kegel.
m_wert:=[51, 61, 71, 81, 91, 101]:
//m_wert:=[5, 10, 15, 20, 25, 30]:
delta_t:=10: // Dauer einer Zeiteinheit in ms
Endhoehe:=0:
//Endhoehe:=-10: // Der Kegel fällt 10m unter Fussbodenniveau
print(NoNL,Unquoted,"Masse\tEndgeschwindigkeit\tv²/m\n");
for j from 1 to 6 do
Fall(m_wert[j]):
vy[j]:=float(vmy[maxm]):
print(NoNL,Unquoted,expr2text(m_wert[j])."\t\t\t".expr2text(vy[j])."\t\t\t\t".expr2text(vy[j]^2/m_wert[j])."\n");
end_for
Masse Endgeschwindigkeit v²/m
51 -5.1 0.509
61 -5.56 0.508
71 -5.99 0.505
81 -6.37 0.501
91 -6.72 0.496
101 -7.04 0.49
Punkte:= plot::PointList2d([[m_wert[i], abs(vy[i])] $ i=1..6],
PointSize=2, PointStyle=Circles, Color=RGB::Blue):
Statt einer Regressionskurve definiert man mit einem der Punkte
die Wurzelfunktion und bewertet die Lage der übrigen Punkte:
f:=x --> (abs(vy[6])/sqrt(m_wert[6]))*sqrt(x):
Gf:=plot::Function2d(f, x=0..105, Color=RGB::Blue):
Sc:= Punkte, Gf,
ViewingBox = [0..105, 0..8],
AxesTitles = ["Masse (g)", "Geschwindigkeit (m/s)"],
YAxisTitleOrientation = Vertical:
plot(Sc, GridVisible):
"Photosequenz" des fallenden Kegels, Vergleich mit und ohne Luftwiderstand
delta_t:=200: // Dauer einer Zeiteinheit in ms
Endhoehe:=0:
Fall(50):
Punkte_mit:= plot::Point2d([1,smy[i]],
PointSize=2,
PointStyle=Circles,
Color=RGB::Red,
VisibleFromTo = i..i,
VisibleAfterEnd
) $ i=0..maxm:;
Punkte_ohne:= plot::Point2d([2,sy[i]],
PointSize=2,
PointStyle=Circles,
Color=RGB::Blue,
VisibleFromTo = i..i,
VisibleAfterEnd
) $ i=0..maxx:
Sc:= Punkte_mit, Punkte_ohne,
ViewingBox = [0..4,-2..h+1],
AxesTitles = [" ", "Höhe(m)"],
YAxisTitleOrientation = Vertical:
plot(Sc, GridVisible):
_______________________________________________________________________________
Anmerkungen:
1. Weitere Anregungen zum Einsatz von MuPAD in der Lehre finden Sie auf unserem WebPortal
MuPAD in Schule und Studium unter: http://schule.mupad.de bzw. http://studium.mupad.de.
_______________________________________________________________________________