Tutorial: GNU Octave und Gnuplot

TECHNISCHE
UNIVERSITÄT
MÜNCHEN
Tutorial: GNU Octave und Gnuplot
Angewandte
Mechanik
Robert Huber, Jan Clauberg
Prof. Dr.- Ing. habil.
Hei n z Ul b r i c h
22. Oktober 2008
Inhaltsverzeichnis
1 Grundlagen
1.1 Was ist Octave? . . . . . . . . . . . . . . . . . . . .
1.2 Sinn dieses Tutorials . . . . . . . . . . . . . . . . .
1.3 Allgemeine Befehle und Konventionen . . . . . . .
1.4 Interaktive Eingabe, Funktions- und Skriptdateien
1.5 Umgang mit Variablen und Operatoren . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
2
2
2
2
2
3
2 Vektoren und Matrizen
2.1 Definition von Vektoren . . . . . . . . . . . . . . .
2.2 Definition von Matrizen . . . . . . . . . . . . . . .
2.3 Zugriffsmöglichkeiten auf Matrizen . . . . . . . . .
2.4 Erzeugung von Submatrizen . . . . . . . . . . . . .
2.5 Elementweises rechnen mit Matrizen und Vektoren
2.6 Spezielle Matrizen erzeugen . . . . . . . . . . . . .
2.7 Weitere Matrixoperationen . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
3
3
4
4
5
5
6
6
3 Lineare Systeme
3.1 Lösen von linearen Gleichungssystemen . . . . . . . . . . . . . . . . . . . . . . . . .
3.2 Weitere Funktionen und Eigenwertberechnung . . . . . . . . . . . . . . . . . . . . . .
6
6
6
4 Funktionen in Octave
4.1 Definiton und Aufruf von Funktionen . . . . . .
4.2 Kontrollstrukturen in Octave . . . . . . . . . .
4.2.1 FOR und WHILE . . . . . . . . . . . .
4.2.2 Verzweigungen mittels IF und SWITCH
4.2.3 Verschachtelung von Funktionen . . . .
4.2.4 globale Variablen . . . . . . . . . . . . .
4.2.5 Speichern, Einlesen und Ausgabe . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
7
7
7
7
8
9
9
10
5 Grafische Ausgabe
5.1 2 dimensionale graphische Ausgabe .
5.1.1 Der plot-Befehl . . . . . . . .
5.1.2 Parameter für den Befehl plot
5.2 3 dimensionale Ausgabe . . . . . . .
5.3 Graphen speichern . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
10
10
10
11
12
13
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
6 Differentialgleichungen
13
6.1 DGL 1. Ordnung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
6.2 DGL 2. Ordnung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
6.3 DGL-System 2. Ordnung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
1
1
Grundlagen
1.1
Was ist Octave?
Octave ist eine Scriptsprache zur numerischen Lösung mathematischer Probleme, wie z.B. Gleichungssysteme und Differentialgleichungen. Zur Plotausgabe verwendet Octave Gnuplot, welches
in der Octaveinstallation beinhaltet ist.
Das Programm ähnelt stark dem kommerziellen Programm Matlab, sodass man problemos beide
Programme verwenden kann, ohne neue Befehle zu lernen.
1.2
Sinn dieses Tutorials
Dieses Tutorial soll eine kleine Einführung in das Arbeiten mit Octave und Gnuplot darstellen.
Anhand von Beispielen wird die Handhabung Schritt für Schritt erläutert. Eingaben in Octave
werden folgendermaßen dargestellt:
>> Eingabe
Ausgaben werden folgendermaßen dargestellt:
Ausgabe
1.3
Allgemeine Befehle und Konventionen
• help listet alle Befehle und internen Variablen auf
• help name gibt Hilfe zu der Variablen oder zu dem Befehl name aus
• ; trennt mehrere Befehle in einer Zeile und unterdrückt die Ausgabe von Werten
• , trennt mehrere Befehle in einer Zeile, unterdrückt die Ausgabe von Werten jedoch nicht
• ... am Zeilenende bedeutet, dass der Befehl in der nächsten Zeile fortgeführt wird
• Octave unterscheidet zwischen Groß- und Kleinschreibung
• % leitet einen Kommentar ein
• who zeigt alle definierten Variablen und Funktionen an
• whos zeigt alle definierten Variablen und Funktionen mit näheren Informationen an
• type name gibt die Variable oder Funktion name aus
• clear name löscht die Variable oder Funktion name
• clear all löscht alle Variablen und Funktionen
1.4
Interaktive Eingabe, Funktions- und Skriptdateien
Ocatve bietet zwei Möglichkeiten Befehle entgegenzunehmen.
Befehle können direkt in das Octave-Fenster eingegeben werden, wie z.B.
>> a = 2+3
a = 5
Befehle können jedoch auch als Skriptdatei abgespeichert werden. Die Skriptdatei muss dabei die
Dateierweiterung .m besitzen. In Octave kann diese Skriptdatei dann einfach durch Eingabe des
Dateinamen (ohne die Erweiterung) ausgeführt werden.
2
Für eine Funktionsdatei erstellt man mit einem text Editor eine Datei und speichert sie als Funktion.m ab. Funktion stellt den Namen der Funktion dar. Die Datei sollte genauso benannt werden
wie die Funktion in der Datei. Aufgerufen wird die Funktionsdatei ebenfalls über diesen Namen.
Gespeichert wird die Datei im Arbeitsverzeichnis von Octave (Voreinstellung: \Octave files).
Beispiel:
Folgende Funktion ist in einer Datei mit dem Namen Fun1.m gespeichert:
function y = Fun1(x)
y=x∧2; end
Nun kann man die Funktion in Octave z.B. mit dem Wert 3 aufrufen. Das Ergebnis der Funktion
speichern wir in der Variable a:
>> a=Fun1(3)
a = 9
Selbstverständlich kann man die Funktion auch durch die Eingabe
>> Fun1(3)
aufrufen. Der Wert wird dann in die Variable ans gespeichert, in der immer das letzte errechnete
Ergebnis gespeichert ist.
ans = 9
Alternativ zur Speicherung als *.m-File kann der Code zur Definition einer Funktion auch direkt
in das Octave-Fenster eingegeben werden.
1.5
Umgang mit Variablen und Operatoren
• variable = wert weist der Variablen variable den Wert wert zu.
• Octave kennt eine große Anzahl an Standardfunktionen und Operatoren wie cos, sin, +, -, *,
/, ∧ , exp, acos, asin, atan, usw.
2
Vektoren und Matrizen
2.1
Definition von Vektoren
Vektoren lassen sich in Octave auf drei verschiedene Weisen eingeben.
1. Als Zeilenvektor: ~v = (1, 2, 3)
>> v=[1,2,3] oder v=[1 2 3]
v = 1 2 3


