Sie sind auf Seite 1von 34

Scilab-Skript

Maria Magdalena Nafalska


WS 09/10

Inhaltsverzeichnis

1 Uber
dieses Skript

2 Einfu
hrung

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 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 Grasche Darstellung - 2D
9.1 Polygon (-z
uge) . . . . . .
9.2 Funktionsgraphen . . . . .
9.3 m n - Grak - Matrix .
9.4 2D-Kurven . . . . . . . .
9.5 Hohenlinien . . . . . . . .
9.6 2D-Vektorfelder . . . . . .
9.7 Flachen in der Ebene . . .
10 Grasche Darstellung 10.1 Funktionsgraphen . .
10.2 3D-Kurven . . . . .
10.3 Flachen 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

Uber
dieses Skript

Dieses kurze Scilab-Skript ist f


ur die TeilnehmerInnen der Analysis I und II

f
ur Ingenieure gedacht und soll einen Uberblick
u
ber die in diesen beiden
Kursen benotigten Scilab-Befehle geben. Derzeit beinhaltet es noch nicht
das Thema Integration, dies wird aber entsprechend dem Vorlesungssto
erganzt.
Fehler und Verbesserungsvorschlage bitte an nafalska@math.tu-berlin.de
schicken.

Einfu
hrung

Scilab ist eine Programmierumgebung zur numerischen und graschen Bearbeitung von mathematischen Aufgabenstellungen. Zudem ist sie kostenfrei,
also eine gute Alternative zu MATLAB, denn Funktionalitat und Syntax
sind sehr ahnlich.
MATLAB wird in Industrie und an Hochschulen f
ur numerische Simulationen, Datenerfassung, Datenanalyse und -auswertung eingesetzt und ist
somit praxisrelevant f
ur den Ingenieursberuf.
Die Software erhalten Sie kostenlos unter http://www.scilab.org. Wenn
Sie das Betriebssystem Windows haben, dann wahlen Sie den Scilab 5.1.1
Installer in der 32 bzw. 64 Bits Version aus. Welche Version sie benotigen,
erfahren Sie, indem Sie sich folgendermaen durchklicken: Start Systemsteuerung System und Wartung System Systemtyp
Bei anderen Betriebssystemen bitte gogglen.

3
3.1

Grundlegendes
Konsole

Beim Starten des Programms Scilab onet sich die Konsole, in der man
Befehle eingeben und durch Dr
ucken der enter-Taste ausf
uhren lassen kann.
Durch Dr
ucken der Pfeiltasten (, ) kann man durch die zuvor eingetippten
Befehle navigieren.

3.2

Scipad

Mochte man ein Scilab-Programm schreiben und nicht nur einzelne Befehl
ausf
uhren lassen, so ist es sinnvoll, den Scipad zu onen (in der Konsole

oben links auf den Notizblock klicken) und den Code dort einzutippen und
abzuspeichern (File Save as).

3.3

Dateien einbinden

Mochte man eine (zuvor abgespeicherte) Datei mit Scilab ausf


uhren oder
auch einzelne Befehle, welche sich in einer bestimmten Datei benden, verwenden, so muss man diese Datei zunachst bei Scilab einbinden: man onet
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 ausschlielich Scilab-Funktionen beinhalten, verwendet man die Endung .sci.
Ein Semikolon unterdr
uckt die Ausgabe, d.h. tippt man z.B. a=1; in die
Konsole (und dr
uckt die enter-Taste), so merkt sich Scilab zwar, dass die
Variable a den Wert 1 hat, gibt dies aber nicht auf dem Bildschirm aus.
Lasst 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 onet sich ein Hilfe-Fenster, wo Sie Informationen zu
allen Scilab-Befehlen erhalten. Durch die Eingabe help plot2d kann man
sich explizit u
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
ur Schritt durch, sofern die Fehlermeldung selbst nicht eine (eindeutige) Antwort darauf liefert,
weshalb das Programm nicht das Gew
unschte leistet.

Elementare Funktionen und Operatoren

Addition, Subtraktion, Multiplikation und Division werden durch +, -, *,


