Scilab-Skript

Scilab-Skript
Maria Magdalena Nafalska
WS 09/10
Inhaltsverzeichnis
1 Über dieses Skript
3
2 Einführung
3
3 Grundlegendes
3.1 Konsole . . . . . . . .
3.2 Scipad . . . . . . . . .
3.3 Dateien einbinden . .
3.4 Wichtige Syntaxregeln
3.5 Hilfe-Browser . . . . .
3.6 Fehlermeldungen . . .
3
3
3
4
4
4
4
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
4 Elementare Funktionen und Operatoren
5
5 Komplexe Zahlen
5.1 Wichtige Befehle . . . . . . . . . . . . . . . . . . . . . . . . .
5.2 Plotten von komplexen Zahlen . . . . . . . . . . . . . . . . .
5
6
6
6 Programmieren
6.1 for-Schleifen . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.2 if-then-else-Alternative . . . . . . . . . . . . . . . . . . . . . .
6.3 while-Schleifen . . . . . . . . . . . . . . . . . . . . . . . . . .
7
7
9
10
7 Scilab-Funktionen
12
7.1 Einbinden einer Scilab-Funktion . . . . . . . . . . . . . . . . . 12
7.2 Aufruf einer Scilab-Funktion . . . . . . . . . . . . . . . . . . . 12
8 Vektoren und Matrizen
13
8.1 Vektoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
8.2 Matrizen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
9 Grafische Darstellung - 2D
9.1 Polygon (-züge) . . . . . .
9.2 Funktionsgraphen . . . . .
9.3 m × n - Grafik - Matrix .
9.4 2D-Kurven . . . . . . . .
9.5 Höhenlinien . . . . . . . .
9.6 2D-Vektorfelder . . . . . .
9.7 Flächen in der Ebene . . .
10 Grafische Darstellung 10.1 Funktionsgraphen . .
10.2 3D-Kurven . . . . .
10.3 Flächen im Raum . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
15
15
16
20
22
23
24
25
3D
27
. . . . . . . . . . . . . . . . . . . . . . . 27
. . . . . . . . . . . . . . . . . . . . . . . 29
. . . . . . . . . . . . . . . . . . . . . . . 31
11 Integration
33
11.1 Integration-1D . . . . . . . . . . . . . . . . . . . . . . . . . . 33
11.2 Integration-2D . . . . . . . . . . . . . . . . . . . . . . . . . . 33
2
1
Über dieses Skript
Dieses kurze Scilab-Skript ist für die TeilnehmerInnen der Analysis I und II
für Ingenieure gedacht und soll einen Überblick über die in diesen beiden
Kursen benötigten Scilab-Befehle geben. Derzeit beinhaltet es noch nicht
das Thema Integration, dies wird aber entsprechend dem Vorlesungsstoff
ergänzt.
Fehler und Verbesserungsvorschläge bitte an [email protected]
schicken.
2
Einführung
Scilab ist eine Programmierumgebung zur numerischen und grafischen Bearbeitung von mathematischen Aufgabenstellungen. Zudem ist sie kostenfrei,
also eine gute Alternative zu MATLAB, denn Funktionalität und Syntax
sind sehr ähnlich.
MATLAB wird in Industrie und an Hochschulen für numerische Simulationen, Datenerfassung, Datenanalyse und -auswertung eingesetzt und ist
somit praxisrelevant für den Ingenieursberuf.
Die Software erhalten Sie kostenlos unter http://www.scilab.org. Wenn
Sie das Betriebssystem Windows haben, dann wählen Sie den Scilab 5.1.1
Installer in der 32 bzw. 64 Bits Version aus. Welche Version sie benötigen,
erfahren Sie, indem Sie sich folgendermaßen durchklicken: ”Start” → Systemsteuerung → ”System und Wartung” → ”System” → ”Systemtyp”
Bei anderen Betriebssystemen bitte gogglen.
3
3.1
Grundlegendes
Konsole
Beim Starten des Programms Scilab öffnet sich die Konsole, in der man
Befehle eingeben und durch Drücken der enter-Taste ausführen lassen kann.
Durch Drücken der Pfeiltasten (↑, ↓) kann man durch die zuvor eingetippten
Befehle navigieren.
3.2
Scipad
Möchte man ein Scilab-Programm schreiben und nicht nur einzelne Befehl
ausführen lassen, so ist es sinnvoll, den Scipad zu öffnen (in der Konsole
3
oben links auf den Notizblock klicken) und den Code dort einzutippen und
abzuspeichern (File → Save as).
3.3
Dateien einbinden
Möchte man eine (zuvor abgespeicherte) Datei mit Scilab ausführen oder
auch einzelne Befehle, welche sich in einer bestimmten Datei befinden, verwenden, so muss man diese Datei zunächst bei Scilab einbinden: man öffnet
die Datei im Scipad (”File → Open”) und bindet sie durch ”Execute →
Load into Scilab” ein.
3.4
Wichtige Syntaxregeln
Der Name einer Scilab-Datei endet mit .sce. Bei Dateien, welche ausschließlich Scilab-Funktionen beinhalten, verwendet man die Endung .sci.
Ein Semikolon unterdrückt die Ausgabe, d.h. tippt man z.B. a=1; in die
Konsole (und drückt die enter-Taste), so merkt sich Scilab zwar, dass die
Variable a den Wert 1 hat, gibt dies aber nicht auf dem Bildschirm aus.
Lässt man das Semikolon weg, so lautet die Ausgabe auf dem Bildschirm:
a=
1.
Alles was hinter // steht (sowohl in der Konsole als auch im Scipad),
gilt als Kommentar und wird von Scilab nicht beachtet. Man sagt auch, der
Text ist ”auskommentiert”.
3.5
Hilfe-Browser
Mit dem Befehl help öffnet sich ein Hilfe-Fenster, wo Sie Informationen zu
allen Scilab-Befehlen erhalten. Durch die Eingabe help plot2d kann man
sich explizit über den Befehl der hinter help steht informieren, hier also
plot2d.
3.6
Fehlermeldungen
Es ist eher der Normalfall, dass neu geschriebene Programme nicht auf Anhieb funktionieren. Oft verursacht schon das Fehlen eines Kommas oder
eine vergessene Klammer eine Fehlermeldung. Lassen Sie sich dadurch nicht
entmutigen, sondern gehen Sie das Programm Schritt für Schritt durch, sofern die Fehlermeldung selbst nicht eine (eindeutige) Antwort darauf liefert,
weshalb das Programm nicht das Gewünschte leistet.
4
4
Elementare Funktionen und Operatoren
Addition, Subtraktion, Multiplikation und Division werden durch +, -, *,
/ ausgedrückt. Desweiteren gibt es bei Scilab elementare (vorprogrammierte) sowie auch benutzerdefinierte Funktionen. Auf die letzteren gehen wir in
Kapitel 7 ein. Zu den elementaren Funktionen gehören z.B. die Trigonometrischen Funktionen oder aber Funktionen, welche den Absolutbetrag einer
(komplexen) Zahl oder die Fakultät einer natürlichen Zahl berechnen. Im
Folgenden finden Sie einige elementare Funktionen:
• Betrag |x| einer Zahl x: abs(x)
Z
• n-te Potenz einer Zahl x (n ∈ ): x^n
√
• Quadratwurzel x einer Zahl x: sqrt(x)
• Sinus von x: sin(x)
• Cosinus von x: cos(x)
• Tangens von x: tan(x)
• Kotangens von x: cotg(x)
• exp(x) bzw. ex : exp(x) bzw. %e^x
• der natürliche Logarithmus von x > 0: log(x)
• zufällig generierte reelle Zahl: rand
• n! wobei n ∈
5
N:
factorial(n)
Komplexe Zahlen
Scilab stellt komplexe Zahlen intern in kartesischer Form z = x + iy dar. Es
ist aber auch möglich, diese in Polarform z = |z|eiϕ = |z|(cos(ϕ) + i sin(ϕ))
einzugeben. Die Ausgabe erfolgt allerdings stets in kartesischer Form.
Dabei ist der Winkel in Bogenmaß einzugeben, also z.B.
z=3*e^ (%i*%pi/4)
oder auch
z=2*(cos(0.5)+%i*sin(0.5)),
wobei in diesem Fall 0.5 =
0.5
π
·π ≈
0.5
3.14
5
· π ≈ 0.16π ≈ 16 π ist.
5.1
Wichtige Befehle
Im Folgenden finden Sie einige wichtige Befehle im Zusammenhang mit komlexen Zahlen. Sei z ∈ :
C
• imaginäre Einheit i: %i
• Realteil von z: real(z)
• Imaginärteil von z: imag(z)
• Konjugierte von z: conj(z)
• Betrag von z: abs(z)
Z
• (komplexe) Zahl z n mit n ∈ : z^n
• (komplexe) Zahl ez : %e^z
• Polarkoordinaten von z: [r,phi]=polar(z)
Da Scilab numerisch arbeitet, kann es beim letzten Befehl durchaus vorkommen, dass der Winkel eine komplexe Zahl ist (wobei der komplexe Anteil
aber praktisch Null ist).
Möchte man den Winkel einer komplexen Zahl ”per Hand” ausrechnen,
so kann man dies mit der Eingabe
atan((imag(z),real(z))
(Bogenmaß)
bzw.
atan((imag(z),real(z))/%pi*180
(Winkelmaß)
erreichen. Der Winkel liegt dann im Bereich ±π bzw. ±180◦ .
5.2
Plotten von komplexen Zahlen
Beispiel 5.1 ist ein kleines Programm, welches komplexe Zahlen als Vektoren (Pfeile) grafisch darstellt. Es ist sicher nicht perfekt, dafür aber leicht
nachzuvollziehen. Informationen zu Scilab-Funktionen und zum Plotten im
Allgemeinen (plot2d()) erhalten Sie in den Kapiteln 7 und 9. An dieser
Stelle reicht es aber, wenn Sie sich das Programm runterladen und als Datei imagplot.sci speichern. Anschießend können Sie sich mit dem Aufruf
imagplot(z) (in der Console) die komplexe Zahl z grafisch darstellen lassen. Durch mehrfachen Aufruf mit verschiedenen Zahlen z ∈
lassen sich
mehrere komplexe Zahlen gleichzeitig darstellen.
C
6
Beispiel 5.1.
function imagplot(z)
L=abs(z);
plot2d([-L 0 0 0 0 L],[0 0 L -L 0 0],style=1,axesflag=5);
xarrows( [0,real(z)], [0,imag(z)], L, 5 );
endfunction
Die elementare Funktion xarrows() erwartet vier Argumente: einen Vektor
mit x-Werten x = (x1 , x2 ), einen Vektor mit y-Werten y = (y1 , y2 ), die Größe
der Pfeilspitze als Zahl und die Farbe des Pfeils als Zahl (siehe Kapitel 9).
Die Punkte (x1 , y1 ) und (x2 , y2 ) werden mit einem Pfeil verbunden und in
einem Koordinatenkreuz dargestellt.
2.0
1.5
1.0
0.5
0.0
-2.0-1.5 -1.0 -0.5 0.0 0.5 1.0 1.5 2.0
-0.5
-1.0
-1.5
-2.0
Diese Grafik wurde durch den Aufruf von imagplot(0.5*%i-1.5),
imagplot(-1.5*%i+1), imagplot(%i+1.5) erzeugt.
6
6.1
Programmieren
for-Schleifen
Schleifen benötigt man, wenn Anweisungen wiederholt ausgeführt werden
sollen. Die Schreibweise einer for-Schleife sieht folgendermaßen aus:
7
• Größen, die in der Schleife geändert werden, muss man vor Beginn
der Schleife einen Wert zuweisen!
• for k=m:(m+n)
k ist eine Variable, m und n können Zahlen oder Variablen sein;
k=m:(m+n) bedeutet: k = m, m + 1, ..., m + n
• Anweisungen, die wiederholt ausgeführt werden sollen
• end
Die Schleife wird nach n + 1 Durchläufen verlassen.
Beispiel 6.1.
Wir berechnen die Geometrische Summe
n
∑
xk = 1 + x + x2 + ... + xn
k=0
für x =
1
2
und n = 10. Anschließend kontrollieren wir das Ergebnis mit Hilfe
n
∑
n+1
der Formel
xk = 1−x
1−x , für x ̸= 1, Analysis I Skript, Beispiel 21:
k=0
n=10;
S=0;
x=1/2;
//Initialisierung
for k=0:n
S=S+x^k;
end
//für k=0,...,n
//bei jedem Durchlauf wird x^k zu S
//dazuaddiert
S
K=(1-x^(n+1))/(1-x)
//Ausgabe der Summe
//Kontrolle
Die Ausgabe lautet in diesem Fall:
S =
1.9990234
K =
1.9990234
8
6.2
if-then-else-Alternative
Diese Anweisung dient der bedingten Ausführung von alternativen Programmzweigen. Die Schreibweise dafür lautet wiefolgt:
• if Bedingung then
Anweisung, Anweisung,...
• evtl. Zeile(n) der Form:
elseif Bedingung then
Anweisung, Anweisung,...
• else
Anweisung, Anweisung,...
• end
Zur Formulierung der Bedingungen gibt es mehrere Möglichkeiten:
logische Operatoren:
Vergleichsoperatoren:
&
”und”
|
”oder”
==
”gleich”
~=
”ungleich”
<
”kleiner als”
<=
”kleiner oder gleich”
>
”größer als”
>=
”größer oder gleich”
Beispiel 6.2.
Das folgende Programm überprüft zunächst, ob die am Anfang eingegebene Zahl x gleich 2 bzw. im Intervall [1, 1.5[ liegt. Ist dies der Fall,
so erscheint auf dem Bildschirm: x=2 oder x ist größer gleich 1 aber
kleiner als 1.5.
Ist dies nicht der Fall, wird als nächstes überprüft, ob x ∈ [1.5, ∞[ aber
x ̸= 2. Der Fall x = 2 kann hier gar nicht mehr auftreten, denn das wäre
9
schon im ersten Fall aufgefallen. Von daher könnte man diese Abfrage weglassen, falsch ist sie aber nicht. Ist x also größer als 1.5, so erscheint auf dem
Bildschirm: Fall 2.
Ist auch dies nicht erfüllt, so wird überprüft, ob x kleiner als -1 ist, und
in diesem Fall wird x<-1 ausgegeben.
In allen anderen Fällen, also wenn x ∈ [−1, 1[ ist, erhalten wir die Ausgabe: sonst.
Da wir am Anfang x = 3 eingegeben haben, lautet in unserem Fall die
Ausgabe: Fall 2.
x=3;
if x==2 | (x>=1 & x<1.5) then
’’x=2 oder x ist größer gleich 1 aber kleiner als 1.5’’
elseif x>=1.5 & x~ =2 then
’’Fall 2:’’
elseif x<-1 then
’’x<-1’’
else
’’sonst’’
end
6.3
while-Schleifen
Diese Anweisung dient der wiederholten Ausführung einer Anweisung in
Abhängigkeit eines boolschen Ausdrucks (Aussage). Die Schreibweise dafür
lautet wiefolgt:
• while Bedingung then
Anweisung, Anweisung,...
• else
Anweisung, Anweisung,...
• end
10
Die Schleife wird solange durchlaufen, wie die Bedingung aus der ersten
Zeile erfüllt ist. Nach jedem Durchlauf wird geprüft, ob diese Bedingung
immer noch erfüllt ist. Ist dies (das erste mal) nicht der Fall, so springt das
Programm zu den Anweisungen hinter else und danach wird die Schleife
verlassen.
Zur Formulierung der Bedingungen gibt es die gleichen Möglichkeiten,
die in Kapitel 6.2 aufgeführt wurden.
Beispiel 6.3.
Das folgende Programm schreibt solange immer noch kleiner auf den
Bildschirm, solange die zuvor eingegebene Zahl d kleiner als die Zahl f ist.
Bei jedem Durchlauf der Schleife wird der Wert von d um 1 erhöht, so dass
nach geügend Durchläufen endlich gleich auf dem Bildschirm erscheint.
d=2; f=4;
while d<f then
’’immer noch kleiner’’, d=d+1;
else
’’endlich gleich’’
end
Die Ausgabe lautet in diesem Fall:
ans =
immer noch kleiner
ans =
immer noch kleiner
ans =
endlich gleich
Hätte man in diesem Beispiel die Anweisung d=d+1; vergessen, so hätte
man eine Endlosschleife erzeugt, denn die Abbruchbedingung d ≥ f wäre
nie erfüllt gewesen. In diesem Fall kann man in der Konsole ”Control →
abort” klicken. Dies beendet die Schleife.
11
7
Scilab-Funktionen
Bei Scilab hat der/die BenutzerIn auch die Möglichkeit, eigene Funktionen
zu definieren. Dateien, welche nur aus einer (oder mehreren) Funktionen
bestehen, bekommen dabei die Endung .sci. Die Schreibweise lautet wiefolgt:
• function [y1,...,yn]=Funktionsname(x1,...,xm)
wobei x1,...,xm Eingabe- und y1,...,yn Ausgabegrößen sind
• Befehle zur Berechnung der Ausgabegrößen aus den Eingabegrößen
• endfunction
Im Fall von nur einer Ausgabegröße, können die eckigen Klammern weggelassen werden.
7.1
Einbinden einer Scilab-Funktion
Die entsprechende Datei wird mit ”Execute → Load into Scilab” (im Scipad)
eingebunden. Anschließend kann die Funktion in der Konsole oder innerhalb
eines anderen Programms aufgerufen werden.
7.2
Aufruf einer Scilab-Funktion
Dazu muss die Funktion bereits eingebunden sein! Es werden nun der Name der Funktion und die Variablen in runden Klammern eingeben, z.B.
imagplot(%i+3). Möchte man auf die Ausgabegröße noch einmal zugreifen,
so muss man sie in einer Variable abspeichern, z.B. w=MeineFunktion(x).1
Bei mehreren Ausgabevariablen muss man diese in eckigen Klammern
auflisten, z.B. [r,phi]=polar(%i+1). Dabei müssen die Namen der Variablen nicht mit denen in der Funktion definierten übereinstimmen; nur
Reihenfolge und Anzahl sind wichtig.
Beispiel 7.1 (1 Eingabegröße, 1 Ausgabegröße).
function [q]=quad(x)
q=x*x;
endfunction
1
Eine Funktion muss nicht unbedingt einen Rückgabert haben: Die Funktion
imagplot() z.B. erzeugt lediglich eine Grafik.
12
Aufruf z.B. mit s=quad(7). Wie schon erwähnt, muss man nicht die gleichen
Variablen wie in der Funktionsdefinition verwenden. So wäre auch der Aufruf
a=quad(6) möglich.
Beispiel 7.2 (2 Eingabegrößen, 1 Ausgabegröße).
function [s]=summe(x,y)
s=x+y;
endfunction
Aufruf z.B. mit s=summe(2,3).
Beispiel 7.3 (2 Eingabegrößen, 2 Ausgabegrößen).
function [s,p]=sumprod(x,y)
s=x+y; p=x*y;
endfunction
Aufruf z.B. mit [s,p]=sumprod(3,4).
8
8.1
Vektoren und Matrizen
Vektoren
Mit Vektoren kann man mehrere Zahlen gleichzeitig erfassen. Die Eingabe
eines Vektors sieht wiefolgt aus:
• Komponenten zwischen eckigen Klammern eingeben [ ]
• getrennt mit Kommata (oder Leerzeichen) bei Zeilenvektoren
• getrennt mit Semikolons (oder Zeilenwechseln) bei Spaltenvektoren
• es können auch einzelne Komponenten eingeben werden (s.u.)
Die Länge des Vektors x erhält man beim Aufruf von length(x). Transponieren eines Vektors x erreicht man durch x’. Auf die k-te Komponente von x kann man mit dem Befehl x(k) zugreifen, wobei k ∈ {1,2,...,
length(x)}.
13
Beispiel 8.1.
Die Befehle
a=[0 1 2];
b=[0;1;2];
c=[0:100];
d=[0:0.1:1];
e=sin(0:10);
erzeugen die Vektoren
 
0
a = (0, 1, 2), b =  1  c = (0, 1, 2, ..., 99, 100), d = (0, 0.1, 0.2, ..., 0.9, 1),
2
(
)
e = sin(0), sin(1), ..., sin(9), sin(10) .
Wenn wir einen Vektor mit erstem Eintrag x1 und letztem Eitrag xn und
genau n Einträgen erzeugen wollen, so können wir linspace(x1,xn,n) verwenden.
Beispiel 8.2.
Wir berechnen die ersten 10 Glieder der Eulerfolge (an ) = (1+ k1 )n (Analysis
I Skript, Beispiel 39) und speichern diese in dem Vektor a ∈ 10 . Zum
Schluss lassen wir uns den Vektor a, seine Länge und zum Vergleich die
Zahl e ausgeben. Wir wissen ja, dass limn→∞ an = e ist.
R
8.2
for k=1:10
a(k)=(1+1/k)^ k;
end
//Die Glieder der Folge werden in dem
//Vektor a gespeichert
a
length(a)
%e
//Ausgabe der Eulerfolge (als Vektor)
//Ausgabe der Länge von a
//Ausgabe der Zahl e zum Vergleich
Matrizen
Dieses Thema schneiden wir nur sehr kurz an, da für unsere Zwecke einige wenige Tatsachen ausreichend sind. Die Schreibweise sieht, am Beispiel,
wiefolgt aus:
14
Beispiel 8.3.
Die Befehle
A=[0,1;1,1;2,3]
B=[0 1
1 1
2 3]


0 0
erzeugen die gleiche Matrix A =  1 1 .
2 3
Die Anzahl der Elemente der Matrix A erhält man beim Aufruf von
length(A). Transponieren einer Matrix A erreicht man durch A’. Auf das
Element in der i-ten Zeile und j-ten Spalte von A, also auf Ai,j kann man
mit dem Befehl A(i,j) zugreifen.
9
Grafische Darstellung - 2D
Zunächst ein kleiner Trick: Bevor mit Scilab aufwendige Grafiken gezeichnet
werden, sollte man zunächst einen einfachen Plot-Befehl ausführen lassen.
Durch dieses ”Warmlaufen” können Programmabstürze verhindert werden.
9.1
Polygon (-züge)
Bevor gezeichnet wird, sollten alte Grafiken gelöscht werden:
xdel
clf()
schließt alle offenen Grafikfenster
löscht die bisherige Grafik
Um eine zwei-dimensionale Grafik (x-y–Grafik) zu zeichnen, müssen die
gewünschten x-y–Punkte in x- und y- Vektoren eingegeben werden. Das
könnte z.B. so aussehen:
x=[0 1 2 0];
y=[1 0 1 1];
Diese müessen stets gleich lang sein! Der Befehl plot2d(x,y) bewirkt, dass
die Punkte samt den Verbindungslinien in die x-y–Ebene gezeichnet werden:
15
1.0
0.8
0.6
0.4
0.2
0.0
0.0
0.4
0.8
1.2
1.6
2.0
Auf die weiteren Gestantungsmöglichkeiten, wie Farbe der Linien, Achseneinstellungen, etc. gehen wir im nächsten Kapitel ein.
9.2
Funktionsgraphen
Um die Funktion f (x) = y grafisch darzustellen, gibt es verschiedene Vorgehensweisen: bei elementaren Funktionen kann man die x- und die entsprechenden y-Werte als Vektoren definieren und dann wieder plot2d()
verwenden:
Beispiel 9.1.
1.0
x=[0:0.1:2];
y=sin(x);
0.8
0.6
0.4
plot2d(x,y)
0.2
0.0
0.0
0.4
0.8
1.2
1.6
2.0
Die ersten beiden Befehle erzeugen die Vektoren x=[0, 0.1, ... , 1.9,
2] und y=[sin(0), sin(0.1), ... , sin(1.9), sin(2)]. Bei ScilabFunktionen, wie z.B. sin(), ist auch sin(x) definiert, wenn x ein Vekor
ist: damit ist das Anwenden von sin() auf jede Komponente von x gemeint.
Das Ergebnis ist also wieder ein Vektor.
Wenn aber z.B. f (x) = x · x ist, so wird Scilab eine Fehlermeldung
ausgeben, weil hier zwei Zeilenvektoren miteinander multipliziert werden
müssten.
16
In so einem Fall kann man f als Scilab-Funktion f() definieren und den
Befehl fplot2d() verwenden:
Beispiel 9.2.
x=[0:0.1:4];
16
function [y]=f(x)
y=x*x;
endfunction
12
8
4
fplot2d(x,f)
0
0
1
2
3
4
Diese Prozedur hätte hier mit der Definition y=x^2 umgangen werden können,
aber z.B. bei f (x) = xex hätte man wieder das oben beschriebene Problem.
Auch die Operation 1/t bereitet Probleme, denn Scilab erzeugt aus dem
Zeilenvektor t den Spaltenvektor 1/t mit den elementweisen Reziproken.
Auch in diesem Fall empfiehlt sich die o. g. Vorgehensweise.
Der Aufruf von plot2d() bzw. fplot2d() erzeugt eine Grafik, in welcher die plot-Punkte mit Linien verbunden werden. Dabei wird die Grafik
desto genauer sein, je ”feiner” der Vektor x ist. Man kann das Bild durch
mehrfachen Aufruf aufbauen, da die alten Grafiken nicht gelöscht werden,
sofern man dies nicht expizit durch clf() fordert.
Eine andere Möglichkeit, die Funktion aus Beispiel 9.2 zu plotten, wäre
die Scilab-Funktionen feval() und plot2d zu verwenden: Die erstgenannte
evaluiert im Fall der Eingabe von feval(x,f) eine (zuvor definierte) ScilabFunktion f an den Stellen x(j) eines Vektors x, wobei j=1,...,length(x).
Das Ergebnis ist also ein Vektor der gleichen Länge wie x.
Beispiel 9.3.
x=[0:0.1:4];
16
function [y]=f(x)
y=x*x;
endfunction
12
8
4
y=feval(x,f);
plot2d(x,y)
0
0
17
1
2
3
4
Dies scheint auf den ersten Blick etwas aufwendiger als zu zuvor beschriebene Variante zu sein, hat aber den Vorteil, dass man damit Funktionenfamilien plotten kann, die formal von zwei Variablen abhängen:
Beispiel 9.4.
Wir möchten die Funktionenfamilie
fm (x) = x sin(mx),
x ∈ [−6, 6],
für m ∈ {1, 3, 10} plotten.
6
function y=f(x,m)
y=x*(sin(m*x))
endfunction
4
x=[-6:0.1:6];
2
m=1;
y1=feval(x,f);
m=3;
y2=feval(x,f);
0
m=10;
y3=feval(x,f);
-2
plot2d(x,y1,style=5)
plot2d(x,y2,style=4)
plot2d(x,y3,style=2)
-4
-6
-6
-4
-2
0
2
4
Dabei bewirkt style=i, dass für die Verbindungslinien eine bestimme
Farbe bzw. Form verwendet wird. Folgende Möglichkeiten gibt es:
i=1: schwarz, i=2: blau, i=3: grün, i=4: hellblau, i=5: rot, i=6: magenta,
i=7: gelb, i=0: nur die Punkte werden gezeichnet, i=-1: statt der Punkte
18
6
werden ”+” verwendet, i=-2: statt der Punkte werden ”x” gezeichnet.
Manchmal ist es sinnvoll, zwei Funktionen mit verschiedenen Stützstellen
(x-Werten) zu verwenden. Möchte man nämlich von der einen Funktion nur
einige Punkte von der anderen aber den Funktionsgraphen plotten, so muss
man verschiedene x-Vektoren definieren (und auch in plot2d() übergeben).
Weitere Gestaltungsmöglichkeiten bietet der Befehl xtitle(’Titel’,
’x-Achse’,’y-Achse’), mit dem man die Grafik, die x- und die y-Achse beschriften kann. Mit xgrid(i) kann man ein Gitter einblenden lassen, wobei i die Farbe des Gitters definiert (Farbgebung s.o.). Durch den Befehl
legend(’Funktion 1’, ’Funktion 2’, ...); lässt sich eine Legende erzeugen.
All diese Befehle kann man auch im Zusammenhang mit fplot2d()
verwenden. Darüberhinaus ist es auch möglich, xtitle(), xgrid() und
legend() in 3D-Plots einzusetzen.
Beispiel 9.5.
xdel
clf()
x=[-5:0.1:5];
function y=f1(x)
y=x^ 2+x^ 3;
endfunction
function y=f2(x)
y=x^ 2;
endfunction
fplot2d(x,f1,style=5)
fplot2d(x,f2,style=2)
xgrid(3)
legend(’x^ 2+x^ 3’,’x^ 2’);
xtitle(’Zwei Polynome’,’x-Achse’,’y-Achse’)
19
Zwei Polynome
150
x^2+x^3
x^2
y-Achse
100
50
0
-50
-100
-5
9.3
-4
-3
-2
-1
0
1
x-Achse
2
3
4
5
m × n - Grafik - Matrix
Mit Hilfe der Scilab-Funktion subplot() lässt sich eine m × n - GrafikMatrix erzeugen, d.h. in einem einzigen Fenster werden in m Zeilen und n
Spalten m · n Grafiken gezeichnet. Der dritte Parameter in subplot(m,n,s)
bestimmt die Position in der Matrix.
Beispiel 9.6.
xdel
clf()
//schließt alle offenen Grafikfenster
//löscht die bisherige Grafik
x=[0:0.1:10];
//x=[0, 0.1, 0.2, ... ,9.8, 9.9, 10]
y1=sin(x);
y2=cos(x);
//y1=[sin(0), sin(0.1), ... , sin(10)]
//y2=[cos(0), cos(0.1), ... , cos(10)]
20
// Grafik 1: - - - -
- - - - - - - - - - - - - - - - - - -
subplot(2,1,1)
plot2d(x,y1,style=5)
//erzeugt eine 2x1-Grafik-Matrix;
//der nachstehende plot-Befehl ist für
//die obere (=erste) Grafik
//plottet die Punkte (0,sin(0)),
//(0.1,sin(0.1)), ..., (10,sin(10))
//samt Verbindungslinien in rot
// Grafik 2: - - - -
- - - - - - - - - - - - - - - - - - -
subplot(2,1,2)
//der nachstehende plot-Befehl ist für
//die untere (=zweite) Grafik
//plottet die Punkte (0,cos(0)),
//(0.1,cos(0.1)), ..., (10,cos(10))
//samt Verbindungslinien in blau
plot2d(x,y2,style=2)
1.0
0.6
0.2
-0.2
-0.6
-1.0
0
1
2
3
4
5
6
7
8
9
10
1
2
3
4
5
6
7
8
9
10
1.0
0.6
0.2
-0.2
-0.6
-1.0
0
21
9.4
2D-Kurven
Der Befehl zum Plotten einer Kurve
γ : [a, b] →
R,
2
(
t 7→
x(t)
y(t)
)
= γ(t)
ist plot2d(x,y), wobei x und y gleich lange Vektoren sind, welche die Funktionswerte von x(t) und y(t) enthalten. Hier kann man wieder die weiteren
Optionen verwenden, welche in Kapitel 9.2 beschrieben sind.
Beispiel 9.7.
Wir möchten die Kurve
(
γ(t) =
cos(t)
t
)
,
t ∈ [0, 6π]
grafisch darstellen.
xdel
clf()
t=[0:0.1:6*%pi];
plot2d(cos(t),t)
20
18
16
14
12
10
8
6
4
2
0
-1
0
1
Handelt es sich bei den Komponenten um kompliziertere Funktionen,
so muss man diese erst als Scilab-Funktionen schreiben und dann mit Hilfe
von feval() auswerten lassens. Diese evaluiert eine (zuvor definierte) ScilabFunktion f an den Stellen t(j), wobei j=1,...,length(t). Das Ergebnis
ist also ein Vektor der gleichen Länge wie t.
22
Beispiel 9.8.
Wir möchten die Kurve
(
γ(t) =
t cos(t)
t sin(t)
)
t ∈ [0, 25]
,
grafisch darstellen.
xdel
clf()
t=[0:0.1:25];
function x=f1(t)
x=cos(t)*t;
endfunction
function y=f2(t)
y=sin(t)*t;
endfunction
x=feval(t,f1);
y=feval(t,f2);
25
20
15
10
5
0
-5
-10
-15
-20
-25
-25
-15
-5
5
15
25
plot2d(x,y)
9.5
Höhenlinien
R
R
Die Höhenlinien Hc einer Funktion f : D ⊂ 2 → , (x, y) 7→ f (x, y) zu
einem Niveau c ∈ sind Teilmengen des 2 , nämlich
R
R
R2 | f (x, y) = c }.
Der Graph einer solchen Funktion liegt allerdings im R3 .
Hc = {(x, y) ∈ D ⊂
Zum Zeichnen von Höhenlinien einer Funktion f gibt es bei Scilab den
Befehl fcontour2d(). Der optionale Parameter i in fcontour2d(x,y,f,i)
bestimmt dabei die Anzahl der gezeichneten Höhenlinien; x und y sind
gleichlange Vektoren.
23
Beispiel 9.9.
Das folgende Programm zeichnet sieben Höhenlinien der Funktion f (x, y) =
x2 − y 2 auf dem Bereich [−5, 5] × [−5, 5]. Da diese Grafikfunktion sehr zeitaufwendig ist, wählen wir lediglich 0.5 als Schrittweiten für die Vektoren.
5
xdel
clf()
x=[-5:0.5:5];
y=[-5:0.5:5];
4
-18.8
-12.5
3
-6.25
2
1
18.8
12.56.25
0
6.2512.5
18.8
0
function z=f(x,y)
z=x^ 2-y^ 2;
endfunction
-1
-2
-6.25
fcontour2d(x,y,f,7)
-3
-12.5
-18.8
-4
-5
-5 -4 -3 -2 -1
9.6
0
1
2
3
4
5
2D-Vektorfelder
Die grafische 2D-Darstellung eines Vektorfeldes
(
)
u(x, y)
f (x, y) =
,
(x, y) ∈ D ⊂
v(x, y)
R2
R
kann mithilfe des Befehls champ(x,y,U,V) erfolgen. Dabei sind x,y ∈ k die
Vektoren der Länge k mit den x- und y-Werten und U,V ∈ k×k Matrizen
mit U(i,j)= u(x(i), y(j)) und V(i,j)= v(x(i), y(j)), also die Komponenten des Vektorfeldes am Punkt (x(i),y(j)). Diese Matrizen bekommen
wir mit Hilfe des Befehls feval(x,y,func), wenn wir für func jeweils die
Komponenten der Funktion f einsetzten.
R
24
Beispiel 9.10.
Gegeben sei das Vektorfeld
(
)
cos(x)
f (x, y) =
,
sin(y)
(x, y) ∈ [−7, 7] × [10, 10].
Mit dem folgenden Programm können wir es grafisch darstellen lassen:
xdel
clf()
10
x=[-7:7];
y=[-10:10];
8
function u=f1(x,y)
u=cos(x);
endfunction
4
6
2
0
function v=f2(x,y)
v=sin(y);
endfunction
-2
-4
-6
U=feval(x,y,f1);
V=feval(x,y,f2);
champ(x,y,U,V)
9.7
-8
-10
-8
-6 -4
-2
0
2
4
6
8
Flächen in der Ebene
Um parametrisierte Flächen in der Ebene zu plotten, verwenden wir den
Befehl plot(). Dazu schreiben wir die Komponenten der Funktion
(
)
x(r, s)
⃗x(r, s) =
,
r ∈ [a, b], s ∈ [c, d],
y(r, s)
25
als Scilab-Funktionen x und y und werten diese mit dem Befehl feval(r,s,x),
etc. aus. Wie schon in Kapitel 9.6 erklärt, ist das Ergebnis jeweils eine Matrix, welche die Funktionswerte an den Stellen (r(i),s(j)) enthält. Dabei
sind r und s Vektoren, die den Intevallen [a, b] bzw. [c, d] entsprechen. Diese
sollten mit Hilfe von linspace() erstellt werden. Denn verwendet man z.B.
im Fall φ ∈ [−π, π] die Definition phi=[-%pi:0.05:%pi], so entsteht in der
Grafik ein Spalt bei φ = π.
Beispiel 9.11.
Wir möchten den Kreisring plotten, der durch die Parametrisierung
(
)
r cos(φ)
⃗x(r, φ) =
,
φ ∈ [−π, π], r ∈ [0.5, 1]
r sin(φ)
gegeben ist.
xdel
clf()
1.0
phi=linspace(-%pi,%pi,50);
0.8
r=linspace(0.5,1,100);
0.6
function u=x(phi,r)
u=r*cos(phi);
endfunction
0.4
0.2
0.0
function v=y(phi,r)
v=r*sin(phi);
endfunction
-0.2
U=feval(phi,r,x);
V=feval(phi,r,y);
-0.8
-0.4
-0.6
-1.0
-1.0
-0.6
-0.2
0.2
0.6
plot(U,V)
Wer gerne lieber einen schwarzen Kreisring hätte, möge den Plot-Befehl
plot2d(U,V, style=[ones(100,1)]) verwenden.
26
1.0
10
Grafische Darstellung - 3D
Beim Erstellen von 3D-Grafiken kann wieder der Befehl subplot() verwendet werden.
Die optionalen Parameter der einzelnen Plot-Befehle werden hier nicht
im einzelnen erörtert und auch nicht zur Bearbeitung der Hausaufgaben
benötigt. Informieren Sie sich ggf. im Help-Browser darüber, indem Sie z.B.
help plot3d in die Konsole eingeben, siehe Kapitel 3.5.
Die in Kapitel 9.2 beschriebenen Grafik-Befehle xtitle(), legend()
und xgrid() können aber auch in 3D-Grafiken eingesetzt werden.
10.1
Funktionsgraphen
R
R
Sei f : D ⊂ 2 → . Ähnlich wie in Kapitel 9.2 definiert man einen ”Definitionsbereich”, eine Scilab-Funktion f() und verwendet dann die ScilabFunktion fplot3d().
Dabei müssen die Vektoren, welche den Definitionsbereich charakterisieren nicht die gleiche Länge haben.
Beispiel 10.1.
Wir plotten den Graphen der Funktion
f (x, y) = x2 + y 2 ,
(x, y) ∈ [−5, 5] × [−5, 5].
xdel
clf()
x=[-5:0.1:5];
y=[-5:0.1:5];
function z=f(x,y)
z=x^ 2+y^ 2;
endfunction
fplot3d(x,y,f)
27
Beispiel 10.2.
Wir plotten den Graphen der Funktion
f (x, y) = x + y,
(x, y) ∈ [−5, 5] × [−5, 5].
xdel
clf()
x=[-5:0.1:5];
y=[-5:0.1:5];
function z=f(x,y)
z=x+y;
endfunction
fplot3d(x,y,f)
Hier bietet es sich an die Grafik zu drehen (oben links ª im Grafik-Fenster):
Beispiel 10.3.
In diesem Beispiel möchten wir die Funktion
f (x, y) =
x2
1
+ y2
auf dem Bereich [−5, 5] × [−5, 5] plotten. Das Problem dabei ist, dass die
Funktion bei (0, 0) gar nicht definiert ist. Dies ist aber auch der einzige kriti28
sche Punkt. Mit einem Trick lässt sie sich doch auf diesem Bereich darstellen:
Wir definieren die Vektoren x = y = (−5, −4.89, −4.78, ..., −0.16, −0.05, 0.06,
..., 4.79, 4.9). Damit wird die Funktion nicht an dem kritischen Punkt ausgewertet aber dennoch auf dem ”ganzen” Bereich dargestellt:
xdel
clf()
x=[-5:0.11:5];
y=[-5:0.11:5];
function z=f(x,y)
z=1/(x^ 2+y^ 2);
endfunction
fplot3d(x,y,f)
Eine andere Möglichkeit wäre den Definitionsbereich aufzuteilen, und die
Funktion auf den unkritischen Bereichen durch mehrfachen Aufruf des Plotbefehls zu zeichnen.
10.2
3D-Kurven
Zum Zeichnen einer Kurve

γ : [a, b] →
R3 ,

x(t)
t 7→ γ(t) =  y(t) 
z(t)
gibt es bei Scilab den Befehl param3d(x,y,z), wobei x, y und z gleichlange
Vektoren sind, welche die Funktionswerte von x(t), y(t) und z(t) enthalten.
Beispiel 10.4.
Wir möchten die Kurve

cos(t)
γ(t) =  sin(t)  ,
t

29
t ∈ [0, 8π]
grafisch darstellen. (Die folgende Grafik haben wir geeignet gedreht.)
30
25
xdel
clf()
20
Z
t=[0:0.1:8*%pi];
15
10
param3d(cos(t),sin(t),t)
5
01
X
-1
0
0
-1 1
Y
Wie schon in Kapitel 9.2 beschrieben, wird Scilab eine Fehlermeldung
ausgeben, wenn man z.B. param3d(sin(t),cos(t),t*t) eingeben würde,
denn dies würde bedeuten, dass zwei (Zeilen-) Vektoren miteinander multipliziert werden müssten. Abhilfe kann man mit der Scilab-Funktion feval()
schaffen, welche eine (zuvor definierte) Scilab-Funktion f an den Stellen
t(j), wobei j=1,...,length(t) evaluiert. Das Ergebnis ist also ein Vektor
der gleichen Länge wie t.
Es können auch noch andere Probleme auftreten: So ergibt z.B. die Multiplikation 1/t*cos(t), wobei t=[0:0.1:5], eine Matrix, denn aus dem Zeilenvektor t macht Scilab einen Spaltenvektor 1/t. Multiplikation mit einem
Zeilenvektor ergibt dann eine Matrix.
Daher ist das oben beschriebene Verfahren für kompliziertere Funktionen
immer sinnvoll.
Beispiel 10.5.
Wir plotten die Kurve


t cos(t)
γ(t) =  t sin(t)  ,
t
30
t ∈ [0, 50].
xdel
clf()
t=[0:0.1:50];
function x=f1(t)
x=t*cos(t);
endfunction
function y=f2(t)
y=t*sin(t);
endfunction
x=feval(t,f1);
y=feval(t,f2);
50
45
40
35
Z 30
25
20
15
10
5
0
50
-50
X
0
-50 50
param3d(x,y,t)
10.3
0
Y
Flächen im Raum
Um parametrisierte Flächen im Raum zu plotten, kann man den Befehl
plot3d2() verwenden. Dazu schreibt man die Komponenten der Funktion


x(r, s)
⃗x(r, s) =  y(r, s)  ,
r ∈ [a, b], s ∈ [c, d],
z(r, s)
als Scilab-Funktionen x,y,z und wertet diese mit dem Befehl feval(r,s,x),
etc. aus. Wie schon in Kapitel 9.6 erklärt, ist das Ergebnis jeweils eine Matrix, welche die Funktionswerte an den Stellen (r(i),s(j)) enthält. Dabei
sind r und s Vektoren, die den Intervallen [a, b] bzw. [c, d] entsprechen. Diese
sollten mit Hilfe von linspace() erstellt werden. Denn verwendet man z.B.
im Fall ϕ ∈ [−π, π] die Definition phi=[-%pi:0.05:%pi] wählt, so entsteht
in der Grafik ein Spalt bei ϕ = π. 2
2
Eine elegantere Variante ist es, die Befehle plot3d und eval3dp() zu verwenden. Diese
werden wir hier aber nicht vorstellen.
31
Beispiel 10.6.
Wir möchten die Kugeloberfläche plotten, welche als parametrisierte Fläche


sin(θ) cos(ϕ)
⃗x(ϕ, θ) =  sin(θ) sin(ϕ)  ,
ϕ ∈ [−π, π], θ ∈ [0, π]
cos(θ)
gegeben ist.
xdel
clf()
phi=linspace(-%pi,%pi,50);
theta=linspace(0,%pi,50);
function u=x(phi,theta)
u=sin(theta)*cos(phi);
endfunction
function v=y(phi,theta)
v=sin(phi)*sin(theta);
endfunction
function w=z(phi,theta)
w=cos(theta);
endfunction
U=feval(phi,theta,x);
V=feval(phi,theta,y);
W=feval(phi,theta,z);
plot3d2(U,V,W)
32
11
Integration
11.1
Integration-1D
Ist
f : [a, b] →
R
eine stetige Funktion, so kann man mit dem Befehl intg(a,b,f) näherungsweise das Integral von f auf dem Intervall [a, b] berechnen. Dazu muss man
f als Scilab-Funktion schreiben.
Beispiel 11.1.
Sei
x ∈ [0, 2].
f (x) = x2 ,
Per Hand ausgerechnet ergibt das gesuchte Integral den Wert 8/3. Mit Scilab
geht das so:
function y=f(x)
y=x^ 2
endfunction
intg(0,2,f)
Das Ergebnis mit Scilab ist 2.6666667, also näherungsweise 8/3.
11.2
Integration-2D
R
Für Integrale auf einem Rechteck [a, b] × [c, d] ⊂ 2 gibt es bei Scilab den
Befehl int2d(X,Y). Dazu muss man das Rechteck zunächst in 2 Teildreiecke3
zerlegen. Die Matrizen X und Y enthalten dabei die x- und y-Koordinaten
der Eckpunkte der Dreiecke und sind vom Format 3 × 2.
Besondere Vorsicht ist allerdings bei uneigentlichen Integralen geboten.
Hier kann das Ergebnis sehr ungenau werden. Mehr Informationen zu diesem
Befehl und dessen weiteren Parametern erhalten Sie im Hilfe Browser (help
int2d).
3
Das Rechteck kann auch in n > 2 Dreiecke zerteilt werden; dann sind die Matrizen X
und Y vom Format 3×n. Eine Unterteilung in mehr als 2 Dreiecke kann notwendig werden,
wenn das Gebiet, über welches man integriert, kein Rechteck sondern zum Beispiel ein
Fünfeck ist.
33
Beispiel 11.2.
Sei
(x, y) ∈ [0, π] × [0, π].
f (x, y) = cos(x + y),
function z=f(x,y)
z=cos(x+y)
endfunction
3.5
X=[0 0
%pi %pi
%pi 0];
3.0
Y=[0 0
0 %pi
%pi %pi];
1.5
1.0
int2d(X,Y,f)
2.5
2.0
0.5
0.00
1.17
2.33
3.50
Eine andere Möglichkeit, so ein Integral zu berechnen ist, das Doppelintegral auf zwei Einfachfachintegrale zurückzuführen. Dies wird hier allerdings
nicht beschrieben sondern Teil einer Hausaufgabe sein. Diese Vorgehensweise
ist auch sinnvoll, wenn der Bereich B, auf welchem die Funktion f integriert
werden soll, nicht in Teildreiecke zerlegbar ist, aber von der Form
B = {(x, y) ∈
R2 | a ≤ b ≤ x, α(x) ≤ y ≤ β(x)}
B = {(x, y) ∈
R2 | a ≤ b ≤ y, α(y) ≤ x ≤ β(y)}
bzw.
ist.
34