1
2. Als Spaltenvektor: ~v =  2 
3
>> v=[1;2;3]
1
v= 2
3
Ein Spaltenvektor kann problemlos in einen Zeilenvektor und ein Zeilenvektor problemlos in
3
einen Spaltenvektor umgewandelt werden. Dazu verwendet man den Post-Operator ’ in Octave (bei komplexen Vektoren erzeugt der Operator den konjugiert komplexen transponierten
Vektor):
>> u = v’
u = 1 2 3
3. Octave kann auch automatisch einen Vektor mit einem bestimmten Inkrement erzeugen: v =
[Anfangswert:Inkrement:Endwert]
>> v = [1:0.1:2]
v = 1 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 2.0
2.2
Definition von Matrizen
Matrizen lassen sich wie folgt eingeben:


1 2 3
Beispiel: A =  4 5 6 
7 8 9
>> A =
1
A = 4
7
[1
2
5
8
2 3; 4 5 6; 7 8 9] oder A=[1,2,3;4,5,6;7,8,9]
3
6
9
Ähnlich wie bei Spalten- und Zeilenvektoren kann man in Octave auch Matrizen mit dem PostOperator ’ transponieren (auch hier erzeugt der Operator bei komplexen Matrizen die konjugiert
komplexe transponierte Matrix).
Zum Beispiel:
>> A = [1 2; 3 4]
A =
1 2
3 4
>> B = A’
B =
1 3
2 4
Matrizen können auch aus Teilmatrizen zusammengesetzt
werden.
1 2
5 6
Zum Beispiel sollen die 2x2 Matrizen A =
und B =
zu einer 2x4 Matrix C
3 4
7 8
zussammengesetzt werden.
>> C=[A B]
A =
2.3
1 2
3 4
5 6
7 8
Zugriffsmöglichkeiten auf Matrizen
In Octave ist ebenfalls ein Zugriff auf einzelne Elemente, Zeilen oder Spalten möglich.
4
• Zugriff auf einzelne Elemente: Mit dem Befehl A(2,1) kann beispielsweise in der 2. Zeile auf
das 1. Element zugegriffen werden.
• Zugriff auf einzelne Zeilen: Mit dem Befehl A(1,:) kann beispielsweise auf die 1. Zeile der
Matrix A zugegriffen werden.
• Zugriff auf einzelne Spalten: Mit dem Befehl A(:,1) kann beispielsweise auf die 1. Spalte der
Matrix A zugegriffen werden.
Neben dem Zugriff auf einzelne Elemente, Zeilen und Spalten ist auch
 die Zuweisung
 von Elementen,