/ ausgedr
uckt. Desweiteren gibt es bei Scilab elementare (vorprogrammierte) sowie auch benutzerdenierte Funktionen. Auf die letzteren gehen wir in
Kapitel 7 ein. Zu den elementaren Funktionen gehoren z.B. die Trigonometrischen Funktionen oder aber Funktionen, welche den Absolutbetrag einer
(komplexen) Zahl oder die Fakultat einer nat
urlichen Zahl berechnen. Im
Folgenden nden Sie einige elementare Funktionen:
Betrag |x| einer Zahl x: abs(x)

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
urliche Logarithmus von x > 0: log(x)
zufallig generierte reelle Zahl: rand
n! wobei n

N:

factorial(n)

Komplexe Zahlen

Scilab stellt komplexe Zahlen intern in kartesischer Form z = x + iy dar. Es


ist aber auch moglich, 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

0.16 16 ist.

5.1

Wichtige Befehle

Im Folgenden nden Sie einige wichtige Befehle im Zusammenhang mit komlexen Zahlen. Sei z :

imaginare Einheit i: %i
Realteil von z: real(z)
Imaginarteil von z: imag(z)
Konjugierte von z: conj(z)
Betrag von z: abs(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).
Mochte 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) grasch darstellt. Es ist sicher nicht perfekt, daf
ur 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. Anschieend konnen Sie sich mit dem Aufruf
imagplot(z) (in der Console) die komplexe Zahl z grasch darstellen lassen. Durch mehrfachen Aufruf mit verschiedenen Zahlen z
lassen sich
mehrere komplexe Zahlen gleichzeitig darstellen.

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 Groe
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 Grak 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 benotigt man, wenn Anweisungen wiederholt ausgef


uhrt werden
sollen. Die Schreibweise einer for-Schleife sieht folgendermaen aus:

Groen, die in der Schleife geandert werden, muss man vor Beginn
der Schleife einen Wert zuweisen!
for k=m:(m+n)
k ist eine Variable, m und n konnen Zahlen oder Variablen sein;
k=m:(m+n) bedeutet: k = m, m + 1, ..., m + n
Anweisungen, die wiederholt ausgef
uhrt werden sollen
end
Die Schleife wird nach n + 1 Durchlaufen verlassen.
Beispiel 6.1.
Wir berechnen die Geometrische Summe

xk = 1 + x + x2 + ... + xn

k=0

f
ur x =

1
2

und n = 10. Anschlieend kontrollieren wir das Ergebnis mit Hilfe


n

n+1
der Formel
xk = 1x
ur x = 1, Analysis I Skript, Beispiel 21:
1x , f
k=0

n=10;
S=0;
x=1/2;

//Initialisierung

for k=0:n
S=S+x^k;
end

//f
ur 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

6.2

if-then-else-Alternative

Diese Anweisung dient der bedingten Ausf


uhrung von alternativen Programmzweigen. Die Schreibweise daf
ur 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 Moglichkeiten:


logische Operatoren:

Vergleichsoperatoren:

&

und

oder

==

gleich

~=

ungleich

<

kleiner als

<=

kleiner oder gleich

>

groer als

>=

groer oder gleich