1 2 3
Zeilen und Spalten möglich. Zum Beispiel soll in der Matrix A =  4 5 6  die zweite Spalte
7 8 9


11
durch den Spaltenvektor ~v =  12  ausgetauscht werden.
13
>> A = [1 2
>> v = [11;
>> A(:,2) =
1 11
A = 4 12
7 13
3; 4 5 6; 7 8 9];
12; 13];
v
3
6
9
Oder auf direktem Weg:
A(:,2) = [11; 12; 13]
2.4
Erzeugung von Submatrizen
Möchte man aus einer Matrix eine Teilmatrix entnehmen, lautet der Befehl A(a:b,c:d).
Die Funtkionsweise lässt sich gut an folgendem Beispiels erkennen:
>> A=[1 2 3 4; 5 6 7 8; 9 10 11 12];
>> B=A(2:3,3:4)
B =
2.5
7 8
11 12
Elementweises rechnen mit Matrizen und Vektoren
Neben der normalen Matrizen- und Vektorenrechnung kann Octave auch komponentenweise auf
Vektoren und Matrizen zugreifen.
kann
man
Den Unterschied
gut an folgendem Beispiel sehen: Es
1 2
5 6
seien die beiden Matrizen A =
und B =
gegeben.
3 4
7 8
Nun führt man die Multiplikation der Matrizen erst normal und dann komponentenweise durch.
>> A*B
19 22
A =
43 55
Es wurde wie man sieht eine normale Matrix/Matrix-Multipliaktion ausgeführt, also Zeile x Spalte.
Nun führt man die Multiplikation komponentenweise durch. Dazu setzt man einen Punkt vor den
Operator. Hier also .*
>> A.*B
5
A =
5 12
21 32
Nun wurde offensichtlich jedes Element der Matrix A mit dem selben Element von der Matrix B
multipliziert.
2.6
Spezielle Matrizen erzeugen
Für die Erzeugung einiger spezieller Matrizen bietet Octave bereits Befehle.
• ones(m,n) erzeugt eine Matrix der Dimension m x n mit Einsen
• zeros(m,n) erzeugt eine Matrix der Dimension m x n mit Nullen
• eye(m,n) erzeugt eine Matrix mit Einsen auf der Hauptdiagonalen. Im Falle von m=n ergibt
sich dabei die Einheitsmatrix.
2.7
Weitere Matrixoperationen
• diag(A) erzeugt aus den Elementen der Diagonale der Matrix A einen Spaltenvektor
• diag(v) erzeugt aus den Elementen des Vektors v eine quadratische Diagonalmatrix
• A(i,:) = [] löscht die i-te Zeile aus der Matrix A
• A(:,i) = [] löscht die i-te Spalte aus der Matrix A
3
Lineare Systeme
3.1
Lösen von linearen Gleichungssystemen
Eine elementare Funktion in Octave ist die Lösung von linearen Gleichungssystemen.
Der Befehl zur Lösung ist A\b. Octave löst das Gleichnungssystem mittels Gaußelimination. Falls
die Matrix nicht quadratisch ist, gibt Octave keine Fehlermeldung aus, sondern löst das zugehörige
Ausgleichsproblem mittels dem Prinzip der kleinsten Fehlerquadrate.
5 12
5
Als Beispiel soll das lineare Gleichungssystem
· ~x =
gelöst werden.
21 32
6
>> x = A\b
x =
3.2
−4.00000
−4.50000
Weitere Funktionen und Eigenwertberechnung
• inv(A) berechnet die Inverese Matrix von A
• eig(A) berechnet die Eigenwerte von A
• svd(A) berechnet die Singulärwerte von A
• [V,D] = eig(A) berechnet eine Diagonalmatrix D, die die Eigenwerte von A enthält und eine
Matrix V, die die zugehörigen Eigenvektoren enthält.
6
4
Funktionen in Octave
Wie bereits im Abschnitt 1.4 erläutert schreibt man Funktion in einem beliebigen Editor und
speichert sie dann als .m File. Wichtig im Vergleich zu Matlab ist, dass man in Octave in einem
.m-File auch mehrere Funktionen schreiben kann. Um jedoch eine gute Übersichtlichkeit und die
Kompatibilität zu Matlab zu gewährleisten, ist es ratsam, pro .m-File nur eine Funktion zu schreiben
und das File nach der Funktion zu benennen
Um erweiterte Funktionen schreiben zu können, sind Kontrollstrukturen von essentieller Bedeutung.
Die wichtigsten werden im Folgenden näher erläutert.
4.1
Definiton und Aufruf von Funktionen
Die Definition und der Aufruf von Funktionen lehnt sich stark an die Syntax von C an.
Als Beispiel wollen wir eine Funktion (stupid addition) definieren, die 3 Eingabewerte und 2 Ausgabewerte hat:
function [out1,out2] = stupid addition(x,y,z)
out1 = x;
out2 = x+y;
out3 = x+y+z;
end
Aufgerufen wird die Funktion mit folgendem Befehl, dabei werden die Werte 1,2,3 übergeben:
>> [erg1, erg2] = stupid addition(1,2,3)
erg1 = 1
erg2 = 3
Alternativ lässt sich in Octave eine Funktion auch mit dem Befehl feval(@Funktionsname, arg1,
arg2, ...) aufrufen. Dabei wird die Funktion mit @ übergeben. In unserem Beispiel also:
[erg1, erg2] = feval(@stupid addition,1,2,3)
erg1 = 1
erg2 = 3
4.2
Kontrollstrukturen in Octave
Ähnlich wie in den meisten Programmiersprachen kann man auch in Octave Kontrollstrukturen
programmieren. Zu ihnen gehören die Anweisungen ’FOR’, ’IF’ und ’WHILE’.
Die dazu meist benötigten grundlegenden logischen Operatoren sind:
<
==
∼
4.2.1
kleiner
gleich
nicht
>
<>
größer
ungleich
<=
&
kleiner gleich
und
>=
|
größer gleich
oder
FOR und WHILE
Mit diesen beiden Strukturen kann man Algorythmen eine bestimme Anzahl lang durchlaufen
lassen. Die Funktionsweise wird an folgendem Beispiel schnell deutlich:
Die Funktion soll alle Zahlen von 1 bis n addieren und zurückgeben. Als Eingabe erhält sie den
Wert des Parameters n.
7
function y = Addi(n)
y=0
for i=1:n
y=y+i;
end
>> Addi(3)
ans = 6
Wie man sieht wurde die Addition ans = 1 + 2 + 3 = 6 durchgeführt.
Die gleiche Funktion kann auch mittels der WHILE-Schleife programmiert werden:
function y = Addi(n)
y=0
i=0
while i<(n+1)
y=y+i;
i=i+1;
end
4.2.2
Verzweigungen mittels IF und SWITCH
Mittels dieser beiden Strukturen lassen sich Verzweigungen in Octave programmieren. Die Funktionsweise lässt sich auch hier wiederum am besten anhand zweier Beispiele erkennen:
Die Funktion soll entscheiden, ob der übergebene Parameter n gleich 6 oder ungleich 6 ist und dies
ausgeben.
function Ents(n)
if n==6
printf(’Der Parameter n hat den Wert 6’);
else
printf(’Der Parameter n hat einen Wert verschieden von 6’);
end
>> Ents(5)
Der Parameter n hat einen Wert verschieden von 6
Eine Erweiterung dieser Funktion wäre, dass die Funktion prüft, ob der Parameter n gleich 4,5,6
oder anderswertig ist. Diese Aufgabe lässt sich mit Hilfe der SWITCH Anweisung programmieren.
8
function Ents(n)
switch n
case 4;
printf(’Der
case 5;
printf(’Der
case 6;
printf(’Der
otherwise
printf(’Der
end
Parameter n hat den Wert 4’);
Parameter n hat den Wert 5’);
Parameter n hat den Wert 6’);
Parameter n hat einen Wert ungleich 4,5,6’);
>> Ents(4)
Der Parameter hat den Wert 4
4.2.3
Verschachtelung von Funktionen
In Octave lassen sich wie auch in anderen Programmiersprachen Funktionen verschachteln. Man
kann dies an den bereits verwendeten Funktionen zeigen. Mit der Anweisung >> Ents(Addi(3))
wird als erstes die Funktion Addi aufgerufen und 1,2 und 3 addiert und daraufhin geprüft, ob das
Ergebnis 4,5,6 oder anderswertig ist.
>> Ents(Addi(3))
Der Parameter hat den Wert 6
4.2.4
globale Variablen
Variablen, die in Funktionen verwendet werden sind lokale Variablen, d.h. sie sind nur innerhalb
der Funktion (z.B. innerhalb eines .m Files) verfügbar, aber nicht in Octave selbst. Wenn diese
Variablen jedoch auch nach der Ausführung der Funktion in Octave zur Verfügung stehen sollen,
dann müssen sie global definiert werden:
global Variable
Die Funktionsweise sieht man an folgendem Beispiel: Die Variable z wird in Octave global definiert
und soll mit der Funktion manipulate geändert werden. Die Funktion manipulate bekommt einen
Faktor übergeben, mit dem sie die globale Variable multiplizieren soll. Dazu ist es notwendig sowohl
in der Hauptfunktion (hier Octave), als auch in der Funktion manipulate die Variable z global zu
definieren.
Die Funktion manipulate:
function manipulate(x)
global z;
z=z*x;
Nun kann man in Octave ebenfalls die Variable z global definieren und einen Wert zuweisen: >>
global z >> z=5
Nun ruft man die Funktion manipulate mit dem Multiplikator 5 auf:
>> manipulate(5)
>> z
9
z=25
Man sieht also, dass die Funktion den Wert von z geändert hat, obwohl die Funktion an sich keinen
Rückgabevariable besitzt.
4.2.5
Speichern, Einlesen und Ausgabe
• Mit dem Befehl save(’Filename’, ’varname1’ [,’varname2’,’var2’]) wird die Variable
varname1 in die Datei Filename gespeichert.
• Möchte man die Variable wieder laden, lautet der Befehl load(’Filename’)
• Möchte man eine Ausgabe auf mehr Nachkommastellen, so lautet der Befehl format long,
möchte man weniger Nachkommastellen format short
• Die Ausgabe von Text und Variablen lehnt sich stark an die Syntax von C an.
Möchte man beispielsweise den Wert der Variable x (=25) als Satz ausgeben: ”Der Wert von
x ist 25”, dann lautet der Befehl:
>> fprintf(’Der Wert von x ist %g’, x)
Der Wert von x ist 25
Beispiel zum Speichern: Positions-File
Möchte man beispielweise die Position eines Körpers (nur x-Koordinate) zu verschiedenen Zeitpunkten t in einem pos.-File speichern, so würde der Befehl folgend lauten:
>> pos = [x t] (wobei x und t Spaltenvektoren sind)
>> save(’-ascii’,’0001.pos’,’pos’)
5
Grafische Ausgabe
Für die graphische Ausgabe verwendet Octave Gnuplot, das automatisch mit Octave mitinstalliert
ist.
5.1
5.1.1
2 dimensionale graphische Ausgabe
Der plot-Befehl
Der grundlegende Befehl lautet plot(x,y,options). Dabei ist x ein Vektor mit allen x-Werten, die
man plotten möchte und y ein Vektor mit den zugehörigen y-Werten. Mit Optionen können noch
zusätzlich unter anderem die Linienfarbe und die Linienart eingestellt werden.
Zum Plotten einer Funktion kann man meist auf dem selben Wege vorgehen. Als Beispiel soll die
einfache Funktion y = x2 geplotet werden.
1. Man erstellt einen Vektor mit der Anzahl an x-Werten, die man in seinem Plot haben möchte.
In unserem Beispiel sollen die x-Werte von -10 bis 10 gehen, in einer Schrittweite von 0.1
Durch den Befehl length(x) kann man sich anzeigen lassen, wieviele Elemente der Vektor
10
hat, in unserem Fall 201.
>> x=[-10:0.1:10]
2. Nun muss man die zugehörigen Funktionswerte im Vektor y abspeichern. Besonders wichtig
ist hierbei, dass die Rechenoperation elementweise ablaufen muss, denn es handelt sich hierbei
ja um keine Matrix-/Vektor-Rechnung. Die Funktion kann selbstverständlich auch in einem
separaten m-File erstellt werden.
>> y=x.∧2
3. Nun kann man die Funktion mit plot plotten.
>> plot(x,y)
5.1.2
Parameter für den Befehl plot
• Einen Titel erzeugen: title(string)
• Beschriftung der x-Achse: xlabel(string)
• Beschriftung der y-Achse: ylabel(string)
• Zahlenbereich der Achsen: axis(v) mit v=[xmin, xmax, ymin, ymax, zmin, zmax]
• Gitternetz erzeugen: grid
• Graph neu berechnen: replot
• Alte Grafik löschen oder nicht: hold (wenn alte Grafik nicht gelöscht werden soll)
• plot(x,y,”b*”): erzeugt einen blauen Graphen aus Sternchen.
Diese Parameter können wir auf unser Beispiel anwenden:
11
plot(x,y,"b*")
title("Parabel")
xlabel("x-Werte")
ylabel("y-Werte")
grid
axis([-15,15,-5,150])
replot
5.2
3 dimensionale Ausgabe
Die Funktion [xx,yy]=meshgrid(x,y) erzeugt in Octave aus den Vektoren x und y Gitterdaten,
auf deren Basis dann die zugehörigen z-Werte berechnet werden müssen. Daraufhin werden die
Daten mit dem Befehl mesh(x,y,z)als 3-dimensionale Grafik dargestellt.
Als Beispiel soll ein Gitter für x = [-1,1] und y = [-2,2] erzeugt werden und darauf die Funktion
z = sin(x2 + 2 ∗ y 2 ) dargestellt werden:
>> x = -1:0.1:1
>> y = -2:0.1:2
>> [xx,yy]=meshgrid(x,y)
>> z = sin(xx.∧2+2*yy.∧2)
mesh(x,y,z)
Der Plot sieht dann folgendermaßen aus:
12
5.3
Graphen speichern
In Octave geplottete Grafiken lassen sich durch folgenden Befehl speichern:
print(’Name.eps’,’-deps’)
Speichert den aktuellen Plot in das Arbeitsverzeichnis von Octave.
6
Differentialgleichungen
Eine der wichtigsten Funktionen von Octave ist das Lösen von Differentialgleichungen. Dazu verwendet man meist den Integrator lsode (in Matlab werden meistens die Integratoren ode23 und
ode45 verwendet, die ebenfalls auf einer Runge-Kutta-Methode basieren).
Allgemein versteht man unter einer Differentialgleichung eine Gleichung, in der auch die Ableitungen derselben Funktion vorkommen.
Der Integrator lsode kann Gleichungen der Form
dx
dt
= f (x, t)
lösen mit der Anfangsbedingung:
x(t0 ) = x0
Gelöst werden prinzipiell nur Differentialgleichung oder Differentialgleichungssysteme 1. Ordnung.
Eine Beispiel für den Aufruf des Integrators lsode wäre:
>> x = lsode(’DGL’,x0,t)
Mit DGL wird dem Integrator die zu lösenden Differentialgleichung übergeben. DGL ist eine Octave Funktion, die die rechte Seite f (x, t) der Differentialgleichungen berechnet. x0 stellt den Anfangswert dar. Im Vektor t sind die diskreten Zeitpunkte, an denen die DGL gelöst werden soll
enthalten. Möchte man die Lösung auf dem Intervall [0;10] generieren, so hat man prinzipiell zwei
Möglichkeiten den Vektor t zu erstellen:
• Durch ein bestimmtes Inkrement: t=[0:0.1:10]
• Durch eine bestimmte Länge (Anzahl der Elemente) des Vektors: t=linspace(0,10,50)
Hier wird ein Vektor mit 50 Elementen erstellt.
Die Zeilen von x enthalten die berechneten Lösungen des Anfangswertproblems.
13
6.1
DGL 1. Ordnung
Als erstes Beispiel soll eine DGL 1. Ordnung mit Anfangswert betrachtet werden, die im Intervall
[0;10] gelöst werden soll.
Exponentielles Wachstum wird durch die DGL ẋ = x beschrieben.
Betrachtet wird das Anfangswertproblem mit x(to ) = x0 = 0.1
Zuerst erstellen wir eine Octave Funktion der DGL, die im nächsten Schritt dem Integrator lsode
übergeben werden kann.
function dx = EXP DGL(x,t)
dx = x;
Nun können wir die Differentialgleichung EXP DGL dem Integrator lsode übergeben. Als Intervall
für t verwenden wir [0,10] mit einem Inkrement von 0.1 .
>> t=[0:0.1:10]
>> x = lsode (’EXP DGL’,0.1,t)
Das nun im Vektor x gespeicherte Ergebnis der numerischen Lösung können wir als Plot darstellen:
>> plot(t,x)
Zusätzlich lässt sich mit Octave problemlos das Richtungsfeld der Differentialgleichung plotten:
function Richtungsfeld
x=0:0.5:5;
t=0:0.25:5;
for k=1:length(x)
for l=1:length(t)
DX(k,l)=EXP DGL(x(k),t(l));
DT(k,l)=1;
end
end
quiver(t,x,DT,DX);
14
6.2
DGL 2. Ordnung
Ähnlich wie im ersten Beispiel lassen sich auch Differentialgleichungen höherer Ordnung lösen. Als
Beispiel soll folgende DGL dienen:
ẍ +
M
L ẋ
+ 5x = 0
mit Anfangswerten x0 = 1 und ẋ0 = 1
Da Octave nur DGLs in der Form ẋ = f (x) verarbeiten kann, muss die DGL als System 1. Ordnung
geschrieben werden.
Es sei
x
~z =
ẋ
Daraus folgt das Gleichungssystem:
ż1 = z2
ż2 = − M
L z2 − 5z1
Dieses System muss nun in eine Octave Funktion implementiert werden:
function dz = DGL2(z,t)
M = 2;
L = 10;
dz = zeros(2,1);
dz(1) = z(2);
dz(2) = -(M/L)*z(2)-5*z(1);
Wie im ersten Beispiel kann die Funktion nun dem Integrator lsode übergeben und daraufhin der
zeitliche Verlauf der Ortskoordinate x = z1 geplottet werden:
15
>> t=linspace(0,1,100)
>> z = lsode(’DGL2’,[1;1],t)
>> plot(t,z(:,1))
Der Befehl >> plot(t,z(:,2)) zeigt den zeitlichen Verlauf der Geschwindikgeit ẋ = z2
Das Phasendiagramm kann wie folgt dargestellt werden:
>> plot(z(:,1),z(:,2))
16
6.3
DGL-System 2. Ordnung
1 2 ~
0 3 ~
1 0
Die Lösung eines System wie z.B.
ẍ +
ẋ +
~x = 0
3 4
8 7
0 5
| {z }
| {z }
| {z }
M
D
K
erfolgt in Analogie zum vorherigen Beispiel, der einzigste Unterschied ist nun, dass ~x und ~ẋ Vektoren sind.
Man setzt wiederum:


x1
 x2 

~z = 
 ẋ1 
ẋ2
Da nun ~x = [x1 ; x2 ] und ẋ = [ẋ1 ; ẋ2 ] aus jeweils zwei Komponenten bestehen, hat der Zustandsvektor ~z die Dimension 4.
Dies ergibt folgende Octave Funktion der DGL:
function dz = DGL3(z,t)
M
R
K
M
=
=
=
1
[1 2; 3 4];
[0 3; 8 7];
[1 0; 0 5];
= inv(M);
dz = zeros(4,1);
dz(1) = z(3);
dz(2) = z(4);
dz(3:4,1) = -M 1*R*z(3:4,1)-M 1*K*z(1:2,1);
>> t=linspace(0,1,100)
>> z = lsode(’DGL3’,[1,1,1,1],t)
>> plot(t,z(:,1)
17
7
Anhang - Linux-Befehlsreferenz
Terminal öffnen
In das home-Verzeichnis wechseln; Dieser Verzeichnis entspricht
/usr/users/laplace/praktXX (Achtung das Trennzeichen ist /)
In das Unterverzeichnis dir1 wechseln
In das Unterverzeichnis dir1/dir2 wechseln (Achtung das Trennzeichen ist /)
Verzeichnis newdir erstellen
Datei delme.txt löschen
Verzeichnis deldir mit allen Unterverzeichnissen und Dateien
löschen
Text-Editor starten
Octave starten; Zum Ausführen eines Octave-Skripts einfach den
Dateinamen des Skripts ohne .m eingeben
AMVis starten; AMVis sucht die Eingabedaten im aktuellen
Verzeichnis
MBSim starten und unter Verwendung von integrator.xml das
Modell test.xml simulieren
Dymola starten
Simpack starten
Passwort ändern; Altes Passwort eingeben, dann zweimal das neue
Passwort eingeben; Das Passwort wird nicht angezeigt, auch nicht
als ****; Das neue Passwort muss mindestens 8 Zeichen besitzen,
mindestens 1 Kleinbuchstabe, mindestens ein Großbuchstabe und
mindestens eine Ziffer!
firefox (Internet Browser) starten
18
Im Menü auf Terminal,
XTerm, Konsole, ... klicken
cd
cd dir1
cd dir1/dir2
mkdir newdir
rm delme.txt
rm -rf deldir
gedit
octave
amvis
mbsimxml integrator.xml
test.xml
dymola
simpack
passwd
firefox