Beispiel 6.2.
Das folgende Programm u
uft zunachst, ob die am Anfang eingeberpr
gebene 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
oer gleich 1 aber
kleiner als 1.5.
Ist dies nicht der Fall, wird als nachstes u
uft, ob x [1.5, [ aber
berpr
x = 2. Der Fall x = 2 kann hier gar nicht mehr auftreten, denn das ware
9

schon im ersten Fall aufgefallen. Von daher konnte man diese Abfrage weglassen, falsch ist sie aber nicht. Ist x also groer als 1.5, so erscheint auf dem
Bildschirm: Fall 2.
Ist auch dies nicht erf
ullt, so wird u
uft, ob x kleiner als -1 ist, und
berpr
in diesem Fall wird x<-1 ausgegeben.
In allen anderen Fallen, 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
oer 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


uhrung einer Anweisung in
Abhangigkeit eines boolschen Ausdrucks (Aussage). Die Schreibweise daf
ur
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
ullt ist. Nach jedem Durchlauf wird gepr
uft, ob diese Bedingung
immer noch erf
ullt 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 Moglichkeiten,
die in Kapitel 6.2 aufgef
uhrt 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 erhoht, so dass
nach ge
ugend Durchlaufen 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
Hatte man in diesem Beispiel die Anweisung d=d+1; vergessen, so hatte
man eine Endlosschleife erzeugt, denn die Abbruchbedingung d f ware
nie erf
ullt gewesen. In diesem Fall kann man in der Konsole Control
abort klicken. Dies beendet die Schleife.

11

Scilab-Funktionen

Bei Scilab hat der/die BenutzerIn auch die Moglichkeit, eigene Funktionen
zu denieren. 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 Ausgabegroen sind
Befehle zur Berechnung der Ausgabegroen aus den Eingabegroen
endfunction
Im Fall von nur einer Ausgabegroe, konnen die eckigen Klammern weggelassen werden.

7.1

Einbinden einer Scilab-Funktion

Die entsprechende Datei wird mit Execute Load into Scilab (im Scipad)
eingebunden. Anschlieend 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
ochte man auf die Ausgabegroe 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
auisten, z.B. [r,phi]=polar(%i+1). Dabei m
ussen die Namen der Variablen nicht mit denen in der Funktion denierten u
bereinstimmen; nur
Reihenfolge und Anzahl sind wichtig.
Beispiel 7.1 (1 Eingabegroe, 1 Ausgabegroe).
function [q]=quad(x)
q=x*x;
endfunction
1
Eine Funktion muss nicht unbedingt einen R
uckgabert haben: Die Funktion
imagplot() z.B. erzeugt lediglich eine Grak.

12

Aufruf z.B. mit s=quad(7). Wie schon erwahnt, muss man nicht die gleichen
Variablen wie in der Funktionsdenition verwenden. So ware auch der Aufruf
a=quad(6) moglich.
Beispiel 7.2 (2 Eingabegroen, 1 Ausgabegroe).
function [s]=summe(x,y)
s=x+y;
endfunction
Aufruf z.B. mit s=summe(2,3).
Beispiel 7.3 (2 Eingabegroen, 2 Ausgabegroen).
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 konnen auch einzelne Komponenten eingeben werden (s.u.)
Die Lange des Vektors x erhalt 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 Eintragen erzeugen wollen, so konnen 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 Lange und zum Vergleich die
Zahl e ausgeben. Wir wissen ja, dass limn an = e ist.

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
ange von a
//Ausgabe der Zahl e zum Vergleich

Matrizen

Dieses Thema schneiden wir nur sehr kurz an, da f


ur 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 erhalt 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.

Grasche Darstellung - 2D

Zunachst ein kleiner Trick: Bevor mit Scilab aufwendige Graken gezeichnet
werden, sollte man zunachst einen einfachen Plot-Befehl ausf
uhren lassen.
Durch dieses Warmlaufen konnen Programmabst
urze verhindert werden.

9.1

Polygon (-zu
ge)

Bevor gezeichnet wird, sollten alte Graken geloscht werden:


xdel
clf()

schliet alle oenen Grakfenster


loscht die bisherige Grak

Um eine zwei-dimensionale Grak (x-yGrak) zu zeichnen, m


ussen die
gew
unschten x-yPunkte in x- und y- Vektoren eingegeben werden. Das
konnte z.B. so aussehen:
x=[0 1 2 0];
y=[1 0 1 1];
Diese m
uessen stets gleich lang sein! Der Befehl plot2d(x,y) bewirkt, dass
die Punkte samt den Verbindungslinien in die x-yEbene 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 Gestantungsmoglichkeiten, wie Farbe der Linien, Achseneinstellungen, etc. gehen wir im nachsten Kapitel ein.

9.2

Funktionsgraphen

Um die Funktion f (x) = y grasch darzustellen, gibt es verschiedene Vorgehensweisen: bei elementaren Funktionen kann man die x- und die entsprechenden y-Werte als Vektoren denieren 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) deniert, 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
ussten.

16

In so einem Fall kann man f als Scilab-Funktion f() denieren 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

Diese Prozedur hatte hier mit der Denition y=x^2 umgangen werden konnen,
aber z.B. bei f (x) = xex hatte 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 empehlt sich die o. g. Vorgehensweise.
Der Aufruf von plot2d() bzw. fplot2d() erzeugt eine Grak, in welcher die plot-Punkte mit Linien verbunden werden. Dabei wird die Grak
desto genauer sein, je feiner der Vektor x ist. Man kann das Bild durch
mehrfachen Aufruf aufbauen, da die alten Graken nicht geloscht werden,
sofern man dies nicht expizit durch clf() fordert.
Eine andere Moglichkeit, die Funktion aus Beispiel 9.2 zu plotten, ware
die Scilab-Funktionen feval() und plot2d zu verwenden: Die erstgenannte
evaluiert im Fall der Eingabe von feval(x,f) eine (zuvor denierte) ScilabFunktion f an den Stellen x(j) eines Vektors x, wobei j=1,...,length(x).
Das Ergebnis ist also ein Vektor der gleichen Lange 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

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 abhangen:
Beispiel 9.4.
Wir mochten die Funktionenfamilie
fm (x) = x sin(mx),

x [6, 6],

f
ur m {1, 3, 10} plotten.

function y=f(x,m)
y=x*(sin(m*x))
endfunction

x=[-6:0.1:6];
2

m=1;
y1=feval(x,f);
m=3;
y2=feval(x,f);

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

Dabei bewirkt style=i, dass f


ur die Verbindungslinien eine bestimme
Farbe bzw. Form verwendet wird. Folgende Moglichkeiten gibt es:
i=1: schwarz, i=2: blau, i=3: gr
un, 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

werden + verwendet, i=-2: statt der Punkte werden x gezeichnet.


Manchmal ist es sinnvoll, zwei Funktionen mit verschiedenen St
utzstellen
(x-Werten) zu verwenden. Mochte man namlich von der einen Funktion nur
einige Punkte von der anderen aber den Funktionsgraphen plotten, so muss
man verschiedene x-Vektoren denieren (und auch in plot2d() u
bergeben).
Weitere Gestaltungsmoglichkeiten bietet der Befehl xtitle(Titel,
x-Achse,y-Achse), mit dem man die Grak, die x- und die y-Achse beschriften kann. Mit xgrid(i) kann man ein Gitter einblenden lassen, wobei i die Farbe des Gitters deniert (Farbgebung s.o.). Durch den Befehl
legend(Funktion 1, Funktion 2, ...); lasst sich eine Legende erzeugen.
All diese Befehle kann man auch im Zusammenhang mit fplot2d()
verwenden. Dar
uberhinaus ist es auch moglich, 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

-50

-100
-5

9.3

-4

-3

-2

-1

0
1
x-Achse

m n - Grak - Matrix

Mit Hilfe der Scilab-Funktion subplot() lasst sich eine m n - GrakMatrix erzeugen, d.h. in einem einzigen Fenster werden in m Zeilen und n
Spalten m n Graken gezeichnet. Der dritte Parameter in subplot(m,n,s)
bestimmt die Position in der Matrix.
Beispiel 9.6.
xdel
clf()

//schliet alle offenen Grafikfenster


//l
oscht 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
ur
//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


ur
//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

10

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 mochten die Kurve
(
(t) =

cos(t)
t

)
,

t [0, 6]

grasch 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

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 denierte) ScilabFunktion f an den Stellen t(j), wobei j=1,...,length(t). Das Ergebnis
ist also ein Vektor der gleichen Lange wie t.

22

Beispiel 9.8.
Wir mochten die Kurve
(
(t) =

t cos(t)
t sin(t)

)
t [0, 25]

grasch 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

15

25

plot2d(x,y)

9.5

H
ohenlinien

Die Hohenlinien Hc einer Funktion f : D 2 , (x, y) 7 f (x, y) zu


einem Niveau c sind Teilmengen des 2 , namlich

R2 | f (x, y) = c }.
Der Graph einer solchen Funktion liegt allerdings im R3 .
Hc = {(x, y) D

Zum Zeichnen von Hohenlinien 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 Hohenlinien; x und y sind
gleichlange Vektoren.
23

Beispiel 9.9.
Das folgende Programm zeichnet sieben Hohenlinien der Funktion f (x, y) =
x2 y 2 auf dem Bereich [5, 5] [5, 5]. Da diese Grakfunktion sehr zeitaufwendig ist, wahlen wir lediglich 0.5 als Schrittweiten f
ur die Vektoren.

xdel
clf()
x=[-5:0.5:5];
y=[-5:0.5:5];

-18.8
-12.5

-6.25

2
1
18.8
12.56.25

6.2512.5
18.8

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

2D-Vektorfelder

Die grasche 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 Lange k mit den x- und y-Werten und U,V kk 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
ur func jeweils die
Komponenten der Funktion f einsetzten.

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 konnen wir es grasch darstellen lassen:

xdel
clf()

10

x=[-7:7];
y=[-10:10];

function u=f1(x,y)
u=cos(x);
endfunction

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

Fl
achen in der Ebene

Um parametrisierte Flachen 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 erklart, ist das Ergebnis jeweils eine Matrix, welche die Funktionswerte an den Stellen (r(i),s(j)) enthalt. 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 Denition phi=[-%pi:0.05:%pi], so entsteht in der
Grak ein Spalt bei = .
Beispiel 9.11.
Wir mochten 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 hatte, moge den Plot-Befehl
plot2d(U,V, style=[ones(100,1)]) verwenden.

26

1.0

10

Grasche Darstellung - 3D

Beim Erstellen von 3D-Graken kann wieder der Befehl subplot() verwendet werden.
Die optionalen Parameter der einzelnen Plot-Befehle werden hier nicht
im einzelnen erortert und auch nicht zur Bearbeitung der Hausaufgaben
benotigt. Informieren Sie sich ggf. im Help-Browser dar
uber, indem Sie z.B.
help plot3d in die Konsole eingeben, siehe Kapitel 3.5.
Die in Kapitel 9.2 beschriebenen Grak-Befehle xtitle(), legend()
und xgrid() konnen aber auch in 3D-Graken eingesetzt werden.

10.1

Funktionsgraphen

Sei f : D 2 . Ahnlich
wie in Kapitel 9.2 deniert man einen Denitionsbereich, eine Scilab-Funktion f() und verwendet dann die ScilabFunktion fplot3d().
Dabei m
ussen die Vektoren, welche den Denitionsbereich charakterisieren nicht die gleiche Lange 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 Grak zu drehen (oben links im Grak-Fenster):

Beispiel 10.3.
In diesem Beispiel mochten 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 deniert ist. Dies ist aber auch der einzige kriti28

sche Punkt. Mit einem Trick lasst sie sich doch auf diesem Bereich darstellen:
Wir denieren 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 Moglichkeit ware den Denitionsbereich 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 mochten die Kurve

cos(t)
(t) = sin(t) ,
t

29

t [0, 8]

grasch darstellen. (Die folgende Grak 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
-1 1

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
urde,
denn dies w
urde bedeuten, dass zwei (Zeilen-) Vektoren miteinander multipliziert werden m
ussten. Abhilfe kann man mit der Scilab-Funktion feval()
schaen, welche eine (zuvor denierte) Scilab-Funktion f an den Stellen
t(j), wobei j=1,...,length(t) evaluiert. Das Ergebnis ist also ein Vektor
der gleichen Lange wie t.
Es konnen 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
ur 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

Fl
achen im Raum

Um parametrisierte Flachen 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 erklart, ist das Ergebnis jeweils eine Matrix, welche die Funktionswerte an den Stellen (r(i),s(j)) enthalt. 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 Denition phi=[-%pi:0.05:%pi] wahlt, so entsteht
in der Grak 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 mochten die Kugeloberache plotten, welche als parametrisierte Flache

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]

eine stetige Funktion, so kann man mit dem Befehl intg(a,b,f) naherungsweise 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 naherungsweise 8/3.

11.2

Integration-2D

F
ur Integrale auf einem Rechteck [a, b] [c, d] 2 gibt es bei Scilab den
Befehl int2d(X,Y). Dazu muss man das Rechteck zunachst 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 3n. Eine Unterteilung in mehr als 2 Dreiecke kann notwendig werden,
wenn das Gebiet, u
ber welches man integriert, kein Rechteck sondern zum Beispiel ein
F
unfeck 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 Moglichkeit, so ein Integral zu berechnen ist, das Doppelintegral auf zwei Einfachfachintegrale zur
uckzuf
uhren. 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