PDF-Druckversion - eTools

Transcription

Einführung in Matlab
Inhaltsverzeichnis
Anleitung ...................................................................................................................................................... 4
Voraussetzungen .................................................................................................................................. 7
Bedienungshinweise ............................................................................................................................. 9
Vorbereitung ........................................................................................................................................... 11
Installation von Matlab ...................................................................................................................... 12
Herunterladen der notwendigen Materialien ..................................................................................... 13
Konfiguration von Matlab ................................................................................................................. 14
Lektion 1: Grundlagen von Matlab ........................................................................................................... 17
Wozu kann man Matlab gebrauchen? ................................................................................................... 18
Einige Beispiele im Direktmodus ...................................................................................................... 20
Demonstrationsbeispiele von Matlab ................................................................................................. 23
Beispiel aus der psychologischen Forschungspraxis ......................................................................... 24
Die Benutzeroberfläche .......................................................................................................................... 26
Darstellungsmöglichkeiten des Desktops .......................................................................................... 27
Das «Command Window» ................................................................................................................. 29
Der «Workspace» ............................................................................................................................... 31
Der «Current Directory»-Browser ..................................................................................................... 33
Die «Command History» ................................................................................................................... 34
Benutzung des Hilfe-Systems ............................................................................................................ 35
Zusammenfassung .............................................................................................................................. 37
Zahlen und Variablen in Matlab ............................................................................................................ 38
Repräsentation von Zahlen ................................................................................................................ 39
Variablen ............................................................................................................................................ 40
Repräsentation von Daten 1: Skalare, Vektoren und Matrizen ............................................................. 43
Skalare ................................................................................................................................................ 44
Vektoren ............................................................................................................................................. 45
Matrizen ............................................................................................................................................. 46
Matrizenmanipulation ............................................................................................................................ 49
Matrizen zusammenfügen .................................................................................................................. 50
Vervielfältigung von Matrizen ........................................................................................................... 51
Erzeugen spezieller Matrizen ............................................................................................................. 52
Umformen von Matrizen ................................................................................................................... 53
Aufgabe 1: Erstellen einer komplexen Datenmatrix ......................................................................... 54
Mathematische Operatoren und Funktionen .......................................................................................... 57
Operatoren .......................................................................................................................................... 58
Funktionen .......................................................................................................................................... 59
Aufgabe 2: Umsetzen einer mathematischen Formel ........................................................................ 60
Aufgabe 3: Überprüfung eines magischen Quadrates ....................................................................... 61
http://etools.fernuni.ch/matlab/ - Stand vom: 20.12.2011
1
Testfragen ............................................................................................................................................... 63
Glossar .................................................................................................................................................... 65
Lektion 2: Programmieren in Matlab ........................................................................................................ 66
m-Files: Skripte und Funktionen ........................................................................................................... 67
Der Editor/Debugger .......................................................................................................................... 68
Programmieren von Skripten ............................................................................................................. 70
Aufgabe 4: Programmieren eines Skriptes ........................................................................................ 72
Programmieren von Funktionen ........................................................................................................ 74
Spezialfälle ......................................................................................................................................... 77
Programm-Kontrollstrukturen: Schleifen ............................................................................................... 80
Die for-Schleife .................................................................................................................................. 81
Die while-Schleife ............................................................................................................................. 82
Abbruch von Schleifen mit break ...................................................................................................... 83
Aufgabe 5: Gauss-Funktion für einen Vektor ................................................................................... 84
Vektorisierung von Schleifen ............................................................................................................ 85
Programm-Kontrollstrukturen: bedingte Verzweigungen ...................................................................... 87
Die Verzweigungsstruktur if-elseif-else ............................................................................................ 88
Die switch-case-Struktur .................................................................................................................... 89
Vergleichsoperatoren und logische Verknüpfungen .......................................................................... 91
Aufgabe 6: Standardisierungsfunktion .............................................................................................. 93
Repräsentation von Daten 2: Zeichenketten (Strings) ........................................................................... 95
Strings erzeugen und zusammenfügen .............................................................................................. 96
Strings untersuchen und vergleichen ................................................................................................. 97
Testfragen ............................................................................................................................................... 99
Glossar .................................................................................................................................................. 100
Lektion 3: Arbeiten mit externen Dateien ............................................................................................... 101
Datenimport .......................................................................................................................................... 102
Einlesen von Daten aus externen Dateien: interaktiv ...................................................................... 103
Einlesen von Daten aus externen Dateien: programmiert ............................................................... 104
Beispiel: Routine zum Einlesen von Daten aus externer Datei ....................................................... 106
Zusammenfassung ............................................................................................................................ 110
Repräsentation von Daten 3: Cell Arrays ............................................................................................ 111
Datenrepräsentation in Cell Arrays ................................................................................................. 112
Erzeugen und referenzieren von Cell Arrays .................................................................................. 113
Zweites Beispiel zum Einlesen von Daten aus externer Datei ........................................................ 115
Repräsentation von Daten 4: Structure Arrays .................................................................................... 117
Repräsentation von Daten in Structure Arrays ................................................................................ 118
Anwendungsbeispiel ........................................................................................................................ 119
Eigenes Datenverarbeitungsprojekt ...................................................................................................... 121
2
Datenbasis ........................................................................................................................................
Grobstruktur .....................................................................................................................................
Datensatz EyeData Processing .........................................................................................................
Aufgabe P1: Einlesen der Daten .....................................................................................................
Interaktion mit dem Benutzer ..............................................................................................................
Auswahl von Dateien und Verzeichnissen ......................................................................................
Mustercode: Alle Dateien aus Verzeichnis wählen .........................................................................
Weitere Benutzereingaben ...............................................................................................................
Aufgabe P2: Benutzereingaben .......................................................................................................
Zusammenfassung ............................................................................................................................
Schreiben von Daten in externe Dateien .............................................................................................
Grundlegende Funktionen zum Schreiben in externen Dateien ......................................................
Aufgabe P3: Daten speichern ..........................................................................................................
Glossar ..................................................................................................................................................
Lektion 4: Verarbeitung und grafische Darstellung von Daten ...............................................................
Daten selektieren: Logisches Indizieren und die «find»-Funktion ......................................................
Logische Indizierung ........................................................................................................................
Die find-Funktion .............................................................................................................................
Eine hilfreiche Funktion: subM .......................................................................................................
Grundlegende Statistikfunktionen ........................................................................................................
Deskriptivstatistik .............................................................................................................................
Korrelation und Kovarianz ..............................................................................................................
Zufallsdaten mit bestimmten Verteilungen ......................................................................................
Aufgabe P4: Projektarbeit - Verarbeitung der Daten ......................................................................
Grafikgrundlagen: Figuren und Achsensysteme ..................................................................................
Erzeugung und Manipulation von Figuren ......................................................................................
Eigenschaften von Figuren ..............................................................................................................
Achsensysteme (Axes) .....................................................................................................................
Multiple Achsensysteme ..................................................................................................................
Grafikwerkzeuge ..................................................................................................................................
Die plot-Funktion .............................................................................................................................
Balkengrafiken .................................................................................................................................
Weitere Grafik-Funktionen kurz demonstriert .................................................................................
Grafiken beschriften und erweitern .................................................................................................
Aufgabe P5: Projektarbeit - Grafische Darstellung der Daten ........................................................
Schlussbemerkungen ............................................................................................................................
122
123
124
125
128
129
132
134
136
137
138
139
141
142
143
144
145
146
147
148
149
150
151
153
154
156
157
158
159
161
162
163
164
165
166
170
172
173
177
179
180
3
Anleitung
Was wird durch dieses Lernprogramm abgedeckt?
Dieser Einführungskurs soll eine praxisnahe Einführung
in die Arbeit mit dem Programm Matlab® der Firma The MathWorks bieten, mit besonderem
Augenmerk auf die Aspekte, die für die Verarbeitung von Daten im Rahmen psychologischer
Forschungstätigkeit relevant sind. Matlab wird häufig bei Experimenten eingesetzt, die mit psychophysischen
Methoden wie Elektroenzephalographie (EEG), Augenbewegungsregistrierung (eye tracking) oder
Hautleitfähigkeitsmessungen (GSR - galvanic skin response) arbeiten. Grundsätzlich ist Matlab bei der
Auswertung grosser, häufig automatisiert erfasster Datenmengen sehr nützlich, wie dies z.B. auch bei LogfileAnalysen oder Internet-Experimenten der Fall ist.
Wozu Matlab?
Matlab ist eine Programmiersprache, die in der psychologischen Forschungstätigkeit vielseitige Anwendung
findet. Sie eignet sich besonders für die Analyse der erzielten Daten, kann aber auch für die Programmierung
computergesteuerter Experimente eingesetzt werden. Ein besonderer Vorteil ist, dass Matlab im Gegensatz zu
den meisten anderen Programmiersprachen als «Interpreter» arbeitet: Eingegebene Befehle und Programme
werden sofort ausgeführt, ohne dass man vorher in einem zusätzlichen Schritt das Programm zuerst kompilieren
muss. Auf diese Weise kann man z.B. unkompliziert ausprobieren, wie die Syntax sein muss, damit der
Rechner das tut, was man von ihm will. Die so erprobten Befehle kann man dann per «copy-and-paste» in
Programmdateien übernehmen.
Umfang dieses Lernprogramms
Matlab ist ein sehr umfassendes Programmpaket, und die meisten Anwender nutzen nur einen kleinen Teil
davon. Dank einer sehr guten integrierten Dokumentation und Hilfe-Funktion ist es aber relativ einfach, weitere
Funktionen dazuzulernen, wenn man die Grundzüge einmal verstanden hat.
In diesem Sinne beschränkt sich dieses Lehrmittel auf die Grundfunktionalität von Matlab, also Matrizenbasierte Datenverarbeitung und Visualisierung.
4
Die Funktionalität von SimuLink (Simulationsprogramm) wird nicht abgedeckt. Ebensowenig kann auf
Funktionen von spezialisierten Toolboxen (neural network toolbox, wavelet toolbox etc.) eingegangen werden,
welche im Rahmen der psychologischen Forschung kaum zur Anwendung kommen. Vielmehr soll eine Basis
vermittelt werden, von der ausgehend es möglich sein sollte, sich selbstständig weitere Kenntnisse anzueignen.
Übersicht über die Lerninhalte
•
Wozu kann man Matlab gebrauchen?
•
Arbeiten mit der Benutzeroberfläche
•
Grundlegendes: Zahlen, Datentypen, Operatoren, Funktionen etc.
•
Programmierung von Skripten und Funktionen
•
Programmkontrollstrukturen: Schleifen, Verzweigungen
•
Daten einlesen, bearbeiten und in Dateien schreiben
•
Interaktion mit dem Benutzer
•
Statistikfunktionen
•
Grafische Darstellungen
Die Lerninhalte können immer wieder direkt in kurzen Übungsaufgaben umgesetzt werden; zusätzlich stehen
Selbsttestfragen zur Verfügung, um den Lernfortschritt durch Überprüfung des Gelernten zu fördern.
Zudem erarbeiten Sie sich im Rahmen des Kurses ein etwas grösseres Programmprojekt, welches typisch
für Anwendungen in der psychologischen Forschung ist: Einlesen und Zusammenfügen von Daten aus
mehreren Datensätzen, Durchführen von Berechnungen mit diesen Daten, Abspeichern der Resultate einem
für die Weiterbearbeitung (z.B. mit SPSS oder Statistica) geeigneten Format sowie grafische Darstellung und
Visualisierung der Resultate.
Entwicklung
Dieses Lehrmittel wurde im Rahmen des Projektes edulap entwickelt.
Dr. phil. Roman von Wartburg
Inhalt, didaktisches Konzept, technische Umsetzung, Übersetzung, Animation
Sarah Steinbacher, dipl. Designerin FH
Grafisches Design
5
Radka Wittmer, M.Ed.
Beratung Mediendidaktik
Stephanie Schütze, Dipl. psych.
Beratung Usability Evaluation
Joël Fisler
Umsetzung Grafikdesign
Unterstützung
Dieses Projekt wurde durch folgende Institutionen unterstützt:
Lizenz/Copyright
«Einführung in Matlab» von Roman von Wartburg/Universitäre Fernstudien Schweiz ist unter
einer Creative Commons «Attribution/Non-Commercial/Share Alike» 2.5 Switzerland License lizenziert.
Das bedeutet, Sie dürfen das Werk vervielfältigen, verbreiten und öffentlich zugänglich machen, sowie
Bearbeitungen des Werkes anfertigen. Die Bedingungen dafür lauten: Namensnennung, keine kommerzielle
Nutzung, Weitergabe unter gleichen Bedingungen.
Weitere Informationen
Implementierung und Distribution
Dieses Tutorial wurde mit eLML umgesetzt. Der komplette eLML-Quellcode ist in den Lernpaketen enthalten,
die hier heruntergeladen werden können:
ZIP-Archiv der HTML-Version
Falls Sie keinen permanenten Internetzugang haben, können Sie dieses Archiv auf Ihre Festplatte extrahieren
und dann lokal mit Ihrem Webbrowser öffnen.
Lernpaket im IMS/CP-Format
Diese Version kann auf Lernplattformen wie OLAT, Moodle oder ILIAS verwendet werden.
6
Voraussetzungen
Vorkenntnisse
Folgende Vorkenntnisse sind für das Bearbeiten dieses Einführungskurses hilfreich:
•
•
•
Grundlegende Erfahrung in der Arbeit mit Computern ist unabdingbar. Wer es gewohnt ist, mit
Programmpaketen wir z.B. SPSS, Excel oder E-Prime zu arbeiten, sollte mit den Basics von Matlab, wie
sie in diesem Kurs gelehrt werden, keine nennenswerten Probleme haben.
Statistisch-methodisches Grundlagenwissen auf Bachelor-Niveau der Psychologie ist vor allem
hilfreich, um die praktischen Beispiele nachvollziehen zu können. Darüber hinausgehende
mathematischen Vorkenntnisse sind nicht nötig.
Vorkenntnisse in der Computerprogrammierung sind zwar sehr hilfreich, aber nicht zwingend.
Zielsetzung
Wir haben versucht, diesen Kurs so zu gestalten, dass sowohl Leute mit Programmiererfahrung als
auch EinsteigerInnen davon profitieren können. Realistisch betrachtet wird sich die Zielsetzung und das
Anspruchsniveau für diese beiden Gruppen allerdings unterscheiden.
•
•
Wer Erfahrung mit anderen modernen Programmiersprachen hat und daher bereits mit der Denkweise
und den grundlegenden Konzepten der Programmierung vertraut ist, sollte den Kurs ohne grosse
Schwierigkeiten durcharbeiten können. Damit sollte man anschliessend in der Lage sein, selbstständig
Matlab-Programme von Grund auf neu zu erstellen. Die Grundstrukturen von Matlab unterscheiden sich
nicht wesentlich von denjenigen anderer (prozeduraler) Sprachen.
Für Leute mit gar keinen oder nur rudimentären Programmierkenntnisse wird dieser Kurs relativ
anspruchsvoll sein. Wir gehen davon aus, dass diese Gruppe nach dem Kurs in der Lage ist, vorhandene
Programme zu verstehen und modifizieren zu können, oder einfache Routinen, die den im Kurs
bearbeiteten Beispielen ähnlich sind, zu schreiben.
Hard- und Software
Da dieser Kurs als wesentlichen Teil auch praktische Übungen umfasst, ist es unabdingbar, das MatlabProgrammpaket auf demselben Computer installiert zu haben. Matlab ist verfügbar für Macintosh, Windows,
verschiedene Linux-Distributionen und Solaris (UNIX-Betriebssystem, früher SunOS).
Matlab ist eine kommerzielle Software und muss käuflich erworben werden. Eine
Lizenz für Studierende wird für USD 99 von Mathworks angeboten. Von einigen
Institutionen (z.B. Universität Bern) wird Matlab für Mitarbeitende und Studierende
gratis zur Benutzung angeboten. Bitte wenden Sie sich an die Informatikabteilung Ihrer
Institution.
Die allermeisten handelsüblichen Computer, die nicht älter als 5-8 Jahre sind, haben genügend Ressourcen
für die Arbeit mit Matlab. Falls Sie im Zweifel sind, ob dies bei Ihnen der Fall ist, konsultieren Sie bitte die
Angaben von Mathworks zu den Systemvoraussetzungen.
Hinweise zur Installation von Matlab finden Sie im Abschnitt Installation.
7
Anforderung an den Web-Browser
In diesem Kurs werden gewisse Inhalte in Pop-up-Fenstern angezeigt. Damit dies möglich ist, dürfen die Popup-Fenster für die Website bzw. die Lernplattform, auf der dieser Kurs läuft, nicht gesperrt sein. Zum Test
klicken Sie hier. Wenn danach kein neues Fenster erscheint, sind Pop-up-Fenster gesperrt, und sie müssen
dies in Ihren Browser-Einstellungen korrigieren.
8
Bedienungshinweise
Der Kurs ist vom Stil her als «hands-on»-Kurs oder geführtes «learning by doing» zu verstehen: Alles, was
vermittelt wird, soll sogleich im parallel laufenden Matlab-Programm selbst ausprobiert und umgesetzt werden.
So lernt man am Effizientesten.
Alle Textbereiche, welche zu konkreten Aktivitäten mit Matlab auffordern, sind grün hinterlegt und
mit diesem Icon gekennzeichnet.
Alle Anweisungen zum Eintippen im «Command Window» von Matlab werden wie folgt dargestellt
(die Eingabeaufforderung >> muss dabei nicht eingegeben werden):
>> a = sin(2)
Erläuterungen sind in Kursivschrift notiert und werden nicht mit eingegeben:
>> 23.5 * pi
pi ist intern vordefiniert
Wichtige Informationen, Merkpunkte und Zusammenfassungen werden in einer solchen
Box angezeigt und mit dem entsprechenden Icon gekennzeichnet.
Weitere Hinweis-Icons
Bestimmte Bereiche im Text werden mit weiteren Icons markiert, die folgende Bedeutung haben:
Hinweis: Damit werden ergänzende Informationen gekennzeichnet.
Hilfe: Bezeichnet Hinweise auf weiterführende Informationen im Matlab-Hilfe-System.
Popup: Werden so gekennzeichnete Links angeklickt, öffnet sich eine Box oder ein neues Fenster mit
den Inhalten.
Besondere Schreibweisen
Matlab-Ausdrücke wie Anweisungen, Funktionen und andere Code-Bestandteile werden im Text mit folgender
Schrift hervorgehoben:
matlab_code
Aufrufe von Matlab-Menufunktionen werden wie im folgenden Beispiel notiert:
Desktop > Desktop Layout > Default
Dies entspricht also folgendem Bedienungsvorgang:
9
Weitere Features
In diesem Kurs stehen Ihnen unterstützend zwei weitere Funktionen zur Verfügung. Diese können Sie über die
zusätzlichen Menupunkte unter der Hauptnavigation (für die HTML-Version) oder über die Fusszeile (Version
in einem Learning Management System wie OLAT) aufrufen.
•
•
PDF-Version: Sie können den gesamten Kurs als PDF-Dokument herunterladen. Dieses können Sie
auch ohne Internetverbindung lesen, oder sich Teile davon ausdrucken.
Befehlsliste: Darin sind alle verwendeten Befehle aufgelistet. Diese Liste öffnet sich in einem neuen,
schmalen Fenster, das Sie neben den anderen Fenstern anordnen können.
10
Vorbereitung
Dieser Abschnitt beschreibt die vorbereitenden Schritte, die für das Bearbeiten dieses Kurses notwendig sind:
•
Installation von Matlab auf Ihrem Computer
•
Herunterladen und Ablegen der notwendigen Materialien wie Beispieldateien, Aufgaben, Materialien
und Musterlösungen
Konfiguration von Matlab
•
11
Installation von Matlab
Welche Version von Matlab brauche ich?
Die Version 7.2 / R2006a oder höher wird empfohlen; auch das Arbeiten mit älteren Versionen ist möglich,
nur können sich einige Details in der Bedienung der Benutzeroberfläche unterscheiden. Grundsätzlich ist
das Arbeiten insbesondere dank sinnvoller Erweiterungen besonders des Editors mit den neueren Versionen
bedeutend angenehmer.
Matlab muss käuflich erworben werden; für Studierende bietet Mathworks Lizenzen für USD 99 an. Von
einigen Institutionen (z.B. Universität Bern) wird Matlab für Mitarbeitende und Studierende gratis zur
Benutzung angeboten. Bitte wenden Sie sich an die Informatikabteilung Ihrer Institution.
Falls Matlab noch nicht auf Ihrem Computer installiert ist, tun Sie dies jetzt. Folgen Sie dazu den
Anleitungen des Installationsprogrammes.
Wichtig: Bei manchen Versionen von Matlab werden Sie während der Installation aufgefordert zu entscheiden,
was Sie alles installieren wollen: Das Matlab-Programm, die Dokumentation oder beides. Wählen Sie
beides, denn die Dokumentation ist ein unverzichtbares Hilfsmittel bei der Arbeit mit diesem komplexen
Programmpaket.
12
Herunterladen der notwendigen Materialien
Zur Bearbeitung dieses Kurses benötigen Sie verschiedene Dateien wie Codebeispiele, Musterlösungen oder
Datenfiles zur Erprobung selbst geschriebener Programme. Diese müssen Sie zuerst auf Ihren Computer
herunterladen.
Bitte laden Sie die benötigten Dateien, die als komprimierte ZIP-Dateien vorliegen, jetzt herunter, wie
dies im folgenden beschrieben ist:
Beispiele und Musterlösungen
Diese Programm-Dateien finden Sie in der Datei examples.zip. Bitte diese Inhalte anschliessend in ein neues
Verzeichnis entpacken , z.B. My Documents\matlab-kurs\m\ oder d:\m\. Es ist sinnvoll, sich
das Verzeichnis zu merken oder zu notieren, da wir dieses gleich anschliessend in Matlab konfigurieren müssen
(vgl. hier).
Wichtig: Dieses Verzeichnis wird auch Ihr Arbeitsverzeichnis für die selbst verfassten Programme sein.
Daten
Einige Beispiele und Übungsaufgaben benötigen Datenfiles, welche in der Datei data.zip zusammengefasst
sind. Entpacken Sie diese bitte an einen anderen Ort, z.B. My Documents\matlab-kurs\data\.
13
Konfiguration von Matlab
Einige Einstellungen sind notwendig bzw. hilfreich, um Matlab «einsatzfähig» zu machen:
•
die Einstellung des Suchpfades für die erstellten Programme
•
das Konfigurieren eines allfälligen Proxy-Servers für den Internetzugang
•
Der Tabulatorabstand des Editors kann den eigenen Wünschen angepasst werden.
Diese Schritte können Sie mit den folgenden Anleitungen nachvollziehen. Anschliessend sind Sie bereit, die
Arbeit mit Matlab zu beginnen.
Nehmen Sie folgende Einstellungen vor, falls dies nicht bereits so konfiguriert ist:
Pfadeinstellung
Matlab muss mitgeteilt werden, wo es nach Programmen suchen soll. Die Pfade für die internen/mitgelieferten
Funktionen und Toolboxen sind bereits konfiguriert, aber wir müssen dem Programm den Speicherort der selbst
erstellten Programme (die sogenannten «m-Files») mitteilen. In unserem Fall ist dies der Ort, wohin Sie die
Beispielprogramme aus der heruntergeladenen ZIP-Datei gespeichert haben (siehe Abschnitt «Materialien»,
hier). Gehen Sie wie folgt vor:
•
Menupunkt File > Set Path anwählen
•
Schaltfläche Add Folder... anklicken
•
Im Datei-Browser das entsprechende Verzeichnis suchen und anwählen, mit OK bestätigen
•
Save und Close betätigen
Die Dialogbox zur Einstellung des Pfades für m-Files
14
Proxy-Server für den Internetzugang
Für gewisse Funktionen des Hilfe-Systems ist ein Internetzugang notwendig. Falls sich Ihr Computer in einem
lokalen Netzwerk befindet, der mit einem sogenannten «Proxy-Server» arbeitet, muss dies Matlab mitgeteilt
werden. Wenden Sie sich an den Informatik-Support, wenn Sie nicht wissen, ob überhaupt ein Proxy-Server
verwendet wird, oder seine Adresse nicht kennen.Tip: Es ist die gleiche Adresse, die auch in Ihrem InternetBrowser als Proxy-Server eingestellt ist.
Diese Einstellmöglichkeiten finden Sie unter dem Menupunkt File > Preferences... (siehe untenstehende
Abbildung). Falls kein Proxy-Server vorhanden ist, entfernen Sie den Haken im Feld «Use a proxy server to
connect to the Internet». Andernfalls nehmen Sie die Einstellungen gemäss folgender Abbildung vor. Anstelle
von «proxy.unibe.ch / 80» muss Adresse und Port des Proxy-Servers Ihres Netzwerkes eingegeben werden.
Einstellungen für den Proxy-Server
Tabulatorabstand für den Editor
Diese Einstellung beinflusst die Darstellung des Programmcodes im Editor und bewirkt eine mehr oder weniger
kompakte Darstellung Ihrer Programme. Ein Wert von 2 hat sich für die meisten Benutzer als ideal erwiesen,
ist aber Geschmackssache (s. Lektion 2, Abschnitt m-Files -> Editor/Debugger) .
Sie können dies wie folgt einstellen: Menupunkt File > Preferences... anwählen, dann die Einstellung gemäss
folgender Abbildung vornehmen; es ist zweckmässig, «Tab size» und «Indent size» auf den gleichen Wert zu
setzen.
15
Tabulatoreinstellung für den Editor
16
Lektion 1: Grundlagen von Matlab
In dieser Lerneinheit lernen Sie, was für Möglichkeiten Matlab überhaupt bietet und wie man mit
der Benutzeroberfläche von Matlab arbeitet. Dazu werden grundlegende Fakten zur Repräsentation und
Manipulation von Daten vermittelt.
Lernziele
•
•
•
•
•
•
Sie erhalten einen Einblick in die Möglichkeiten von Matlab
Sie kennen die verschiedenen Bereiche der Benutzeroberfläche
Sie können diese an Ihre Bedürfnisse anpassen
Sie können im Direktmodus Berechnungen anstellen
Sie kennen die grundlegende Methode von Matlab, Daten zu repräsentieren (Skalare, Vektoren,
Matrizen)
Sie können diese Daten manipulieren und mathematische Funktionen und Operationen darauf anwenden
17
Wozu kann man Matlab gebrauchen?
Im folgenden erhalten Sie eine Übersicht über die Möglichkeiten von Matlab. Sollten Sie bereits wissen,
was man alles mit Matlab anstellen kann, können Sie diese Abschnitte auch überspringen und direkt zu Die
Benutzeroberfläche gehen.
Matlab steht für Matrix laboratory. Es handelt sich dabei um eine Programmiersprache und -umgebung, die
mit speziellen Datentypen (insbesondere eben Matrizen 1) arbeitet.
Wann bietet Matlab Vorteile?
Kleine, nur einmal zu erfassende und auszuwertende Datenmengen lassen sich problemlos mit
Tabellenverarbeitungsprogrammen wie MS Excel oder OpenOffice Calc vorverarbeiten und dann in
Statistiksprogrammen wie Statistica oder SPSS inferenzstatistisch auswerten. Dafür lohnt sich der Einsatz von
Matlab kaum.
Matlab wird in folgenden Fällen interessant:
•
•
•
•
Wenn es sich um die Auswertung grösserer, häufig automatisiert erfasster Datenmengen handelt, wie sie
u.a. auch bei der Durchführung von psychophysiologischen Experimenten (EEG 2, fMRI 3, Registrierung
von Augenbewegungen, Hautleitfähigkeit u.ä.) oder bei Internet-Experimenten und Logfile-Analysen
etc. anfallen. Jeden neu erfassten Datensatz in der Tabellenverarbeitungssoftware manuell zu bearbeiten
und dann in ein Statistikprogramm zu exportieren wird dann schnell sehr aufwendig, sodass eine
Automatisierung mittels eines Matlab-Programmes lohnend wird.
Die Arbeit mit programmierten Auswertungsroutinen ist auch dann effizienter, wenn die Auswertung
mehrmals verändert werden muss und dann der ganze Datensatz immer wieder neu durchgerechnet
werden soll.
Matlab bietet zudem umfangreiche Grafikfunktionen, spezielle Statistikfunktionen und weitere
interessante Features, die in den gängigen Softwarepaketen nicht oder in zu wenig flexibler Form
vorhanden sind.
Es lassen sich benutzerfreundliche Bedieneroberflächen programmieren, die die Auswertung von Daten
auch Mitarbeitenden erlaubt, die weniger gut ausgebildete Computerkenntnisse besitzen.
Auswertungsprogramme kann man natürlich auch mit anderen Sprachen wie Visual Basic, C++ oder
Java schreiben. Matlab ist aber speziell auf die Verarbeitung, Auswertung und grafische Darstellung
numerischer Daten ausgelegt. Ein besonderer Vorteil ist, dass Matlab im Gegensatz zu den meisten anderen
Programmiersprachen als «Interpreter» bedient werden kann: Man kann Befehle einzeln eingeben und sofort
ausführen lassen, und auf diese Weise ausprobieren, wie die Syntax sein muss, damit der Computer das tut,
was man von ihm will. Die so erprobten Befehle kann man dann per «copy-and-paste» in Programmdateien
übernehmen. Auch um ein Programm auszuführen, muss es nicht vorher «kompiliert» werden, wie das in
anderen Sprachen notwendig ist.
Bemerkung für Programmierer: Trotz dieser bedienungsfreundlichen Oberfläche laufen MatlabProgramme fast genauso schnell wie solche, die mit «kompilierten» Programmiersprachen wie C
++ oder Pascal erstellt wurden. Zudem besteht auch die Möglichkeit, ein Matlab-Programm zu
kompilieren und als «stand alone»-Programm laufen zu lassen.
1
Die wichtigste Art der Repräsentation von Daten in Matlab. In der Mathematik ist eine Matrix (Plural: Matrizen) eine Tabelle von Zahlen
oder anderen Größen. Matrizen unterscheiden sich von einfachen Tabellen dadurch, dass mit ihnen gerechnet werden kann. Mit dem
Ausdruck Matrix ist meist eine zwei- oder höherdimensionale Matrix gemeint (vgl. Skalar, Vektor).
18
Beispielhafter Ablauf der Datenverarbeitung
Im folgenden sehen Sie eine schematische Darstellung eines typischen Projektes. Daraus wird ersichtlich,
welche Schritte der Datenverarbeitung oft mit Matlab realisiert werden.
Beispiel des Datenflusses in einem Projekt
19
Einige Beispiele im Direktmodus
Direktmodus bedeutet, dass Anweisungen direkt im «Command Window» auf der
«Command Line», also direkt nach dem Prompt >> eingegeben werden. Matlab führt
diese dann sofort aus. Dies steht im Gegensatz zum Programmier-Modus, d.h. wenn
zuerst ein Programm geschrieben wird, das dann später immer wieder ausgeführt werden
kann (dazu mehr in der Lektion 2).
Im folgenden können Sie selbst einige Möglichkeiten von Matlab ausprobieren. Starten Sie dazu Matlab,
geben Sie im «Command Window» hinter der Eingabeaufforderung >> die in den untenstehenden Beispielen
notierten Kommandos ein, und schauen, was passiert. Im Moment müssen Sie noch nicht jedes Kommando im
Detail verstehen, all dies wird später nochmals genauer erläutert.
Beispiel 1: Benutzen von Matlab als (etwas überdimensionierten) «Taschenrechner»
>> 27*5
>> 2^10
>> durchmesser=14.6
>> umfang=durchmesser*pi
>> flaeche=durchmesser^2*pi/4
>> ans
Erläuterungen: Einfache Berechnungen können im Direktmodus gemacht werden. Wird kein Variablenname
wie durchmesser angegeben, wird das Resultat in ans (answer) gespeichert. pi ist eine intern
vordefinierte Konstante, die jederzeit verwendet werden kann.
Beispiel 2: Erstellen einer Grafik im Direktmodus
>> x = -pi:.01:pi
>> y = sin(x)
>> plot(x,y)
>> hold on
>> z = cos(x)
>> plot(x,z,'r')
Erläuterungen: Zuerst wird eine Folge von Werten zwischen -pi und pi mit dem Abstand 0,01 generiert. Davon
werden die Sinuswerte berechnet, und die Daten anschliessend mit plot gezeichnet. hold on «fixiert»
die Grafik, damit sie von der nächsten plot-Anweisung nicht gelöscht wird. Zusätzlich wird der Cosinus
berechnet und in rot in dieselbe Grafik geplottet.
20
Anschliessend das Grafikfenster schliessen: Entweder direkt so, wie man jedes Windows-Fenster schliesst,
oder mit der Eingabe von close.
Beispiel 3: Einige Statistikfunktionen
>> data = randn(1, 1000);
>> plot(data)
>> hist(data)
>> mean(data)
>> std(data)
Erläuterungen: Im ersten Schritt werden mittels der Funktion randn 1000 normalverteilte Zufallswerte
erzeugt (der Strichpunkt am Ende der Zeile verhindert die Ausgabe der Werte im Command Window). Mit
plot werden diese Rohdaten in einem neuen Grafikfenster angezeigt. hist erzeugt ein Histogramm,
in dem man die Normalverteilung sehen kann (eventuell muss man hier das Ausgabefenster wieder in den
Vordergrund holen). mean und std berechnen den Mittelwert und die Standardabweichung. Wie man sieht,
erzeugt randn Werte mit dem Mittelwert 0 und der Standardabweichung 1.
21
22
Demonstrationsbeispiele von Matlab
Matlab stellt in seiner Dokumentation zahlreiche eindrückliche Demos zur Verfügung. Im folgenden können
Sie einige davon durchspielen, um ein besseres Bild der Mächtigkeit von Matlab zu erhalten.
Wählen Sie die Demos über den Start-Button von Matlab oder über das Hilfe-Menu an.
Zwei Möglichkeiten, die Demos zu starten
Nun wird das Hilfe-System gestartet. Öffnen Sie im linken Fensterteil (help browser) die Verzeichnisstruktur
«MATLAB» (auf das «+»-Zeichen clicken). Nun können Sie z.B. unter «Graphics» einige Demos anschauen.
Empfohlen:
•
2-D Plots
•
3-D Plots
•
Vibrating Logo
•
Earth's Topography
Nach dem Auswählen muss zum Starten oben rechts Run in the Command Window (und anschliessend
wiederholt Next zum weiterfahren) bzw. Run this demo angeclickt werden.
23
Beispiel aus der psychologischen Forschungspraxis
Die nachfolgenden Grafiken zeigen einige Möglichkeiten, Augenbewegungsdaten mittels Matlab-Routinen zu
visualisieren (Quelle: Labor für Perzeption und Okulomotorik, Neurologie, Universitätsspital Bern).
Zum Vergrössern bitte die Bilder anklicken.
Darstellung des Abtastpfades: Auswertungsroutine mit grafischem Benutzerinterface
Dichtedarstellung der Fixationen: 2D density plot
Dichtedarstellung der Fixationen: 3D density plot
Darstellung von Sakkadenamplitude und -häufigkeit je Richtung
24
Dieses Element (Animation, Video etc.) kann nicht dargestellt werden und ist nur in der
Onlineversion sichtbar. [link]
Animierte Darstellung des Abtastpfades
25
Die Benutzeroberfläche
Übersicht
Die Matlab-Benutzeroberfläche, kurz «Desktop» (engl. Arbeitsfläche, Schreibtisch) genannt, ist in
verschiedene Bereiche aufgeteilt. Für ein effizentes Arbeiten mit Matlab ist das Verständnis ihrer Funktionen
grundlegend. Die wichtigsten davon werden daher in dieser Lerneinheit besprochen, nämlich
•
das Command Window
•
der Workspace
•
der Current Directory Browser
•
die Command History
Des weiteren ist es wichtig zu wissen, was das Hilfe-System von Matlab an Informationen zur Verfügung stellt.
Die Matlab-Benutzeroberfläche (Desktop)
26
Darstellungsmöglichkeiten des Desktops
Der Desktop ist in verschiedene Bereiche aufgeteilt. Untenstehendes Bild zeigt die «DefaultEinstellung» (Voreinstellung).
Default-Darstellung des Desktops
Die neuesten Versionen von Matlab (ca. ab Version 2008a) haben ein etwas anderes Default-Layout.
Es ist also kein Fehler, wenn Ihr Bildschirm nicht genauso aussieht, wie in der Abbildung gezeigt.
Weitere Bereiche lassen sich über den Menupunkt Desktop dazuschalten bzw. entfernen. Die verschiedenen
Bereiche lassen sich auf vielfältige Weise anordnen, Fensterteile in der Grösse und Position verändern, aus
dem Verbund mit den anderen herauslösen, und sie können die Begrenzungslinien zwischen den Teilfenstern
verschieben. Benutzen Sie dazu die Buttons in der rechten oberen Ecke des jeweiligen Subfensters sowie
verschiedene Optionen unter dem Menupunkt Desktop benutzen.
27
Andere Möglichkeit der Darstellung
Falls Sie genauer wissen wollen, welche Möglichkeiten es dazu gibt, können Sie sich im Hilfesystem
kundig machen. Dieses ruft man mit über das Menu Help > Product Help auf. Die Informationen zum
Desktop finden Sie wie in der folgenden Abbildung gezeigt.
Sollte Ihr Matlab-Desktop nicht der Default-Einstellung entsprechen, stellen Sie bitte diese
Grundeinstellung her: Desktop > Desktop Layout > Default
28
Das «Command Window»
Der Bereich des «Command Windows» (Kommandofenster) ist der Kommunikationskanal zwischen dem
Benutzer und Matlab. Sie haben ihn bei der Eingabe der ersten Beispiele bereits benutzt. Er dient zur
Eingabe von Anweisungen, und Programme können Resultate in dieses Fenster ausgeben. Auch Warnungen,
Fehlermeldungen etc. erscheinen hier.
Früher eingegebene Befehle lassen sich mit den Tasten <Pfeil aufwärts> und <Pfeil
abwärts> wieder hervorholen, und dann allenfalls abändern und nochmals ausführen.
Das «Command Window» von Matlab
Einige Einstellungen des Command Windows
Mit folgenden Kommandos können Sie die Ausgabe im Command Window beeinflussen:
>> pi
>> format compact
>> pi
>> home
PI anzeigen
Ausgabeformat 'compact' einstellen
nun ist's tatsächlich kompakter
nach oben links gehen, aber Inhalt des Command Windows nicht löschen
29
>> clc
löscht das Command Window komplett (clear command window)
Erläuterungen: Der Befehl format ermöglicht, die Ausgabe von Werten im Command Window auf
vielfältige Weise zu beeinflussen. format compact verhindert die Ausgabe von überflüssigen Leerzeilen.
Für weitere Möglichkeiten sehen Sie bitte die Angaben im Hilfe-System (z.B. durch die Eingabe von
docsearch format im Command Window).
30
Der «Workspace»
Der Workspace ist quasi das Arbeitsgedächtnis von Matlab. Hier werden alle verwendeten Variablen
gespeichert, und darauf kann das Programm direkt zugreifen. In der untenstehenden Abbildung finden Sie
dort die Variablen vor, die wir bei den Demonstrationsbeispielen benutzt haben. Hier kann z.B. direkt auf die
Variablen zugegriffen werden, um sie anzuzeigen oder zu verändern.
Der "Workspace" von Matlab
Tools im Workspace
Markieren Sie eine Variable im Workspace und schauen Sie sich die in der Werkzeugleiste des
Workspaces vorhandenen Werkzeuge an. Am häufigsten verwendet werden Open und die GrafikTools.
31
32
Der «Current Directory»-Browser
Dieser liegt im gleichen Fensterteil wie der Workspace und kann über den «Register-Reiter» hervorgeholt
werden. Er dient dazu, sich im Dateisystem des Computers zurechtzufinden, und damit das aktuelle
Verzeichnis für Lade- und Speichervorgänge von Daten sowie das Stammverzeichnis des Editors zu
wählen. Letzteres wird im Eingabefeld «Current Directory» rechts oben angezeigt und kann alternativ auch
dort gewählt werden.
Dies ist nicht zu verwechseln mit dem «path», mit dem Matlab mitgeteilt wird, wo die
Programmdateien liegen, vgl. Abschnitt Konfiguration von Matlab.
Das «Current Directory»-Fenster von Matlab
33
Die «Command History»
In diesem Unterfenster finden Sie die Geschichte Ihrer Benutzung von Matlab, d.h. die in letzter Zeit
im Command Window eingegebenen Befehle. Diese Liste lässt sich durchsuchen, einzelne Befehle erneut
aufrufen, oder es ist möglich, aus mehreren selektierten Befehlen direkt ein Programm (Skript) zu erstellen.
Die "Command History" von Matlab
Nochmaliges Ausführen von früher verwendeten Befehlen
Finden und markieren (z.B. mit Shift-Click oder Ctrl-Click) Sie in Ihrer Command History die in
der obenstehenden Abbildung umrahmten Befehle, die aus den Beispielen aus dem ersten Abschnitt
stammen (falls Sie diese nicht gemacht haben, markieren Sie einige andere Befehle). Wählen Sie dann
über das Context-Menu (rechte Maustaste) den Punkt «Evaluate Selection» (oder drücken Sie F9). So
werden die markierten Befehle nochmals ausgeführt.
34
Benutzung des Hilfe-Systems
Das Hilfe-System von Matlab ist äusserst gut ausgebaut und macht jedes gedruckte Handbuch überflüssig.
Es ist sowohl beim Erlernen von Matlab wie auch bei der täglichen Arbeit für fortgeschrittene Anwender
ein unverzichtbares Hilfsmittel. Neben der eigentlichen Dokumentation des Matlab-Hauptprogrammes und
allfälliger Toolboxen beinhaltet es - wie wir gesehen haben - auch eine Fülle von Beispielen und einige
Tutorials, um den Einstieg zu erleichtern, sowie Links zu Online-Ressourcen von Mathworks.
Aufruf des Hilfe-Systems
Das Hilfe-System kann auf verschiedene Arten aufgerufen werden. Die wichtigsten davon sind
folgende (bitte direkt im Programm ausprobieren):
•
•
•
•
•
Über Help > Product Help. Auf diese Weise wird der Help Browser/Help Navigator geöffnet (s. Bild
unten)
Mit der Taste F1. Wenn man sich dabei im Command Window befindet, wird eine reduzierte Version
aufgerufen, ähnlich einem der anderen Unterfenster des Desktops. Unten links befindet sich ein Link
«Open Help Browser», mit dem man in die Volldarstellung wechseln kann.
Hilfe zu bestimmten Funktionen: doc funktionsname, z.B. doc sin. So wird direkt der
Eintrag für die betreffende Funktion angezeigt.
Ähnlich kann man auch im Command Window einen bereits getippten Befehl markieren und über das
Kontextmenu (rechte Maustaste) Help on Selection die Hilfe dazu aufrufen (oder mit der Taste F1).
Wenn man den Hilfeeintrag noch nicht genau kennt, kann man mittels direktem Befehl in die HilfeSuchfunktion einsteigen, z.B. docsearch operators
Inhalte finden
Matlab bietet im wesentlichen drei Möglichkeiten, Hilfe zu bestimmten Fragen zu finden. Diese sind im linken
Teil, im Help Navigator, zu finden.
1.
2.
3.
Contents: Darstellung als logisch gegliedertes Inhaltsverzeichnis.
Index: alphabetisch geordneter Index der Hilfethemen
Suchfunktion: Im Feld Search for: kann nach Stichwörtern gesucht werden. Die gefundenen Einträge
werden dann in den Search Results angezeigt, und der erste Eintrag im Hauptfenster.
35
Das Hilfesystem von Matlab
Zudem werden unmittelbar nach dem Start des Hilfesystems auch im Hauptfenster verschiedene
Möglichkeiten angeboten: Suchen in Kategorien, alphabetisch, nach Objekteigenschaften, sowie Links zu
druckbaren Versionen der Dokumentation (pdf) und externen Ressourcen auf der Mathworks-Homepage.
Im Hauptfenster kann man - ähnlich wie in einem Internet-Browser - komfortabel in den Inhalten vor- und
zurückblättern, suchen, Favoriten anlegen oder drucken.
Übernehmen von Beispielcode aus dem Hilfe-System
Code-Beispiele, die in Hilfe-Einträgen erscheinen, kann man ganz einfach mittels Copy-and-Paste in
das Command Window (oder in ein Programm) kopieren und dort ausprobieren.
•
Im Help Navigator plot3 eingeben und Go clicken (alternativ: im Command Window doc plot3)
•
runterscrollen und die vier Programmzeilen nach «Examples: Plot a three-dimensional helix» selektieren
•
Edit > Copy oder Ctrl-C
•
Wechseln in das Command Window, und dort Edit > Paste oder CTRL-V ausführen
•
Die Enter-Taste zum Ausführen drücken, und... WOW!
36
Zusammenfassung
Die wichtigsten Punkte des Abschnittes «Benutzeroberfläche» finden Sie im folgenden
kurz zusammengefasst.
•
•
•
•
•
•
Der Bereich des «Command Windows» (Kommandofenster) ist der
Kommunikationskanal zwischen dem Benutzer und Matlab. Hier können Sie
Anweisungen eingeben, und Programme können Resultate in dieses Fenster
ausgeben. Auch Warnungen, Fehlermeldungen etc. erscheinen hier.
Früher eingegebene Befehle im Command Window lassen sich mit den Tasten
<Pfeil aufwärts> und <Pfeil abwärts> wieder hervorholen, und dann allenfalls
abändern und nochmals ausführen.
Der «Workspace» ist das Arbeitsgedächtnis von Matlab. Hier werden die
verwendeten Variablen gespeichert. Programme arbeiten mit diesen Variablen.
Der «Current Directory Browser» erlaubt den Zugriff auf das Dateisystem
des Computers. Man kann damit das aktuelle Verzeichnis für Lade- und
Speichervorgänge von Daten sowie das Stammverzeichnis des Editors zu wählen
Im Fenster «Command History» finden Sie die in letzter Zeit im Command
Window eingegebenen Befehle.
Das Hilfe-System von Matlab ist ein unverzichtbares Hilfsmittel für Anfänger wie
Profis. Es macht ein gedrucktes Handbuch überflüssig.
37
Zahlen und Variablen in Matlab
Wie Sie bereits im Abschnitt Wozu Matlab? gesehen haben, können Berechnung, grafische Darstellungen etc.
auf simple Art im sogenannten Direktmodus - d.h. direkte Eingabe von Kommandos im Command Window
- vorgenommen werden.
In den folgenden Lerneinheiten erlernen Sie die Grundlagen, um im Direktmodus arbeiten zu können:
•
Wie werden Zahlen in Matlab dargestellt?
•
Was sind Variablen?
•
Der wichtigste Datentyp: Matrizen
•
Wie geht man mit Matrizen um?
•
Mit welchen Operatoren und Funktionen kann man rechnen?
All dies ist nicht nur im Direktmodus relevant, sondern gilt auch für selbst geschriebene Programme, wie Sie
in der Lektion Programmieren in Matlab erfahren werden.
Dies erlaubt, die Anweisungen, die in ein Programm eingefügt werden sollen, zuerst im Direktmodus
auszuprobieren, wenn man sich über deren Syntax oder Funktion im unklaren ist, bevor man sie dann ins
Programm übernimmt.
38
Repräsentation von Zahlen
Gemäss der Konvention im angelsächsischen Sprachraum werden Zahlen mit Dezimalstellen mit Punkt notiert.
Das Komma dient in Matlab der Trennung aufeinanderfolgender Anweisungen auf derselben Zeile. Das
Resultat einer Berechnung (hier nur die Eingabe einer Zahl) wird der vordefinierten Variablen ans (answer)
zugewiesen, sofern keine Zuweisung zu einer Variablen erfolgt.
Geben Sie die nachfolgenden Kommandos im Command Window ein und versuchen Sie
nachzuvollziehen, was Matlab damit anfängt.
>> format compact
>> 23.736
>> 7,43
>> pi
kompaktere Darstellung aktivieren
korrekte Eingabe einer Zahl
wird als zwei Zahlen interpretiert, durch das Komma getrennt
pi ist eine vordefinierte Konstante, die jederzeit verwendet werden kann
Für Zahlen in Exponentialnotation wird der Buchstabe e benutzt, um den Exponenten abzutrennen. Beispiele:
>> 1.746e5
>> 584e-11
für 1,746 x 105
auch negative Exponenten sind natürlich möglich
Im Gegensatz zu anderen Programmiersprachen verfügt Matlab auch über eine Repräsentation von zwei
besonderen Zahlenwerten: unendlich (inf, infinite) und «keine Zahl» (NaN, Not a Number). Diese können als
Resultat von Berechnungen entstehen, wie z.B. Division durch Null, und auch einer Variablen zugewiesen
werden.
Probieren Sie folgende Kommandos aus, die dies illustrieren.
>> 2/0
>> -5/0
>> 0/0
>> inf/inf
>> 0*inf
Division durch 0 gibt inf
auch minus unendlich ist möglich
0 dividiert durch 0 gibt NaN
39
Variablen
Daten werden im Arbeitsspeicher von Matlab (dem Workspace) als Variablen gespeichert.
Eine Variable ist ein reservierter Speicherplatz im Hauptspeicher des Computers,
welcher mit einem eindeutigen Namen angesprochen werden kann.
Eine Variable kann verschiedene Arten von Daten enthalten. Dieser Umstand wird
ausgedrückt, indem man sagt, dass die Variable von einem bestimmten «Datentyp» ist.
Beispiele von Datentypen sind einfache Zahlen, Matrizen, Zeichenketten (Strings), strukturierte Daten etc.
In den folgenden Beispielen arbeiten wir mit einfachen Zahlen. Weitere Datentypen werden Sie im späteren
Verlauf kennenlernen.
Im Gegensatz zu vielen anderen Programmiersprachen müssen Variablen in Matlab nicht vordefiniert - d.h.
ihnen ein Speicherplatz zugewiesen - werden. Matlab reserviert ihren Speicherplatz bei der ersten Verwendung
(d.h. bei der ersten Zuweisung eines Wertes) automatisch.
Konventionen für Variablennamen
Eine Variable wird durch einen eindeutigen Namen gekennzeichnet. Dieser muss mit einem Buchstaben
beginnen, und kann danach Buchstaben, Zahlen oder den «underscore» _ enthalten.
Variablennamen sind case-sensitive, d.h. Gross- und Kleinschreibung ist relevant.
An den folgenden Beispielen sehen Sie, welche Variablennamen möglich sind und wie diese mit
Inhalten befüllt und diese auch wieder abgerufen werden können.
>> Speed = 63
>> g65_fubar = 3
>> Speed
>> speed
>> 6test = 2
>> _foo = 1
>> hallo$du
>> pi = 11
>> sin = 0
das Gleichzeichen weist der Variablen einen Wert zu
auch ein gültiger Name
den Wert wieder abrufen
klein geschrieben geht's nicht
am Anfang kein Buchstabe ist ungültig
ebenso
nur das Sonderzeichen _ ist erlaubt
Auch das Umdefinieren von vordef. Konstanten wie pi oder Funktionsnamen
(hier die Sinus-Funktion sin) ist möglich, aber mit Vorsicht zu verwenden...
Laden und Speichern der Variablen im Workspace
Alle einmal verwendeten Variablen sind im Workspace sichtbar. Der Inhalt des Workspaces kann mit save
auf die Festplatte gespeichert werden (in dasjenige Verzeichnis, das im Current Directory Browser-Fenster
angewählt ist) und mit load wieder geladen werden.
Einzelne Variablen können mit dem Kommando clear aus dem Workspace entfernt werden.
Probieren Sie auch dies bitte selbst aus:
>> save daten
>> clear Speed
>> clear
>> load daten
speichert alle Variablen in der Datei daten.mat
die Variable Speed ist nicht mehr im Workspace sichtbar
löscht alle Variablen (siehe Workspace-Fenster)
lädt die Variablen wieder zurück (siehe Workspace-Fenster)
40
Speichern und laden von Workspace-Variablen ist auch über die Menu-Buttons des Workspace-Fensters
möglich. Einzelne Variablen lassen sich direkt im Workspace löschen (Markieren und 'delete'-Taste oder
Kontextmenu > delete).
41
Zusammenfassung
Die wichtigsten Punkte des Abschnittes «Zahlen und Variablen» finden Sie im folgenden
kurz zusammengefasst.
•
Die Dezimalstellen einer Zahl werden mit Punkt (nicht Komma) notiert.
•
Die Exponentialnotation erfolgt mit e, also zum Beispiel 2.7e6 für 2,7 x 106.
Operationen wie Division durch Null, die in anderen Programmiersprachen und
Anwendungen nicht zulässig sind, ergeben in Matlab definierte Werte wie inf
für unendlich oder NaN für «keine Zahl».
Eine Variable wird durch einen eindeutigen Namen gekennzeichnet. Dieser muss
mit einem Buchstaben beginnen, und kann danach Buchstaben, Zahlen oder den
«underscore» _ enthalten.
Variablennamen sind case-sensitive, d.h. Gross- und Kleinschreibung ist relevant.
•
•
•
42
Repräsentation von Daten 1: Skalare, Vektoren und Matrizen
Matlab kennt verschiedene Repräsentationen von Daten. Die wichtigste ist die Darstellung als Matrix, daher
ja auch der Name Matlab (Matrix Laboratory).
Die geläufigste Form einer Matrix ist diejenige einer zweidimensionalen Matrix, vergleichbar einer
Tabelle. Matrizen enthalten ausschliesslich numerische Werte (Ausnahme: Zeichenketten, vgl. Abschnitt
Repräsentation von Daten 2: Zeichenketten (Strings) in der nächsten Lektion.
Eine Matrix ist sehr gut geeignet, Daten abzuspeichern, wie sie auch sonst in Tabellenform erfasst werden
könnten - z.B. um schnell einen Datensatz zu erstellen, oder maschinell erfasste Daten zu repräsentieren.
Beispiel: Ein einfacher Datensatz, der in der ersten Spalte die Versuchspersonennummer enthält, in der zweiten
das Geschlecht (z.B. 1 = weiblich, 2 = männlich), in der dritten das Alter der Vp, und in Spalte vier und fünf
die Messwerte zweier abhängiger Variablen.
Einfache Datenmatrix mit Daten von fünf Versuchspersonen
Gemäss der Terminologie der linearen Algebra werden gewisse Sonderfälle von Matrizen, entsprechend ihrer
Anzahl Dimensionen, wie folgt bezeichnet:
•
Skalar: «nulldimensionale» Matrix, d.h. nur ein Element
•
Vektor: eindimensionale Matrix
•
Matrix: zwei- oder höherdimensionale Matrix. Diese werden oft auch als Array bezeichnet.
Diese werden Sie im folgenden genauer kennenlernen.
43
Skalare
Ein Skalar ist eine Matrix mit einer Zeile und einer Spalte, also mit nur einem einzigen numerischen Wert.
Die Schreibweise mit eckigen Klammern [
] bezeichnet immer eine Matrix,
inkl. Skalare und Vektoren! (mit einer Ausnahme, s. Abschnitt Programmieren von
Funktionen, Beispiel 3).
Bitte probieren Sie's aus:
>> sk = 93
>> sk2 = [13]
>> sk(1,1)
>> isscalar(sk)
Dies ist ein Skalar. Dafür sind die eckigen Klammern also nicht zwingend.
allgemeinere Schreibweise als 1x1-Matrix
ist identisch mit sk - das Element in Zeile 1, Spalte 1
bestimmt, ob sk ein Skalar ist (1 = ja, 0 = nein)
44
Vektoren
Ein Vektor enthält mehr als ein numerisches Element, die quasi nebeneinander oder untereinander angeordnet
werden.
Abhängig davon, ob die Elemente des Vektors nebeneinander oder untereinander angeordnet sind, spricht man
von:
•
Spaltenvektoren (eine Spalte, beliebig viele Zeilen)
•
Zeilenvektoren (eine Zeile, beliebig viele Spalten)
Anders gesagt ist ein Vektor also eine Matrix mit nur einer einzigen Zeile oder einer Spalte.
Bitte versuchen Sie die folgenden Beispiele nachzuvollziehen:
>> zvekt = [1 4 8]
>> zvekt = [1,4,8]
>> zvekt(2)
>> zvekt(0)
>> svekt = [12; 55; inf]
>> svekt(1:2)
>> folge = 0:2:10
>> folge2 = 20:30
>> folge3 = pi:-.1:-pi
>> folge2'
>> isvector(folge2)
>> length(folge3)
ein Zeilenvektor mit drei Elementen
die Elemente können mit Leerschlag oder Komma getrennt werden
Das zweite Element des Vektors abrufen
Wichtig: Es gibt es kein «nulltes» Element!
ein Spaltenvektor. Der Strichpunkt trennt die Zeilen
das erste bis zweite Element des Vektors abrufen
erzeugt einen Vektor mit Zahlen in gleichem Abstand.
wird der mittlere Wert weggelassen, beträgt der Abstand 1
auch negative und gebrochene Schrittweiten sind möglich
Der Apostroph transponiert eine Matrix.
Hier: Umwandlung Zeilen- zu Spaltenvektor
ist das ein Vektor?
bestimmt die Länge eines Vektors
45
Matrizen
In der Mathematik ist eine Matrix (Plural: Matrizen) eine Tabelle von Zahlen oder anderen Größen. Die
gebräuchlichste Matrix ist sicher die zweidimensionale (m Zeilen, n Spalten), sie entspricht einer Tabelle,
wie man sie z.B. aus MS Excel kennt (allerdings kann sie nur Zahlen enthalten). Matlab erlaubt aber auch
höherdimensionale Matrizen, also solche mit drei oder mehr Dimensionen.
Demonstrationsbeispiel: Die Matrix in «Melancholia» von Dürer
>> load durer
>> image(X)
>> colormap(map)
>> load detail
>> image(X), colormap(map)
>> m4 = magic(4)
lädt einen vordefinierten Datensatz in den Workspace (Variable X)
stellt ihn als Bild dar
lädt die richtige Farbpalette dazu. Finden Sie die Matrix?
ein anderer Datensatz mit dem Bilddetail
Ein magisches Quadrat!
das kann Matlab auch (finden Sie den Unterschied!)
Matrizen können auf vielfältige Weise erzeugt werden, und auch der Zugriff auf ihre Elemente ist sehr variabel
möglich, wie Sie in den folgenden Beispielen sehen können.
Erzeugen von Matrizen und Zugreifen auf ihre Inhalte und Eigenschaften.
>> M3=[12 13 10;3 5 8;3 2 1]
>> M3(2, 3)
>> M3(:, 3)
>> M4 = [1:4; 6:2:12]
>> M4(1, 2:end)
>> M4(3, 4)
>> M4(3, 4) = 55
>> M5 = M4(1:2, 2:3)
>> M4(1:2, 2:3) = -1
>> mag = magic(4)
>> mag = mag(:, [1 3 2 4])
>> M4(1, 1, 3) = 100
>> groesse = size(M4)
>> size(M4, 1)
>> ndims(M4)
>> numel(M4)
>> leer = [];
>> isempty(leer)
>> isempty(mag)
>> p = pascal(8)
>> p(3, :) = []
>> p(:, 6) = []
eine 3x3-Matrix
einzelne Elemente ansprechen (Zeile, Spalte)
die ganze 3. Spalte; der : bezeichnet alle Elemente
auch die Notation für Zahlenfolgen ist möglich
end bezeichnet das letzte Element
liegt «ausserhalb» der Matrix
Matlab erweitert die Matrix automatisch und füllt mit 0 auf
eine Teilmatrix einer neuen Variablen zuweisen
einen Teil der Matrix belegen
nochmals das magische Quadrat
durch vertauschen der 2. & 3. Spalte in Dürers Quadrat verwandeln
d.h. Indizierung durch Vektor
die Matrize M4 auf eine dreidimensionale erweitern
ergibt die Grösse der Matrix (als Vektor!)
nur die Anzahl Zeilen abfragen (2 ergibt die Spalten)
Anzahl Dimensionen (number of dimensions)
Anzahl Elemente (number of elements)
leere Matrix erzeugen
Abfrage, ob Matrix leer ist
noch eine Matrix erzeugen (Pascal'sches Dreieck)
So kann man eine Zeile aus der Matrix entfernen
analog für eine Spalte
46
Lineare Indizierung
Die lineare Indizierung ermöglicht eine etwas andere Art des Zugriffs auf
die Elemente einer Matrix. Anstatt das Element mit Zeile und Spalte zu adressieren, kann man eine Matrix
auch quasi «durchnumerieren» (zuerst in Spalten, dann in Zeilen). Mit einem einzelnen Argument adressiert
man also das x-te Element der Matrix.
In der abgebildeteten Matrix ist das Element data(2, 4) also identisch mit data(17) mit dem Inhalt 14.
47
Zusammenfassung
Unten finden Sie die wichtigsten Merkpunkte wieder in einer kurzen Zusammenfassung.
Zusätzlich werden auch die häufig gebrauchten Matlab-Anweisungen aufgelistet.
Merkpunkte
•
•
•
•
•
•
•
•
•
•
•
Ein Skalar ist eine Matrix mit einer Zeile und einer Spalte, also mit nur einem
einzigen numerischen Wert.
Ein Vektor ist eine Matrix mit nur einer einzigen Zeile (Zeilenvektor) oder einer
Spalte (Spaltenvektor).
Die gebräuchlichste Matrix ist die zweidimensionale (m Zeilen, n Spalten). Matlab
erlaubt aber auch höherdimensionale Matrizen, also z.B. mit m Zeilen, n Spalten
und p Ebenen.
Matrizen und Vektoren werden bei der Definition mit eckigen Klammern [ ]
notiert. Bei Skalaren sind die Klammern optional.
Die Elemente von Matrizen und Vektoren werden in der Zeile mit Leerschlag oder
Komma getrennt. Der Strichpunkt ergibt eine neue Zeile.
Zahlenfolgen (= Vektoren) können mit der : - Notation erzeugt werden, z.B.
10:2:50 für alle geraden Zahlen von 10 bis 50.
Ein alleine stehender Doppelpunkt bezeichnet alle Elemente in einer Zeile bzw.
Spalte, z.B. daten(:, 12) für alle Zeilen, aber nur Spalte 12 der Matrix.
Beim Zugriff auf einzelne Elemente einer Matrix werden die Indices in runden
Klammern ( ) eingeschlossen.
Die Indices gehen immer von 1 bis n, der Index 0 (ein «nulltes» Element) existiert
in Matlab nicht.
Bei zweidimensionalen Matrizen ist der erste Index ist immer die Zeile (row), der
zweite die Spalte (column).
Lineare Indizierung: Anstatt das Element mit Zeile und Spalte zu adressieren, kann
man eine Matrix auch quasi «durchnumerieren» (zuerst in Spalten, dann in Zeilen).
Mit dem linearen Index adressiert man dann das x-te Element der Matrix.
Anweisungen
•
isscalar, isvector: prüft, ob eine Variable ein Skalar bzw. ein Vektor
ist
•
•
•
•
•
length bestimmt die Länge eines Vektors
ndims ergibt die Anzahl Dimensionen einer Matrix
numel berechnet die Anzahl Elemente einer Matrix
size gibt die Grösse der Matrix zurück
isempty bestimmt, ob die Matrix leer ist
48
Matrizenmanipulation
Im folgenden erlernen Sie verschiedene Möglichkeiten, Matrizen zu manipulieren:
•
Zusammenfügen von Matrizen
•
Vervielfältigen von Matrizen
•
Erzeugen spezieller Matrizen
•
Umformen von Matrizen
Diese Lerneinheit wird mit einer ersten praktischen Übungsaufgabe abgeschlossen.
49
Matrizen zusammenfügen
Matrizen können mittels der normalen [ ] -Notation zusammengefügt werden.
Versuchen Sie dies anhand der folgenden Beispiele nachzuvollziehen:
>> a = magic(5);
>> b = randn(5,3);
>> c = [a b]
>> d = [a; b]
>> b = randn(5,5);
>> d = [a; b]
>> e = [a, d, a]
der Strichpunkt verhindert die Ausgabe von a im Command Window
Zufallszahlen, 5 Zeilen, 3 Spalten
horizontales Zusammenfügen
vertikales Zus.fügen: geht so nicht, weil die Anz. Spalten nicht übereinstimmen
also machen wir eine 5x5-Matrix aus b
nun funktioniert's
auch mehrere Matrizen gleichzeitig zusammenfügen ist möglich
Aus den obigen Beispielen wird ersichtlich, dass der Strichpunkt am Ende einer
Anweisung dazu dient, die Ausgabe der erzeugten Zahlenwerte bzw. die Inhalte der
Variablen im Command Window zu unterdrücken.
Matlab stellt neben der eben besprochenen Möglichkeit auch spezielle Funktionen zum Zusammenfügen von
Matrizen zur Verfügung.
Auch dies wieder an Beispielen gezeigt:
>> horzcat(a, b)
>> vertcat(a, b, a)
horizontal concatenation: horizontales Zusammenfügen
vertical concatenation: vertikales Zusammenfügen;
auch mehr als zwei Matrizen sind möglich
Eine Übersicht über die grundlegenden Befehle zur Matrizenmanipulation finden Sie im Hilfe-System,
z.B. durch Eingabe von doc elmat (elementary matrices and matrix manipulation.)
50
Vervielfältigung von Matrizen
Die wichtigsten beiden Funktion zur Vervielfältigung von Matrizen lauten repmat (repetition of matrices)
und cat (concatenation).
Bitte studieren Sie die Anwendung dieser beiden Befehle anhand der folgenden Manipulationen. Die
Variablen a und b aus den vorherigen Beispielen sollten Sie noch im Workspace haben.
>> m = magic(3);
>> n = repmat(m,2,3)
>> cat(1, a, b)
>> cat(2, a, b)
Matrizen vervielfältigen. Hier 2mal vertikal und 3mal horizontal
Allgemeine Funktion: entlang der Dimension n (1. Argument) zusammenfügen.
1 = vertikal, 2 = horizontal, 3 = "Ebene"
Illustration zur cat-Funktion
51
Erzeugen spezieller Matrizen
Gewisse spezielle Matrizen werden immer wieder benötigt, daher stellt Matlab Funktionen zur Verfügung, um
diese zu erzeugen. Einige Beispiele:
•
Matrizen mit Nullen oder Einsen gefüllt
•
Matrizen von Zufallszahlen mit verschiedenen Verteilungen. Dies kann manchmal zum Testen
statistischer Funktionen oder zum Erstellen von Testdatensätzen hilfreich sein. Siehe hiezu auch
Abschnitt Zufallsdaten in Lektion 4
Besondere Matrizen für die lineare Algebra: Identitätsmatrix, Pascal'sches Dreieck etc.
•
Die wichtigsten dieser Funktionen können Sie aus folgenden Beispielen ersehen.
>> zeros(7, 3)
>> alleseins = ones(4)
>> a(1:5, 1:10) = 3.5
>> b = ones(7, 3) * 81
>> rand(1, 8)
>> randn(2, 6)
>> eye(5)
>> pascal(7)
>> magic(8)
Matrix mit Nullen
Matrix mit Einsen. Wird nur ein Argument angegeben,
resultiert eine quadratische Matrix
Braucht man Matrizen mit anderen Werten, gibt es versch. Methoden
zufallsverteilte Zahlen zwischen 0 und 1
normalverteilte Zufallszahlen mit Mittelwert 0 und Standardabweichung
1
sog. Identitätsmatrix (nur quadratisch möglich), für lineare Algebra
Pascal-Matrix, auch eher was für MathematikerInnen
magische Quadrate
52
Umformen von Matrizen
Die wichtigsten Umformungen sind:
•
Spiegeln (horizontal oder vertikal)
•
Rotieren
•
Transponieren (Zeilen und Spalten vertauschen)
Beispiele zum Ausprobieren:
>> a = [1 2 4 8 16; 0 1 2 3 4; -1 -6 0 1 6];
>> fliplr(a)
>> flipud(a)
>> rot90(a)
>> rot90(a, 3)
>> a'
flip left-right: an der vertikalen Achse spiegeln
flip up-down: an der horizontalen Achse spiegeln
um 90 Grad im Gegenuhrzeigersinn rotieren (default: 1mal)
3-mal um 90 Grad rotieren
Matrix transponieren (Zeilen und Spalten vertauschen)
53
Aufgabe 1: Erstellen einer komplexen Datenmatrix
Sie haben nun die Grundlagen erlernt, um verschiedenste Arten von Matrizen zu erzeugen und zu verändern.
Für den Lernerfolg ist es sehr wichtig, dass Sie versuchen, dieses theoretische Wissen konkret in die Praxis
umzusetzen, indem Sie selbstständig ein Beispiel lösen.
Aufgabenstellung
Manchmal ist es hilfreich, zum Testen einer Auswertungsroutine für Experimentaldaten einen Testdatensatz
erzeugen zu können, wenn man noch keine "echten" Daten erhoben hat. Versuche Sie dies anhand der folgenden
Aufgabe umzusetzen.
Am Ende der Aufgabenstellung finden Sie den Link zu einer Musterlösung, die Sie konsultieren können, falls
Sie nicht weiterkommen. Es ist aber wichtig zu erkennen, dass es nicht nur eine mögliche Lösung gibt.
Greifen Sie nicht zu rasch auf die Musterlösung zurück, sondern versuchen Sie auch, das Hilfe-System
von Matlab zu rate zu ziehen.
Bilden Sie die unten abgebildete Matrix testdata mit hypothetischen Testdaten im Workspace
nach. Versuchen Sie dies mit möglichst wenigen Anweisungen zu erreichen.
Erläuterungen zu den Daten:
Spalte 1: Versuchspersonennummer
Spalte 2: 1. oder 2. Durchführung des Experimentes
Spalten 3-12: markieren verschiedene Experimentalbedingungen
Spalte 13: normalverteilte Zufallsdaten (sie müssen nicht identisch mit den abgebildeten Werten sein). Vier
Werte werden durch NaN als "missing data" gekennzeichnet".
Tips für verwendbare Funktionen: eye, repmat, randn
54
Musterlösung
>> testdata = (27:36)' % Vp-Nummern obere Hälfte
>> testdata = [testdata ones(1, 10)' eye(10)] % Gruppennrn. Gruppe 1 und Diagonale
>> testdata = repmat(testdata, 2, 1) % ganze Matrix vertikal verdoppeln
>> testdata(11:20, 2) = 2 % Gruppe 2 eintragen
>> testdata(:, 13) = randn(20, 1) % zufallsverteilte Daten
>> testdata([4, 11:13], 13) = NaN % missing values eintragen
Alle Zeilen können zusammen durch Copy/Paste in das Command Window übernommen
werden.
Alles, was nach dem %-Zeichen kommt, ist Kommentar und wird von Matlab nicht interpretiert.
55
Zusammenfassung
Zusammenfassung der wichtigsten Merkpunkte und Anweisungen:
Merkpunkte
•
•
Ein Strichpunkt am Ende einer Anweisung im Direktmodus dient dazu, die
Ausgabe der erzeugten Zahlenwerte im Command Window zu unterdrücken.
Matrizen können mittels der normalen [ ]-Notation horizontal oder vertikal
zusammengefügt werden. Statt einzelner Zahlen werden dafür einfach ganze
Matrizen eingesetzt, z.B. d = [a; b]. Dabei müssen die Dimensionen
der Matrizen übereinstimmen, also die Anzahl Zeilen beim horizontalen
Zusammenfügen, und die Anzahl Spalten beim vertikalen Zusammenfügen.
Anweisungen
•
•
•
•
•
horzcat,
vertcat: Horizontales oder vertikales Zusammenfügen von
Matrizen
cat: Allgemeine Anweisung zum Zusammenfügen von Matrizen in Zeile, Spalte,
Ebene etc.
repmat: Eine Matrix vervielfältigen
zeros, ones erzeugt eine Matrix mit Nullen bzw. Einsen
rand,
randn erzeugt Matrizen mit gleich- oder normalverteilten
Zufallszahlen
•
•
•
fliplr, flipud: Spiegeln von Matrizen links/rechts bzw. oben/unten
rot90: Rotation um 90 Grad
data': Transponierung der Matrix data, d.h. Vertauschung von Zeilen und
Spalten
56
Mathematische Operatoren und Funktionen
In dieser Lerneinheit werden mathematischen Operatoren und Funktionen erläutert.
Unter mathematischen Operatoren versteht man Funktionszeichen wie:
•
Addition +, Subtraktion -, Vorzeichen etc.
•
Multiplikation * und Division /
•
Exponentialfunktionen wie Quadrierung ^2
•
Damit verbunden sind auch die Prioritäten der Operationen und die Klammerregeln
Andere mathematische Manipulationen sind als Funktionen realisiert, z.B.
•
trigonometrische Funktionen wie Sinus, Cosinus, Tangens etc.
•
deskriptive Funktionen wie Minimum, Maximum, Mittelwerte u.ä.
•
mathematische Grundfunktionen wie Quadratwurzel, Logarithmus, Summe, Rundung etc.
•
und sehr viel anderes mehr...
Der Funktionsumfang von Matlab ist immens, daher kann hier nur ein Einblick in die wichtigsten Funktionen
gegeben werden.
Der Umgang mit Funktionen und Operatoren kann anschliessend an zwei Übungsaufgaben erprobt werden.
Das Hilfe-System gibt Auskunft über weitere verfügbare Funktionen, z.B. indem man im Suchfeld des
Hilfe-Fensters elementary math eingibt.
57
Operatoren
Das Hilfesystem gibt einen guten Überblick über die mathematischen Operatoren und deren
Schreibweise: Entweder gibt man im Help Navigator arithmetic operators ein, oder im Command
Window docsearch 'arithmetic operators' (die Hochkommata sind nötig, weil der
Suchbegriff einen Leerschlag enthält).
Beim Ausführen von Berechnungen kommen einige Besonderheiten von Matlab zum tragen. Solange
man ausschliesslich mit Skalaren
4
arbeitet, funktioniert alles, wie es auch ein Taschenrechner
ausführen würde. Operationen mit Matrizen (und Vektoren 5) dagegen gehorchen z.T. anderen Regeln
(lineare Algebra).
Bitte versuchen Sie die nachfolgenden Beispiele zu verstehen:
>> magic(3) + ones(3)
>> a(1:3, 1:3) = 5;
>> a * magic(3)
>> a .* magic(3)
>> magic(3) * 5
Die Addition erfolgt immer Element für Element. Die beiden Matrizen
müssen die gleiche Grösse haben.
Die Multiplikation von zwei Matrizen erfolgt nicht Element für Element
(lineare Algebra, für Anwendungen in unserem Fachgebiet in der Regel
nicht relevant).
Um dies zu erreichen, verwendet man den Operator .*
(array multiplication, element-by-element product)
Um jedes Element einer Matrix mit 5 zu multiplizieren, kann man sie auch
einfach mit einem Skalar (also hier 5) multiplizieren. Dieses Verfahren
nennt sich «scalar expansion»
Wenn man sich über die Funktion eines Operators unsicher ist, probiert man es am besten einfach im
Direktmodus aus, bevor man die Operation ins Programm einfügt.
Die Rangfolge für die Ausführung verschiedener Operationen gehorcht den allgemeinen mathematischen
Regeln (z.B. «Punkt vor Strich»), wie üblich muss hier mit Klammern gearbeitet werden, wenn eine andere
Rangfolge notwendig ist.
Die Hilfe dazu erhält man mit dem Stichwort operator precedence im Hilfesystem.
58
Funktionen
Matlab bietet eine Unmenge an vordefinierten mathematischen Funktionen (z.B. Sinus, Mittelwert, Wurzel
etc.).
Hilfe dazu findet man im Hilfesystem bei "Contents" unter Function reference > Mathematics >
Elementary math
Einige Beispiele für mathematische Funktionen:
>> data = magic(10);
>> sum(data)
>> sum(sum(data))
>> min(data)
>> max(data)
>> std(data)
>> sin(data)
>> round(pi)
>> why
sum bildet die Summe in Spalten
Für die Gesamtsumme kann man zwei Statements verschachteln
Minimum und Maximum pro Spalte
Standardabweichung in Spalten
Funktionen wie Sinus berechnen das Resultat für jedes Element separat
Rundungsfunktion
Auch eine Funktion: Antwort auf alle möglichen Fragen...
59
Aufgabe 2: Umsetzen einer mathematischen Formel
Setzen Sie folgende Formel der Gauss'schen Glockenkurve 6 um.
m ist der Mittelwert oder Erwartungswert (Peak der Kurve)
s ist die Standardabweichung ("Breite" der Kurve)
x ist der unabhängige Wert
e ist die Exponentialfunktion, in Matlab mit exp ausführbar. Die Wurzelfunktion heisst sqrt (Engl: square
root)
>> m = 3; s = 5; x = 2;
>> y = ...
Definition der Eingabewerte
Wie muss die Formel notiert werden? Als Resultat sollte man 0.0782 erhalten.
Musterlösung
>> m = 3; s = 5; x = 2;
>> y = 1/(s*sqrt(2*pi))*exp(-1/2*((x-m)/s)^2)
60
Aufgabe 3: Überprüfung eines magischen Quadrates
Überprüfen Sie die Korrektheit eines 7x7 magischen Quadrates: Die Summe aller Zeilen, Spalten und
der beiden Diagonalen müssen gleich sein.
>> m = magic(7);
>> ...
Musterlösung
>> m = magic(7);
>> sum(m) % Summe in Spalten
>> sum(m') % m transponieren, um die Zeilensummen zu erhalten
>> sum(diag(m)) % Summe in der Hauptdiagonalen
>> sum(diag(fliplr(m))) % die andere Diagonale
61
Zusammenfassung
Die wichtigsten Merkpunkte und Befehle finden Sie wie gewohnt in der
Zusammenfassung.
Merkpunkte
•
•
Die Rangfolge für die Ausführung verschiedener Operationen gehorcht den
allgemeinen mathematischen Regeln (z.B. «Punkt vor Strich»), wie üblich muss
hier mit Klammern gearbeitet werden, wenn eine andere Rangfolge notwendig ist.
Die Übersicht über die Operatoren finden Sie mit docsearch
'arithmetic operators'
•
Addition und Subtraktion ganzer Matrizen erfolgt Element für Element.
•
Will man ganze Matrizen Element für Element multiplizieren oder dividieren, ist
eine spezielle Notation notwendig: a .* b beziehungsweise a ./ b
Andernfalls führt Matlab eine Matrizenmultiplikation bzw. -division aus, die
gemäss linearer Algebra etwas anderes (und für Anwendungen in der Psychologie
kaum relevant) ist.
Hilfesystem: In "Contents" unter Function reference > Mathematics >
Elementary math findet man die Funktionsübersicht.
•
Anweisungen
•
•
•
•
•
sum: Summe
min, max: Minimum und Maximum
std: Standardabweichung
sin, cos, tan etc.: trigonometrische Funktionen
round: Rundung
62
Testfragen
Bitte versuchen Sie zur Überprüfung ihres Verständnisses folgende Fragen zu beantworten.
Benutzeroberfläche
Mit welchem Befehl können Sie das Command Window löschen?
❍ clear
❍ clc
❍
home
❍
clrcmd
Was können Sie im Workspace-Fenster NICHT tun?
❍ Variablen aus dem Workspace entfernen
❍ Den Inhalt von Variablen verändern
❍
Daten aus externen Quellen einlesen
❍
Berechnungen vornehmen
Wie wählen Sie die Verzeichnisse aus, in denen Matlab nach Funktionen (m-Files) sucht?
❍ Über den Current Directory-Browser
❍ mit cd (change directory)
❍
Über den Menupunkt File > Set Path
Hilfe-System
Finden Sie im Hilfe-System die Antwort auf folgende Frage:
Die Funktion zum Zeichnen eines dreidimensionalen Scatterplots lautet ___________ .
Matrizen
Welcher Befehl erzeugt die folgende Matrix a?
❍
❍
❍
❍
a
a
a
a
=
=
=
=
[
[
(
[
1
1
1
1
5
5
5
6
8 3,
8 3;
8 3;
0; 5
6
6
6
6
6 7 1,
6 7 1;
6 7 1;
1; 8 7
0 1 0 8]
0 1 0 8]
0 1 0 8)
0; 3 1 8 ]
Welche Anweisungsfolge bewirkt, dass die abgebildete Matrix im Command Window ausgegeben wird?
❍
❍
a=[0 8 3;3 5 5]; b=a'; b(1,:)=NaN; [a b]
a=[0 8 3;3 5 5]; b=transpond(a); b(1,:)=[]; [a b]
63
❍
❍
a=[0 8 3;3 5 5]; b=a'; b(1,:)=[]; [a b]
a=[0 8 3;3 5 5]; b=a'; b=b(2:3,:); [a; b]
Mathematische Operationen
Welcher Code entspricht der folgenden Formel?
❍
❍
❍
❍
y
y
y
y
=
=
=
=
2*exp(-t/tau)/sqrt(x+1*x-1)
2*exp(-t/tau)/sqrt((x+1)*(x-1))
2(exp(-t/tau)/sqrt((x+1)*(x-1)))
2*e^(-t/tau)/sqrt((x+1)*(x-1))
64
Glossar
EEG:
Elektro-Enzephalographie: Registrierung der Gehirnströme
fMRI:
Funktionale Magnetresonanztomographie (functional magnetic resonance imaging)
Glockenkurve:
Dichtefunktion normalverteilter Daten
Matrix:
Die wichtigste Art der Repräsentation von Daten in Matlab. In der Mathematik ist eine Matrix (Plural:
Matrizen) eine Tabelle von Zahlen oder anderen Größen. Matrizen unterscheiden sich von einfachen
Tabellen dadurch, dass mit ihnen gerechnet werden kann.
Mit dem Ausdruck Matrix ist meist eine zwei- oder höherdimensionale Matrix gemeint (vgl. Skalar,
Vektor).
Skalar:
«nulldimensionale» Matrix, d.h. nur ein Element
Vektor:
eindimensionale Matrix, also nur eine Zeile bzw. eine Spalte
65
Lektion 2: Programmieren in Matlab
Grundsätzlich wird unter einem Programm eine Folge von Anweisungen verstanden, die bei der
Ausführung des Programmes abgearbeitet werden. Die Reihenfolge der Ausführung der Anweisungen
wird durch Programm-Kontrollstrukturen wie Schleifen oder bedingte Verzweigungen bestimmt. Diese
Anweisungsfolge ist in einer Datei gespeichert und kann dadurch immer wieder aufgerufen werden.
Lernziele
•
•
•
•
•
Sie kennen die wichtigsten Funktionen des Editors
Verständnis der Unterschiede zwischen Skripten und Funktionen
Sie können einfache Skripte und Funktionen schreiben
Sie kennen die wichtigsten Schleifen- und Verzweigungsstrukturen
Sie wissen, wie man mit Zeichenketten arbeitet
66
m-Files: Skripte und Funktionen
Alle in Matlab erstellten Programme liegen als sogenannte m-Files mit der Dateiendung .m vor - dies gilt
auch für die meisten bei Matlab mitgelieferten Funktionen. Wie diese erstellt und ausgeführt werden können,
erfahren Sie in dieser Lerneinheit.
Es existieren zwei Arten von Programm- oder m-Files: Skripte und Funktionen.
Skripte
Ein Skript enthält eine Folge von Anweisungen, die genauso arbeitet, wie wenn diese Anweisungen direkt
nacheinander im Command Window eingegeben würden. Entsprechend können Skripte auf alle Variablen im
Workspace zugreifen, und die von Skripten erzeugten Variablen werden im Workspace abgelegt.
Funktionen
Eine Funktion zeichnet sich dadurch aus, dass ihr (meistens) Werte übergeben werden, die sie verarbeiten soll,
und dass sie die Resultate an den «Aufrufer» (aus dem Command Window oder aus einem anderen Skript bzw.
Funktion) zurückgibt. Dies ist also gleich wie bei den Standardfunktionen wie z.B. der Mittelwertberechnung a
= mean(b). Der Funktion wird die Matrix b übergeben, und sie retourniert den berechneten Mittelwert a.
Der Editor/Debugger
Damit Sie überhaupt beginnen können, Skripte und Funktionen zu erstellen, müssen Sie zuerst das
entsprechende «Werkzeug» kennenlernen, nämlich den Editor. Wie der Name sagt, kann man damit Dateien oder eben m-Files - editieren. Dies geschieht im nächsten Abschnitt.
Gleichzeitig dient dieses Programm als sogenannter «Debugger», also als Hilfsmittel, um im geschriebenen
Programm Fehler (bugs) zu suchen und beheben (engl. debugging). Dies wird erst später in der Lektion 3 im
Abschnitt Anwendung: Externe Dateien demonstriert.
67
Der Editor/Debugger
Um Programme zu schreiben, wird der in Matlab eingebaute Editor verwendet. Dieser ist gleichzeitig der sog.
Debugger, also das Werkzeug, das die Fehlersuche in Programmen unterstützt.
Der Debugger wird in Lektion 3 im Beispiel: Daten Einlesen demonstriert.
Der Editor kann auf verschiedene Arten aufgerufen werden:
•
Durch Eingabe von edit oder edit funktionsname (bzw. skriptname)
•
durch Markieren eines Funktionsnamens im Command Window und Anwahl von open über das
Kontextmenu (rechte Maustaste bzw. ctrl-Klich auf Macs mit Eintasten-Maus)
oder dasselbe im Directory Browser.
•
Bitte beachten (für einige ältere Versionen von Matlab): Wenn man aus dem Dateimanager von
Windows heraus ein m-File (ein Matlab-Programmfile mit der Endung .m) doppelclickt, wird ebenfalls
der Editor von Matlab aktiviert, aber ohne Debug-Funktionen.
Demonstration des Editors: Bitte führen Sie die nachfolgenden Schritte aus, um das Prinzip des
Erstellens von Programmen im Editor zu erfahren.
•
•
Starten Sie den Editor durch Eingabe von edit im Command Window. Dabei öffnet der Editor auch
gerade ein «leeres» m-File.
Kopieren Sie die nachfolgenden Befehle mittels Copy/Paste in das Editor-Fenster.
[X,Y,Z] = peaks(30);
surfc(X,Y,Z)
colormap hsv
axis([-3 3 -3 3 -10 5])
•
•
Speichern Sie das Programm mittels File > Save as... unter dem Namen editordemo.m. Speicherort
ist dasjenige Verzeichnis, das Sie früher im Schritt Konfiguration von Matlab als Pfad für m-Files
definiert haben.
Gehen Sie ins Command Window und geben Sie editordemo ein; nun wird das Programm
ausgeführt.
68
So sollte das ungefähr auf Ihrem Bildschirm aussehen
69
Programmieren von Skripten
Ein Skript ist eine externe Datei, die eine Folge von Anweisungen enthält. Matlab arbeitet diesen Skript genauso
ab, wie wenn diese Anweisungen direkt nacheinander «von Hand» im Command Window eingegeben würden.
Skripte können auf alle Variablen im Workspace zugreifen, und die von Skripten
erzeugten Variablen werden entsprechend im Workspace abgelegt.
Struktur eines Skriptes
•
•
•
•
•
Programmzeilen: Meistens wird man auf jeder Programmzeile nur einen Befehl notieren. Ein
Strichpunkt nach dem Befehl verhindert, dass die erzeugten Werte im Command Window ausgegeben
werden.
Es ist aber auch möglich, mehrere Befehle pro Zeile zu schreiben; diese werden dann mittels Komma
getrennt, oder mittels Strichpunkt, wenn man zugleich die Ausgabe ins Command Window verhindern
will.
Kommentare werden mit dem Prozentzeichen % gekennzeichnet. Alles, was auf einer Programmzeile
nach diesem Zeichen erscheint, wird von Matlab nicht interpretiert.
Kopfzeilen/Hilfetext: Wie in der nachfolgenden Abbildung gezeigt, beginnt ein Skript in gutem
Programmierstil mit einigen Kommentarzeilen, die die Funktion des Skriptes beschreiben.
Diese Zeilen (bis zur ersten Leerzeile) werden ausgegeben, wenn man im Command Window mit help
skriptname)die Hilfe zu diesem Skript aufruft.
Leerzeilen: Zur visuellen Strukturierung eines Programmes lassen sich beliebig Leerzeilen einfügen,
diese beeinflussen den Programmablauf nicht.
Erstellen von Skripten
Wie im Beispiel im vorhergehenden Abschnitt gezeigt, geht das Erstellen von Skripten wie folgt vor sich:
•
Öffnen des Editors. Dabei wird eine leere Datei eröffnet.
•
Schreiben der Anweisungen im Editorfenster
•
Abspeichern des Skriptes als m-File unter einem neuen Namen
Ausführung eines Skriptes
Durch Eingabe des Skriptnamens (= Dateiname, ohne .m) im Command Window oder aus einem anderen
Skript oder einer Funktion heraus.
70
Ein einfacher Skript. Im Command Window sieht man die Ausgabe beim Aufruf des Skriptes sowie der Hilfe dazu
71
Aufgabe 4: Programmieren eines Skriptes
In dieser Aufgabe geht es darum, aus den Kommandos, die Sie in der Aufgabe 1 gefunden haben, einen Skript
1
zu erstellen, der dann immer wieder aufgerufen werden kann. Wie das geht, haben Sie im vorangehenden
Abschnitt bereits gesehen.
Verfassen Sie einen Skript, der die Datenmatrix aus Aufgabe 1 erzeugt (aber ohne die NaN-Werte!),
Mittelwert und Standardabweichung der Daten in Spalte 13 pro Gruppe berechnet und diese Werte im
Command Window ausgibt.
Spalte 1: Versuchspersonennummer
Spalte 2: 1. oder 2. Durchführung des Experimentes
Spalten 3-12: markieren verschiedene Experimentalbedingungen
Spalte 13: normalverteilte Zufallsdaten (sie müssen nicht identisch mit den abgebildeten Werten sein).
Zu erzeugende Datenmatrix
Speichern Sie den Skript z.B. unter dem Namen exercise4.m in Ihrem Arbeitsverzeichnis (dasjenige, das Sie
im Abschnitt Vorbereitung/Materialien angelegt haben). Die Erzeugung der Datenmatrix können Sie aus
Ihrer eigenen Lösung von Aufgabe 1 übernehmen, oder aus dem untenstehenden Kasten.
Hinweise: Die Ausgabe ins Command Window erfolgt entweder mit der Notierung des Variablennamens (wie
im Direktmodus) bzw. des Weglassens des Strichpunktes am Ende einer Berechnung, oder mit der Funktion
disp(Variablenname). Weitere benötigte Funktionen: mean, std
% Aufgabe 4: Dieser Skript erzeugt die Datenmatrix aus Aufgabe 1,
1
Ein Skript ist eine in einer Datei (m-File) abgespeicherte Folge von Anweisungen. Diese werden genauso argearbeitet, wie wenn diese
Anweisungen Command Window eingegeben würden.
72
% berechnet Mittelwert und Standardabweichung pro Gruppe und gibt
% diese Werte im Command Window aus.
% Matrix erzeugen
testdata = (27:36)';
testdata = [testdata ones(1, 10)' eye(10)];
testdata = repmat(testdata, 2, 1);
testdata(11:20, 2) = 2;
testdata(:,13) = randn(20,1);
% Berechnungen und Ausgabe
...
Musterlösung (öffnet in neuem Fenster)
Die Lösung ist auch im m-File exercise4_sol.m (aus dem heruntergeladenen File examples.zip) zu finden.
73
Programmieren von Funktionen
Selbst erstellte Funktions-m-Files 2 werden auf die gleiche Weise angewandt wie die von Matlab
bereitgestellten Funktionen wie z.B. sin (Sinusfunktion), d.h. sie werden mit ihrem Namen (= Name des mFiles) und entsprechenden Argumenten aufgerufen, also z.B.
y = sin(x)
Eine Funktion zeichnet sich dadurch aus, dass ihr (meistens) Werte übergeben werden, die sie verarbeiten soll,
und dass sie die Resultate an den «Aufrufer» (aus dem Command Window oder aus einem anderen Skript bzw.
Funktion) zurückgibt.
Der Hauptvorteil von Funktionen ist ihre Wiederverwendbarkeit. Aufgaben, die in verschiedenen
Anwendungen immer wieder ausgeführt werden sollen, müssen so nur einmal geschrieben werden. Gibt
es Änderungen, müssen diese nur einmal in der Funktion gemacht werden; automatisch wird sie für jedes
Programm relevant, das die Funktion aufruft.
Funktionen ermöglichen so effizienteres Programmieren, und die Programme selbst werden kompakter und
damit auch besser les- und wartbar.
Funktionen sind datenmässig «gekapselt» (encapsulated), d.h. sie haben nur auf
diejenigen Variablen Zugriff, die ihnen beim Aufruf übergeben werden. Der Workspace,
wie Sie ihn bis jetzt kennen, ist für die Funktion «unsichtbar». Während der
Ausführung einer Funktion erhält sie quasi einen eigenen temporären Workspace, der die
übergebenen, zurückzugebenden und allfälligen funktions-intern definierten Variablen
enthält. Dieser wird nach der Beendigung der Funktion wieder gelöscht.
Struktur einer Funktion
Eine Funktion unterscheidet sich formal nur durch die erste Zeile von einem Skript. Sie enthält die sogenannte
Funktionsdefinition. Dadurch wird folgendes festgelegt:
•
•
•
Name der Funktion. Dieser muss identisch mit dem Dateinamen sein, unter dem die Funktion als mFile gespeichert wird.
Eingabeparameter: Sie legen fest, welche Werte der Funktion übergeben werden können.
Rückgabeparameter: Sie spezifizieren die Werte, durch die die Funktion die Berechnungsresultate
zurückgeben kann.
Beispiel 1: m-File gauss1.m
Einfache Funktion mit je einem Eingabe- und Rückgabeparameter.
Bitte öffnen Sie diese Funktion im Editor. Sie sollte ihn Ihrem Verzeichnis für m-Files liegen, und stammt aus
dem Zip-File examples.zip.
function y = gauss1(x)
% Berechnet den Wert der Gauss'schen Glockenkurve, mit fixem Mittelwert
% und Standardabweichung
% noch ein Kommentar (wird bei Eingabe von help gauss1 NICHT angezeigt)
2
Eine Datei mit der Endung .m, welche eine Folge von Matlab-Befehlen enthält. Es kann sich dabei um einen Skript oder eine Funktion
handeln.
74
s = 5; % Sigma
m = 3; % Mittelwert
y = 1/(s*sqrt(2*pi))*exp(-1/2*((x-m)/s)^2);
Erläuterungen
•
Zur Gauss-Funktion siehe Aufgabe 2 in Lektion 1.
•
Zeile 1: Hier wird die Funktion mit den Ein- und Ausgabe-Parametern definiert. gauss1 ist der
Funktionsname und muss mit dem Namen des m-Files übereinstimmen. x bezeichnet den Wert, der der
Funktion übergeben wird. y ist der Wert, der das berechnete Resultat an den Aufrufer zurückgibt.
Zeile 2 und 3 enthalten eine Kurzbeschreibung der Funktion als Kommentar. Es entspricht gutem
Programmierstil, alle Funktionen mit entsprechenden Erklärungen zu versehen, damit man auch nach
einem halben Jahr noch weiss, was sie tun, oder jemand anderes die Funktion verstehen kann. Alle
Kommentarzeilen bis zur ersten Leerzeile werden ausgegeben, wenn im Command Window help
gauss1 eingegeben wird.
in der letzten Zeile wird die Berechnung ausgeführt. Als x wird also der Wert übernommen, der der
Funktion beim Aufruf übergeben wird, y wird zurückgegeben.
•
•
Anwendung der Funktion:
>> resultat = gauss1(2)
Beispiel 2: m-File gauss2.m
Funktion mit mehreren an die Funktion übergebenen Parametern.
function y = gauss2(x, m, s)
% Berechnet den Wert der Gauss'schen Glockenkurve mit variablem Mittelwert
% und Standardabweichung
y = 1/(s*sqrt(2*pi))*exp(-1/2*((x-m)/s)^2);
Erläuterungen: Nun sind auch m und s variabel und müssen der Funktion beim Aufruf übergeben werden.
>> resultat = gauss2(2, 3, 5)
Beispiel 3: m-File stats.m
Funktion mit mehreren an den Aufrufer zurückgegebenen Parametern. Diese werden in eckigen Klammern
notiert.
Dies ist der einzige Fall, in dem die eckigen Klammern [ ] nicht eine Matrix bezeichnen, sondern
einfach eine Liste von Rückgabeparametern.
% Berechnet statistische Kennwerte für einen Zeilenvektor
%
% INPUT : M_in - Eingangsvektor mit Daten
% OUTPUT: mittelw - Mittelwert
75
% stdabw - Standardabweichung
% minimum - Minimalwert
% maximum - Maximalwert
function [mittelw, stdabw, minimum, maximum] = stats(M_in)
% Bemerkung: Der Funktionsname kann am Anfang der Datei stehen, oder
% auch erst nach den Hilfe-Zeilen.
mittelw = mean(M_in);
stdabw = std(M_in);
minimum = min(M_in);
maximum = max(M_in);
>> M_in = randn(1, 300)*100+100
>> [m, s, mnm, mxm] =
stats(M_in)
>> stats(M_in)
>> a = stats(M_in)
>> [s1, s2, s3] = stats(M_in)
Zeilenvektor mit Zufallszahlen erzeugen
alle 4 Rückgabeparameter abfragen
Es ist auch möglich, nicht alle 4 Rückgabeparameter abzuholen dann wird einfach "von vorne nach hinten" aufgefüllt.
76
Spezialfälle
Spezialfall 1: Funktionen ohne Parameter
Soll eine Funktion geschrieben werden, die keine Eingabewerte benötigt (z.B. eine Funktion, die spezielle
Zufallszahlen generiert), oder keine Werte zurückliefert (sondern z.B. eine Grafik erzeugt), sieht die Notation
wie folgt aus:
>> function zahlen = randomx()
Keine Eingabeparameter: einfach die Klammer leer lassen
>>
function
[]
= keine Rückgabeparameter, zwei Möglichkeiten
draw_graph(M_in)
>> function draw_graph(M_in)
Spezialfall 2: Variable Anzahl Parameter
Es ist gelegentlich notwendig, Funktionen zu haben, bei denen nicht fix vorgegeben ist, wieviele Ein- oder
Rückgabeparameter vorkommen.
function string = strxcat(varargin) variable Anzahl Eingabeparameter
varargout = readsomenumbers(fid) variable Anzahl Rückgabeparameter
Die Variablen varargin (variable number of arguments IN) bzw. varargout (variable number of
arguments OUT) sind Cell arrays, ein spezieller Datentyp, der Daten verschiedenster Art enthalten kann. Mehr
über Cell arrays 3 erfahren Sie in der Lektion 4, Kapitel Cell arrays.
Als Beispiel für eine Funktion mit variabler Anzahl Eingabeparameter mag die Funktion strxcat dienen,
die auch an anderer Stelle erwähnt wird:
function string = strxcat(varargin)
% A variable number of strings or numbers are concatenated into the output string.
%
% INPUT : n strings or numbers
% OUTPUT: string
string = [];
nbarg = length(varargin);
if nbarg == 0
return
end
for arg_i = 1:nbarg
substr = varargin{arg_i}(:)';
string = [string num2str(substr)];
end
Erläuterungen: Als erstes wird mit length die Anzahl übergebener Zeichenketten (Strings 4) nbarg
ermittelt.
3
«Zellen-Felder». In jedem Feld eines Cell Arrays können unterschiedliche Datentypen abgelegt werden, z.B. Matrizen unterschiedlicher
Grösse.
4
Zeichenkette. Ein Vektor bzw. eine Matrix deren Elemente ASCII-codierte Zeichen (character) interpretiert werden.
77
Eine Schleife mit arg_i wird dann entsprechend oft durchlaufen. Darin wird das arg_i-te Element
extrahiert, wenn nötig von einer Zahl in einen String umgewandelt, und auf der zweitletzten Zeile zu den
vorherigen Strings hinzugefügt.
78
Zusammenfassung
Merkpunkte
•
•
•
•
•
•
Ein Skript enthält eine Folge von Anweisungen, die genauso arbeitet, wie
wenn diese Anweisungen direkt nacheinander im Command Window eingegeben
würden.
Ein Skript wird im Command Window aufgerufen, indem man seinen Dateinamen
(ohne .m) eingibt. Auf dieselbe Weise kann ein Skript aus einem anderen Skript
oder einer Funktion aufgerufen werden.
Skripte können auf alle Variablen im Workspace zugreifen, und die von Skripten
erzeugten Variablen werden wiederum im Workspace abgelegt.
Eine Funktion unterscheidet sich von einem Skript dadurch, dass ihr (meistens)
Werte übergeben werden, die sie verarbeiten soll, und dass sie Resultate an den
«Aufrufer» zurückgibt.
Im Gegensatz zu Skripten sind Funktionen sind datenmässig «gekapselt», d.h. sie
haben auf die Variablen im allgemeinen Workspace keinen Zugang, sondern nur
auf diejenigen Variablen, die ihnen beim Aufruf übergeben werden.
Während der Ausführung einer Funktion erhält sie quasi einen eigenen temporären
Workspace, der die übergebenen, zurückzugebenden und allfälligen funktionsintern definierten Variablen enthält.
Ein Strichpunkt am Ende einer Anweisung auf einer Programmzeile verhindert die
Ausgabe der erzeugten Zahlenwerte im Command Window.
Anweisungen
•
•
function
[Rückgabevariablen]
Funktionsname(Variablen für übergebene Werte)
=
Definitionszeile einer Funktion mit Übergabe- und Rückgabevariablen
disp(): Ausgabe von Werten ins Command Window
79
Programm-Kontrollstrukturen: Schleifen
Schleifen ermöglichen, eine Reihe von Anweisungen für eine bestimmte Anzahl von Durchläufen zu
wiederholen. Es gibt zwei Arten von Schleifen:
•
die for-Schleife: Sie wird angewandt, wenn vorbestimmt ist, wie oft sie durchlaufen werden muss
•
die while-Schleife: Damit kann die Anzahl der Wiederholungen von einem Vergleich innerhalb der
Schleife abhängig gemacht werden
80
Die for-Schleife
Die for-Schleife wird immer dann eingesetzt, wenn vorbestimmt ist, wie oft eine Folge
von Anweisungen durchgeführt werden soll.
Die Syntax der for-Schleife lautet schematisch:
for indexvar = range
anweisung 1
...
anweisung n
end
indexvar - der sog. Schleifenindex. Dieser wird bei jedem Durchlauf auf den jeweils nächsten Wert von
range gesetzt und kann als normale Variable innerhalb der Schleife verwendet werden. Dafür kann man
einen beliebigen Variablennamen verwenden.
range - Zeilenvektor oder Matrix. Bestimmt, welche Werte indexvar annimmt.
Beispiele für for-Schleifen
Bitte versuchen Sie, die Funktionsweise der for-Schleife anhand der Beispiele nachzuvollziehen.
Einfache for-Schleife:
>> for index = 1:30
>> facts = factor(index);
>> disp(facts)
>> summe = sum(facts);
>> end
Matlab tut nichts, bis es auf end trifft
die Primfaktoren des Schleifenindex' berechnen
ausgeben
weitere Anweisungen
hiermit wird die Schleife abgeschlossen und ausgeführt
Grundsätzlich sind für den Schleifenindex alle Notationen von Vektoren verwendbar:
>> for i = pi:-.3:-pi, i, end
>> for i = [1 4 7 11 13 17 3 5], i, end
>> for i = rand(1,10) * 20, i, end
beliebige Zahlenreihe
Aufzählung
durch Funktion erzeugter Vektor,
aber nur Zeilenvektoren
Wird eine Matrix als range angegeben, wird dem Schleifenindex jeweils eine Spalte von range
zugewiesen. D.h. die Schleife wird so oft durchlaufen, wie die Matrix Spalten besitzt.
>> for i = magic(7), i, end
81
Die while-Schleife
Die while-Schleife wird eingesetzt, wenn die Anzahl Wiederholungen von einem
Vergleich abhängig gemacht werden soll, der jedes Mal ausgewertet wird, wenn die
Schleife durchlaufen wird (gewöhnlich am Anfang der Schleife).
Die Syntax der while-Schleife lautet in Pseudo-Code:
while vergleich
anweisung 1
...
anweisung n
end
Die Schleife wird solange durchlaufen, wie der vergleich wahr (true, Wert > 0) ist. Der Vergleich
wird immer am Anfang der Schleife vorgenommen. Wird er das erste mal falsch (false, Wert = 0),
wird die Schleife abgebrochen, und die Ausführung geht bei der ersten Anweisung nach der Schleife
(korrespondierendes end) weiter.
Detaillierte Informationen dazu, wie man Vergleiche formulieren kann, erhalten Sie später im Abschnitt
Vergleichsoperatoren und logische Verknüpfungen.
Eine einfache while-Schleife:
>> index = 1;
>> while index <= 30
>> disp(factor(index))
>> index = index + 1;
>> end
Schleife durchlaufen, solange index kleiner oder gleich 30 ist
Primfaktoren ausgeben
index inkrementieren
82
Abbruch von Schleifen mit break
Es ist möglich, for- und while-Schleifen durch die Anweisung break zu verlassen, auch wenn sie eigentlich
noch nicht «fertig» ist.
Auf diese Weise kann zum Beispiel eine while-Schleife geschrieben werden, deren Vergleichsoperation am
Ende der Schleife oder irgendwo mittendrin ausgeführt wird, statt am Anfang. Oder man kann eine for-Schleife
bedingt verlassen, bevor der Schleifenindex den letzten Wert erreicht hat.
Beispiel 1: for-Schleife mit vorzeitigem Abbruch
>> for index = 1:30
>> disp(sum(factor(index)))
>> if index == 20, break, end
>> end
schon abbrechen, wenn der Index 20 ist
Beispiel 2: while-Schleife mit break
index = 1;
while true
disp(factor(index))
if index > 30
break
end
index = index + 1;
end
Erläuterung
true (oder auch 1) heisst im while-Statement: Vergleich wahr, hier also: IMMER (Gegenstück: false
oder 0).
83
Aufgabe 5: Gauss-Funktion für einen Vektor
Schreiben Sie die Gauss-Funktion Version 2 (m-File gauss2.m) mittels einer Schleife so um (als
gauss3.m speichern), dass sie die Werte für einen Zeilenvektor berechnet, und als Vektor wieder
ausgibt. Also:
function Moutput = gauss3(Minput, m, s)
% Berechnet die Werte der Gauss'schen Glockenkurve für den Zeilenvektor
% Minput, mit dem Mittelwert m und der Standardabweichung s
...
Dann die Funktion mit den Werten -5 bis 5 (Schrittweite 0,1) aufrufen, und die resultierenden Werte mit plot
grafisch darstellen.
Die Lösung ist auch im m-File gauss3_sol.m zu finden.
84
Vektorisierung von Schleifen
Dank der Datenrepräsentation als Matrizen ist es in Matlab in vielen Fällen möglich, Berechnungen von ganzen
Datensätzen sehr viel effizienter durchzuführen, als das mittels Schleifen möglich wäre.
Bitte schauen Sie sich das an folgendem Beispiel an:
Eine Möglichkeit, mit den bisher bekannten Mitteln den Sinus von 1001 Werten von 0 bis 10 zu berechnen
und im Zeilenvektor y abzuspeichern, ist:
>> i = 0;
>> for t = 0:.01:10
>> i = i + 1;
>> y(i) = sin(t);
>> end
Die «vektorisierte» Version ist viel einfacher und schneller:
>> t = 0:.01:10;
>> y = sin(t);
Oder noch kompakter:
>> y = sin(0:.01:10);
85
Zusammenfassung
Merkpunkte
•
•
Die for-Schleife wird immer dann eingesetzt, wenn vorbestimmt ist, wie oft eine
Folge von Anweisungen durchgeführt werden soll.
Die while-Schleife wird eingesetzt, wenn die Anzahl Wiederholungen von einem
Vergleich abhängig gemacht werden soll.
Anweisungen
•
•
•
for index=1:n
(div. Anweisungen)
end
Wiederholungsschleife. Für 1:n kann ein beliebiger Vektor eingesetzt werden.
while (Bedingung)
(div. Anweisungen)
end
Schleife mit bedingtem Abbruch. Die Anweisungen werden solange durchlaufen,
wie die Bedingung erfüllt (true, Wert > 0) ist. Der Vergleich wird immer am
Anfang der Schleife vorgenommen.
break: Damit können for- und while-Schleifen abgebrochen werden.
86
Programm-Kontrollstrukturen: bedingte Verzweigungen
In fast jedem Programm ist es notwendig, Anweisungen nur unter bestimmten Bedingungen auszuführen. Dafür
verwendet man sogenannte bedingte Verzweigungen.
Matlab stellt dafür zwei Konstrukte zur Verfügung:
•
die if-elseif-else-Struktur, und
•
die switch-case-Struktur.
87
Die Verzweigungsstruktur if-elseif-else
Die Anwendung dieser Programmstruktur können Sie anhand folgender Beispiele erschliessen.
Beispiel 1: if-else-Struktur mit zwei Fällen
Laden Sie dazu das m-File example_if.m in den Editor. Dort können Sie es mit der Taste F5 ausführen lassen,
oder aus dem Command Window example_if eingeben, um den Skript auszuführen.
% Beispiel 1 für if-else
a = rand(20) * 100 - 20; % Zufallszahlen erzeugen
for i = 1:length(a)
if a(i) < 0
disp([num2str(a(i)) ': Zahl unter Null'])
else
disp([num2str(a(i)) ': Zahl über Null'])
end
end
Erläuterungen: Der zusammengesetzte Ausdruck nach disp bewirkt, dass die entsprechende Zahl mit dem
Text zusammen ausgegeben wird. Die Funktion num2str werden wir später genauer anschauen (s. hier).
Beispiel 2: if-else-Struktur mit mehreren Fällen
Sie können dazu wiederum das entsprechende m-File example_if_elseif.m in den Editor laden.
%% Beispiel 2 für if-elseif-else
a = rand(20) * 100 - 20;
for i = 1:length(a)
if a(i) < 0
disp([num2str(a(i)) ': Zahl unter Null'])
elseif a(i) >= 0 && a(i) <= 20 % ist die Zahl >= 0 UND <= 20?
disp([num2str(a(i)) ': kleine Zahl'])
else
disp([num2str(a(i)) ': grosse Zahl'])
end
end
Erläuterungen: Es ist natürlich möglich, beliebig viele elseif-Vergleiche einzufügen.
88
Die switch-case-Struktur
Wenn im Rahmen einer if-elseif-else-Struktur sehr viele Einzelvergleiche mit derselben Variablen gemacht
werden müssen, bietet sich die switch-case-Struktur an:
Ihre Syntax lautet schematisch:
switch indicator
case expr
anweisung, ..., anweisung
case {expr1, expr2, expr3, ...}
otherwise
end
indicator ist die Variable, welche die verschiedene Bedingungen enthalten kann. Sie kann sowohl ein
Skalar als auch ein String (Character Array) sein.
Die case-Anweisung vergleicht indicator mit expr. Stimmen diese überein, werden die
nachfolgenden Anweisungen innerhalb des entsprechenden case-Abschnittes durchlaufen. Anschliessend
wird das Programm nach dem end fortgesetzt.
expr enthalten die Vergleichswerte (Skalare oder Strings). Es kann sowohl ein einzelner Wert verwendet
werden, wie auch ein Cell Array mit mehreren Werten.
Nach otherwise folgen die Anweisungen, die durchlaufen werden, falls keiner der vorgängigen Vergleiche
zutraf.
Beispiel: Ersetzen eines Mehrfachvergleiches durch eine switch-case-Struktur
Betrachten Sie die folgende Umsetzung eines Mehrfachvergleiches mit if-elseif-else:
if strcmp(designator,'date')
% Anweisungen...
elseif strcmp(designator,'start')
% Anweisungen...
elseif strcmp(designator,'endtrial')
% Anweisungen...
elseif strcmp(designator,'fix') || strcmp(designator,'sacc') || strcmp(designator,'blink')
% Anweisungen...
else
% alles andere
end
Dies lässt sich eleganter und besser lesbar so formulieren:
switch designator
case 'date'
% Anweisungen...
case 'starttrial'
% Anweisungen...
case 'endtrial'
% Anweisungen...
case {'fix', 'sacc', 'blink'}
89
% Anweisungen...
otherwise
% alles andere
end
90
Vergleichsoperatoren und logische Verknüpfungen
In den beiden vorangehenden Beispielen haben Sie bereits verschiedene Vergleichsoperationen wie «kleiner
als» oder «grösser oder gleich als» gesehen.
Vergleichsoperatoren
Nachfolgend sind die grundlegenden Vergleichsmöglichkeiten dargestellt:
A
A
A
A
== B
~= B
< B bzw. A > B
<= B bzw. A >= B
Test auf Gleichheit (doppeltes Gleichzeichen!
Nicht zu verwechseln mit =, das wäre eine Zuweisung)
Test auf Ungleichheit. Die Tilde ~ bedeutet immer eine
logische Inversion, also NICHT
Test auf «kleiner» oder «grösser»
Test auf «kleiner oder gleich» bzw. «grösser oder gleich»
Als Resultat liefern Vergleichsoperationen entweder den Wert true (intern vordefiniert als 1, aber jeder Wert
> 0 wird als "wahr" interpretiert) oder false (intern vordefiniert als 0, Null).
Eine Übersicht über alle Möglichkeiten finden Sie im Hilfesystem unter dem Stichwort 'relational
operators'.
Verknüpfung von Vergleichen
Mehrere Vergleiche lassen sich auch logisch verknüpfen. Dafür stehen zwei logische Operatoren zur
Verfügung:
•
&& als UND-Verknüpfung: Der Ausdruck wird nur dann wahr, wenn Bedingung 1 und Bedingung 2
•
wahr sind.
|| als ODER-Verknüpfung: Diese bedeutet im Gegensatz zur Alltagssprache "A oder B oder beides"!
Beispiele:
>> true
>> false
>> x = 77; y = 12;
>> x < y
>> x ~= y
>> x <= 77 && y > 0
>> v = x == y
>> ~v
>> a=1:4; b=[1 3 5 7];
>> length(a)==4 || ~isempty(b)
>> a == b
die vordefinierten Werte
ist x kleiner als y?
ist x nicht gleich y?
&& und || kommen in der Reihenfolge zuletzt -> keine Klammern nötig
v enthält jetzt den Wahrheitswert 'false' oder 0
das ~ «invertiert» den Wahrheitswert (NOT-Funktion)
Vergleiche von Vektoren und Matrizen geschehen Element für Element!
Das geht nur, wenn die beiden gleich gross sind.
Solche Vergleiche stehen meist nach einem if-Statement, wie im vorherigen Abschnitt gezeigt.
>> if (x < y || y ~= 0) && (v == true || numel(a) == 4)
>> disp('das ist wahr')
>> else
>> disp('das ist falsch')
>> end
91
Übrigens: Falls eine Programmzeile so lang wird, dass sie unübersichtlich wird oder nicht
mehr ins Editorfenster passt, kann man sie mit ... aufteilen:
if (x < y || y ~= 0) ...
&& (v == true || numel(a) == 4)
92
Aufgabe 6: Standardisierungsfunktion
Schreiben Sie eine Funktion mit dem Namen standardize, welche die Daten in einer maximal
zweidimensionalen Matrix von Daten z-standardisiert (also auch Vektoren, jedoch keine Skalare, weil
mindestens zwei Datenpunkte vorhanden sein müssen).
Die Formel dafür lautet:
Die Funktion soll eine gleichgrosse Matrix mit den transformierten Werten zurückgeben, und auch den
Mittelwert und die Standardabweichung der Daten. Verwenden Sie für die Umsetzung mehrere for- oder whileSchleifen (überlegen Sie sich eventuell auch, ob und wie eine «vektorisierte» Lösung – also ohne Schleifen
– möglich wäre).
Die der Funktion übergebene Matrix soll vor der Berechnung auf Gültigkeit geprüft werden:
•
•
Ist sie leer oder enthält sie nur ein Element, soll die Funktion eine leere Matrix [ ] sowie den berechneten
Mittelwert und die Standardabweichung (die dann 0 beträgt oder NaN) zurückgeben und eine Warnung
ins Command Window schreiben.
Ist die Matrix mehr als zweidimensional, soll die Funktion abbrechen und eine entsprechende
Fehlermeldung ausgeben.
Tips für möglicherweise nützliche Funktionen (Funktion allenfalls im Hilfe-System nachschlagen):
mean, std, reshape, isempty, ndims, size, numel, disp, error, return
Die Lösung finden Sie auch im m-File standardize_sol.m, die «vektorisierte» Lösung heisst
standardize_vect.m
93
Zusammenfassung
Zusammenfassung der wichtigsten Punkte:
•
•
Verzweigungsstruktur mit mehrfachen Vergleichen:
if (Bedingung 1)
(Anweisungen)
elseif (Bedingung 2)
(Anweisungen)
else
(Anweisungen)
end
Verzweigungsstruktur mit Fallverzweigung:
switch indicator
case (Wert 1)
(Anweisungen)
case {Wert 2, Wert 3, Wert 4, ...}
(Anweisungen)
otherwise
(Anweisungen)
end
94
Repräsentation von Daten 2: Zeichenketten (Strings)
Bis anhin haben wir ausschliesslich mit Matrizen gearbeitet, welche Zahlen enthielten. Oft wird man aber auch
mit Texten arbeiten müssen, also «Zeichenketten» oder «Strings» (character strings). Ein Beispiel wäre, wenn
Sie Daten aus einer ASCII 5-Datei (z.B. Tabulator-getrennte Daten) einlesen und weiterverarbeiten wollen.
Oder wenn Sie Resultate oder Benutzungshinweise für den Anwender im Klartext ausgeben wollen.
Dafür bietet Matlab die Möglichkeit, in Matrizen auch Texte abzuspeichern. Dabei wird jede Zahl in einem
Element der Matrix als ASCII-codiertes Zeichen (character) interpretiert.
Dies ist eine oft verwendete, aber nicht die einzige und auch nicht immer die eleganteste Möglichkeit
zum Arbeiten mit Texten, wird aber der besseren Verständlichkeit halber als erstes eingeführt (vgl.
Lektion 3: Cell Arrays).
5
American Standard Code for Information Interchange, die gebräuchlichste Norm, um alphanumerische Zeichen zu repräsentieren.
95
Strings erzeugen und zusammenfügen
Als erstes müssen Sie wissen, wie man Zeichenketten (im folgenden auch als Strings bezeichnet) erzeugt. Meist
ist es auch notwendig, mehrere Strings zusammenzufügen, oder numerische Resultate in Strings umzuwandeln
und an einen anderen String anzuhängen.
Gehen Sie die folgenden Beispiele durch, um zu erfahren, wie das geht.
>> t1 = 'The quick brown fox jumps '
>> t2 = 'over the lazy dog.'
>> n = num2str(23.28)
>> ischar(t1)
>> m = str2num('3.1415926')
>> t3 = [t1 t2]
>> t4 = strcat(t1, t2)
Fixe Texte werden mit Hochkommata eingegeben
Umwandlung einer Zahl in einen String
ergibt true, wenn es sich um eine
Matrix mit Zeichen (characters) handelt
Umwandlung einer in einem String gespeicherten
Zahl in einen Skalar
Zusammenhängen von Texten wie bei
'normalen' Vektoren
so geht's auch. strcat = string concatenation
Will man mehrere Zeichenketten in einer Matrix abspeichern (also in Zeilen), ergeben sich die ersten
Komplikationen: Wie Sie wissen, müssen verschiedene Zeilen einer Matrix immer gleich lang sein. Matlab
wird also die Zeilen von kürzeren Texten mit Leerzeichen auffüllen (Funktion strvcat = string vertical
concatenation)!
>> z=['eins';'zwei';'drei']
>> z=['eins';'zwei';'drei';'sechs']
>> z=strvcat('eins','zwei','drei','sechs')
>> z1 = z(1, :)
>> length(z1)
>> z2 = deblank(z1), length(z2)
So geht's, alle sind gleich lang
So nicht, weil 'sechs' länger ist
korrekte Variante
erste Zeile abrufen
ist aber fünf Zeichen lang, ein
Leerzeichen wurde angefügt
deblank entfernt Leerzeichen am
Ende eines Strings
Eine hilfreiche Funktion: strxcat
Will man mehrere Strings und numerische Resultate zusammenfügen, führt das rasch zu relativ
unübersichtlichem und umständlichem Code. Um dies zu vermeiden, können Sie auf eine extra dafür
ausgelegte Funktion zurückgreifen (diese ist nicht im Matlab-Funktionsumfang enthalten, sie finden Sie in den
heruntergeladenen Beispielen).
Die Funktion strxcat ist wie folgt definiert:
function string = strxcat(varargin)
Sie dient dazu, eine beliebige Anzahl von Strings und Zahlen zu einem einzigen String zusammenzufügen.
Beispiel:
>> summe = fix(sum(rand(1, 3000)))/100
>> ausgabe = strxcat('Der Endbetrag lautet: ', summe, ' SFr.')
strxcat ist ein einfaches Beispiel für eine Funktion mit einer variablen Anzahl von
Eingabeparametern (vgl. Abschnitt Spezialfälle). Wenn Sie das interessiert, können Sie sich diese
Funktion im Editor genauer anschauen: edit strxcat
96
Strings untersuchen und vergleichen
Untersuchen von Strings auf bestimmte Inhalte
Oft wird man in Abhängigkeit des Inhaltes eines Strings Daten auf unterschiedliche Weise bearbeiten müssen.
Daher benötigen wir Operationen, die uns die Untersuchung der Inhalte von Strings erlauben.
Zu diesem Zweck stellt Matlab die leicht zu verwechselnden Funktionen strfind und findstr zur
Verfügung.
Diese lassen sich wieder am einfachsten anhand von Beispielen demonstrieren. Die Variablen der
vorhergehenden Beispiele dieser Lektion sollten sich dazu noch im Workspace befinden.
>> findstr(t3, 'fox')
>> findstr(t3, 'cat')
>> pos = strfind(t3, ' ')
Findet einen String in einem anderen.
Resultat: Startposition(en) der gefundenen Übereinstimmungen
Position aller Leerzeichen
Erläuterung: findstr vergleicht zwei Strings und schaut, ob der kürzere im längeren enthalten ist.
strfind findet ein Muster (zweites Argument) in einem String (erstes Argument). Sie können diese
Unterschiede im Hilfe-System nachschlagen.
Vergleichen von Strings
Ob zwei Strings identisch sind oder nicht, kann leider nicht einfach mittels der
bekannten Vergleichsoperationen == bzw. ~= herausgefunden werden, sondern es
müssen spezielle Funktionen verwendet werden.
Die Grundfunktion lautet strcmp (string comparison). Diese Funktion gibt es in verschiedenen Varianten
strcmpi, strncmp, strncmpi welche zusätzlich zum simplen Vergleich auf Gleichheit oder
Ungleichheit auch erlauben, nur eine bestimmte Anzahl von Zeichen zu vergleichen, oder beim Vergleich
Unterschiede in der Gross-/Kleinschreibung zu ignorieren.
Um dies zu sehen, probieren Sie bitte folgende Zeilen aus. Die Variablen der vorhergehenden Beispiele
dieser Lektion sollten sich dazu noch im Workspace befinden.
>> strcmp(z2, 'eins')
>> E = 'Eins';
>> strcmp(z2, E)
>> strcmpi(z2, E)
>> strncmp(t2, 'over it', 4)
Vergleich
falsch, da der Vergleich case-sensitive ist
wird dies nicht gewünscht, strcmpi verwenden
(i steht für case-insensitive)
vergleicht nur die ersten n Zeichen (ist auch
case-insensitive möglich - strncmpi)
97
Zusammenfassung
Merkpunkte
•
•
Zeichenketten bzw. Strings sind Matrizen, deren Elemente ASCII-codierte
Zeichen (character) interpretiert werden.
Wörtliche Texte werden im Unterschied zu Variablennamen mittels
Hochkommata notiert: a = 'Hello'.
Hello ist also nicht eine Variable, sondern ein wörtlicher Text.
Anweisungen
•
•
length: Bestimmt die Länge eines Strings (wie bei Vektoren)
str2num: Umwandlung einer in einem String gespeicherten Zahl in einen
Skalar
•
•
num2str: Umwandlung einer Zahl in einen String
ischar: ergibt true, wenn es sich um eine Matrix mit Zeichen (characters)
handelt
•
•
•
•
•
•
strcat: String concatenation, Zeichenketten zusammenhängen
strvcat: vertikales Zusammenfügen von Strings
deblank: Entfernen von Leerzeichen am Ende des Strings
findstr, strfind: Findet einen String in einem anderen
strcmp, strcmpi: Strings vergleichen, mit i: case-insensitive
strncmp, strncmpi: die ersten n Zeichen von Strings vergleichen, mit i:
case-insensitive
98
Testfragen
Bitte versuchen Sie zur Überprüfung ihres Verständnisses folgende Fragen zu beantworten.
Programmierung
Welche Definition(en) einer Funktion ist/sind korrekt? Mehrere richtige Antworten sind möglich.
❏ function hallo()
❏
❏
❏
function (zahlen, anzahl) = generiere(nummer, modus)
function [vpn, name, age] = getsubject(1, 6)
function [] = startprocess(grunz)
Welche der Codezeilen erfüllen folgenden Zweck: Ausgeben der Zahlen 7 bis 21 und deren Quadrate im
Command Window? Mehrere richtige Antworten sind möglich.
❏ for i = 7:21, disp(i, i^2), end
❏
❏
❏
i=7;while i <22, disp(i, i^2), end
i=6; while true, i=i+1, disp(i^2), if i==21, break, end, end
for i = 7:28, disp(i, i^2), if i>20, break, end, end
Welches Resultat ergibt die folgende Programmanweisung:
4 >= sqrt(9) && ~false
❍
3
❍
0
❍
false
❍
1
Welche Anweisung muss man einfügen, um in q das Resultat 1 bzw. true zu erhalten?
m = 'Wenn der Computer alles kann, kann er mich mal kreuzweise';
q = ___________ (m(10:17), 'computer')
99
Glossar
ASCII:
American Standard Code for Information Interchange, die gebräuchlichste Norm, um alphanumerische
Zeichen zu repräsentieren.
Cell Array:
«Zellen-Felder». In jedem Feld eines Cell Arrays können unterschiedliche Datentypen abgelegt werden,
z.B. Matrizen unterschiedlicher Grösse.
Funktion:
Eine Folge von Anweisungen ähnlich einem Skript. Einer Funktion können aber Werte übergeben werden,
und sie gibt Resultate zurück. Sie kann nicht auf Variablen im allgemeinen Workspace zugreifen.
m-File:
Eine Datei mit der Endung .m, welche eine Folge von Matlab-Befehlen enthält. Es kann sich dabei um
einen Skript oder eine Funktion handeln.
Skript:
Ein Skript ist eine in einer Datei (m-File) abgespeicherte Folge von Anweisungen. Diese werden genauso
argearbeitet, wie wenn diese Anweisungen Command Window eingegeben würden.
String:
Zeichenkette. Ein Vektor bzw. eine Matrix deren Elemente ASCII-codierte Zeichen (character) interpretiert
werden.
100
Lektion 3: Arbeiten mit externen Dateien
In dieser Lektion erlernen Sie wichtige Funktionen, welche ganz konkret in Anwendungen der psychologischen
Forschung benötigt werden.
•
•
•
•
Typischerweise werden zuerst die Rohdaten eingelesen, wie sie andere Programme (E-Prime,
Presentation) oder technische Systeme (MRI, EEG, Eye Tracker etc.) erstellen.
Diese Daten müssen Matlab-intern in für die Weiterbearbeitung (Zusammenfassen, Umformen,
Umrechnen, Aggregieren, rechnerische Auswertung, Statistik, grafische Darstellung etc.) geeigneten
Formen gespeichert werden.
Oft kann der Benutzer die Verarbeitung auch über eine direkte Interaktion mit dem Programm
beeinflussen.
Schlussendlich sollen die Daten meist wieder in einem Format extern abgespeichert werden, sodass
sie anschliessend ausserhalb von Matlab weiterbearbeitet werden können, z.B. mit Excel, SPSS oder
Statistica.
Diese verschiedenen Verarbeitungsschritte können Sie in dieser und der folgenden Lektion an einer
umfangreicheren Übungsarbeit in mehreren Phasen konkret umsetzen lernen.
Zur Erinnerung hier nochmals die schematische Darstellung eines Projektes:
Lernziele
•
•
•
•
•
Sie können Daten auf verschiedene Weisen in Matlab importieren.
Sie lernen weitere Datentypen kennen.
Sie kennen die wichtigsten Arten, wie ein Programm mit dem Benutzer interagieren kann.
Sie sind in der Lage, die verarbeiteten Daten in einer externen Datei zu speichern.
Sie sehen, wie diese Schritte in einer beispielhaften Anwendung zusammen integriert werden.
101
Datenimport
Um mit Matlab Daten zu verarbeiten und darzustellen, muss man sie zuerst überhaupt «ins Programm
reinkriegen». Heutzutage ist es glücklicherweise so, dass fast alle Systeme und Programme zur Erhebung von
psychophysiologischen und verhaltenspsychologischen Daten die Speicherung als Text-Dateien ermöglicht.
Für das Einlesen solcher Daten ist Matlab bestens gerüstet. Es bietet im wesentlichen zwei Möglichkeiten dafür
an:
•
•
Komfortable Programmfunktionen, um Daten «manuell» aus verschiedenen Standardapplikationen
einzulesen. Diese Variante ist geeignet, um einen einzelnen Datensatz zu explorieren oder grafisch
darzustellen.
Einlesen von Daten durch ein Matlab-Programm. Diese Methode wird man wählen, wenn immer wieder
neue Datensätze im gleichen Format verarbeitet werden sollen - also die typische Anwendung in der
Forschung.
102
Einlesen von Daten aus externen Dateien: interaktiv
Zum raschen «Reinschauen» in einen Datensatz bietet Matlab komfortable Funktionen an, welche ermöglichen,
Daten aus der Zwischenablage (Clipboard) oder aus Text-, Excel-, XML- oder Lotus-Dateien zu importieren,
ohne dafür gleich ein Programm schreiben zu müssen. Anschliessend können sie weiterbearbeitet oder z.B.
graphisch dargestellt werden.
Import mittels copy-paste
Die simpelste, aber nicht sehr vielseitige Methode: Kreieren einer Matrix in der benötigten Grösse im
Workspace, öffnen derselben im «Variable Editor» (Doppelclick auf die Variable im Workspace), und
übertragen der Daten z.B. aus Excel, SPSS oder ähnlich, mittels copy-and-paste 1.
Import aus Dateien - der «Import Wizard»
Importieren Sie die Datei exp1.xls (dieses ist im zip-File data.zip enthalten und sollte sich in Ihrem
Arbeitsverzeichnis befinden), indem Sie sie im Directory Browser anwählen und im Context Menu
«Import data» anwählen, oder über File > Import Data... aktivieren.
Wie Sie sehen, erzeugt der Import Wizard zwei Datensätze: eine Matrix mit den numerischen Daten, und ein
«cell array» (siehe hier), welches die Text-Daten enthält.
Auch aus einem Programm kann man den Import Wizard aufrufen: uiimport (s. auch import)
Das Stichwort, um im Hilfe-System weitere Informationen dazu zu erhalten, lautet import wizard.
Import von Inhalten aus der Zwischenablage
Auch aus der Zwischenablage (Clipboard) können Sie Daten importieren, die Sie vorher in einer anderen
Applikation mit Edit > Copy oder CTRL-C / CTRL-X gespeichert haben. Folgende Möglichkeiten stehen zur
Verfügung und rufen wiederum den Import Wizard auf.
•
mit Edit > Paste to Workspace...
•
uiimport -pastespecial im Command Window eingeben
oder einfach uiimport, dann bei Select Data Source Clipboard auswählen
•
1
Auf PC/Windows: CTRL-C und CTRL-V. Auf Mac OS: cmd-C und cmd-V
103
Einlesen von Daten aus externen Dateien: programmiert
Wie funktioniert eine Datei?
Eigentlich ganz simpel, eine Datei kann man einfach als serielle Folge von Datenelementen (im Falle von Daten
im ASCII-Format also einzelne alphanumerische Zeichen) ansehen, die mit dem ersten Zeichen beginnt, und
mit einem Marker für das Dateiende (EOF - end of file) endet. Beim Lesen einer Datei wird ein «Lesezeiger»
von vorne nach hinten durch die Datei geschoben - mit jedem Lesevorgang rückt er entsprechend weiter vor.
Dieser Zeiger kann zwar auch wieder zurückgeschoben werden, aber meist ist das nicht notwendig und sinnvoll.
Erreicht der Zeiger die EOF-Marke, ist der Vorgang abgeschlossen.
Schematische Darstellung des sequentiellen Zugriffs auf die Elemente einer Datei
Schematischer Ablauf von Dateioperationen
1.
2.
3.
Damit aus einer Datei gelesen oder hineingeschrieben werden kann, muss sie zuerst «geöffnet» werden:
Funktion fopen.
Anschliessend kann geschrieben oder gelesen werden: fgetl, fscanf, fprintf etc.
Am Schluss muss die Datei wieder «geschlossen» werden: fclose.
Die für die Arbeit mit Dateien notwendigen Funktionen lassen sich am einfachsten an einem Beispiel erläutern.
Wir arbeiten zuerst mit den grundlegendsten Anweisungen - vieles davon liesse sich mit komplexeren (und
neueren) Befehlen einfacher lösen, für das grundlegende Verständnis des Vorgehens erscheint dieses Vorgehen
aber geeigneter.
Grundlegende Funktionen zum Lesen aus externen Dateien
Hier wird davon ausgegangen, dass es sich um ASCII 2-Daten (z.B. Tab- oder Komma-separierte Text-Dateien
*.txt, *.tab, *.csv etc.) handelt. Zum Arbeiten mit rein binären Daten gibt es spezielle Befehle (fread).
Die im folgenden beschriebenen Befehle haben zum Teil noch weitere Parameter - sehen Sie dazu die
Angaben in der Hilfe.
fid = fopen(filename, mode)
Öffnen einer Datei.
Wird als filename nur ein Dateiname angegeben, wird sie im aktuellen Verzeichnis gesucht. Alternativ
kann auch ein kompletter Pfad angegen werden, z.B. d:\daten\jan08\data.txt . fid ist die
«Identifikationsnummer» der geöffneten Datei. Diese wird bei allen nachfolgenden Operationen mit dieser
Datei angegeben, damit diese bei mehreren offenen Dateien klar referenziert werden kann. Kann die Datei
nicht geöffnet werden, erhält fid den Wert -1.
mode ist der Arbeitsmodus, die wichtigsten Möglichkeiten sind 'r' (read - Datei nur zum Lesen öffnen) und
'w' (write - Datei zum schreiben öffnen bzw. neu erstellen).
2
American Standard Code for Information Interchange, die gebräuchlichste Norm, um alphanumerische Zeichen zu repräsentieren.
104
data = fgetl(fid)
Liest eine ganze Zeile ein, also bis zum nächsten Zeilenumbruch (CR, LF). Ist der «Lesezeiger» bereits in der
Mitte einer Zeile, wird sie einfach bis zum Ende eingelesen. Es resultiert ein String 3 (Vektor 4 mit char).
data = fscanf(fid, format, n)
Liest eine durch n bestimmte Anzahl von Dateneinheiten in einem bestimmten Format ein, welches in
format spezifiziert ist. Für die Formatangaben und alle weiteren Möglichkeiten siehe nachfolgendes Beispiel
sowie die Angaben im Hilfe-System.
fclose(fid)
Schliesst die Datei. Erst danach können andere Anwendungen voll auf die Datei zugreifen.
feof(fid)
Prüft, ob das Dateiende erreicht wurde (eof = end of file), ergibt true, falls dies der Fall ist.
3
Zeichenkette. Ein Vektor bzw. eine Matrix deren Elemente ASCII-codierte Zeichen (character) interpretiert werden.
4
105
Beispiel: Routine zum Einlesen von Daten aus externer Datei
Dieses Beispiel demonstriert eine typische Funktion, wie sie zum Einlesen von Daten aus einer Text-Datei
verwendet wird. Gleichzeitig können Sie daran auch die wichtigsten Funktionen des Debuggers 5 kennenlernen.
Der einzulesende Datensatz sieht wie folgt aus (s. Datei exp1.dat)
Die Funktion ist wie folgt definiert:
function [Mdata, Mfirstname, Mfamilyname] = load_data1('exp1.dat')
Die Daten werden von der Funktion wie folgt in den drei Variablen Mdata, Mfirstname und
Mfamilyname zurückgegeben:
5
Funktionen des Editors, um im geschriebenen Programm Fehler zu suchen und beheben.
106
Explorieren der Funktion im Debugger
Schauen Sie sich als erstes folgendes Lernvideo an, das demonstriert, wie man ein Programm im
Debugger untersuchen und von Fehlern befreien kann. Anschliessend können Sie den Ablauf selbst
in Matlab durchspielen.
Vorschau auf die Blockstruktur von load_data1: Die Funktion liest zuerst die Informationen im
«Dateikopf», also die ersten drei Zeilen. Der Tabellenkopf wird überlesen, anschliessend werden die
eigentlichen Datenzeilen eingelesen, bis das Dateiende erreicht wird. Die Daten werden einerseits als zwei
separate String-Matrizen für die Vor- und Nachnamen extrahiert, die anderen Spalten werden wenn nötig
numerisch umcodiert und in eine Matrix gepackt.
107
Spielen Sie den ganzen Ablauf nun bitte selbst durch. Dabei erhalten Sie weitere Hinweise auf die
detaillierte Funktion des Programmes.
•
Vergewissern Sie sich, dass als «current directory» dasjenige Verzeichnis gewählt ist, welches die
Beispieldaten enthält.
Öffnen der Funktion load_data1.m im Editor
•
Setzen eines sog. «break points» auf Zeile 17 - Mausclick auf den Strich nach der Zeilennummer
•
Matlab wird Sie jetzt darauf hinweisen, dass kein Breakpoint gesetzt werden kann, weil im Programm
noch ein Syntaxfehler vorliegt (Zeile 39). Versuchen Sie diesen zu korrigieren und speichern Sie die
Funktion.
Modernere Versionen von Matlab weisen schon vorher darauf hin, dass in der betreffenden Zeile ein
Fehler vorzuliegen scheint.
•
Lösung
Es fehlt eine schliessende Klammer am Schluss der Zeile 39:
datestring = rdata(pos(1) + 1:length(rdata) );
Der Breakpoint hat nun (je nach Matlab-Version) seine Farbe auf rot gewechselt, was bedeutet, dass er
aktiv ist. Falls nicht, setzen Sie ihn nochmals.
Rufen sie die Funktion aus dem Command Window wie folgt auf:
•
•
>> [Mdata, Mfirstname, Mfamilyname] = load_data1('exp1.dat')
Die Programmausführung wird dank des Breakpoints schon auf Zeile 17 angehalten, und zwar bevor
die betreffende Zeile ausgeführt wird.
Von nun an können Sie schrittweise mit Debug > Step (oder F10) weitermachen, weiter unten
einen Breakpoint setzen und Debug > Continue (F5) wählen, oder Debug > Go Until Cursor die
Programmausführung bis zur Schreibmarke fortsetzen.
Indem Sie den Mauszeiger über eine Variable führen, können Sie sich deren Wert anschauen. Sie können
sie aber auch im Command Window abfragen oder im Workspace ansehen.
•
•
•
Erläuterungen zur Programmfunktion
•
Zeilen 17-20: Laden der Datei und Fehlermeldung, falls sie nicht gefunden wird. fid zeigt dies
mit dem Wert -1 an.
Zeilen 22-33: Einlesen der 1. Zeile, dekodieren des Dateinamens und prüfen, ob es keinen
Konflikt mit dem eigentlichen Filenamen gibt
Zeilen 35-40: Einlesen der 2. Zeile und dekodieren des Datums
•
Zeilen 42-43: "Überlesen" des Aufzeichnungssystems und des Tabellenkopfes
•
Zeile 52: Beginn der Hauptschleife, die läuft, bis EOF (end of file) erreicht ist
•
Zeilen 53-60: Eine komplette Datenzeile wird eingelesen
•
Zeilen 62-81: Die drei im alphanumerischen Klartext registrierten Datenwerte der Spalten 3, 5
und 11 werden in rein numerische Daten umgewandelt (so kann man sie dann in einer einzigen
numerischen Matrix speichern)
Zeilen 84-86: Die drei Rückgabevariablen werden mit den Daten gefüllt
•
•
•
108
•
Auf der Zeile 86 wird die Programmausführung abbrechen, weil folgender Fehler vorliegt:
??? Error using ==> horzcat
CAT arguments dimensions are not consistent.
•
•
Um den Fehler genauer anzuschauen, machen wir uns die Möglichkeit von Fehler-Breakpoints zunutze.
Über Debug > Stop if Errors/Warnings... aktivieren wir «Always stop if error» und rufen die Funktion
erneut auf. Die Programmausführung bleibt dann beim Fehler stehen, und Sie haben die Möglichkeit,
sich die beteiligten Variablen genauer anzusehen (Mauszeiger über die Variable im Editor, Doppelclick
im Workspace, oder Aufruf im Command Window).
Finden Sie den Fehler? Wie kann man ihn korrigieren?
Lösung
Das Problem liegt auf der Zeile 86:
Mdata = vertcat(Mdata,
calibn]);
[gendern
age
condn
data
Erinnern Sie sich daran, dass beim horizontalen Zusammenfügen die Anzahl Zeilen
der beteiligten Matrizen identisch sein müssen. Wenn Sie mit dem Mauszeiger auf die
verschiedenen Variablen in der eckigen Klammer in der vertcat-Anweisung zeigen,
sehen Sie, dass alle ausser data Skalare sind, also nur eine Zeile haben. data dagegen
hat fünf Datenpunkte vertikal angeordnet, also fünf Zeilen - das kann so nicht gehen. Wir
wollen die Datenwerte ja nebeneinander angeordnet haben. Dies können wir korrigieren,
indem wir data transponieren, also data' notieren.
•
Beim erneuten Aufruf sollte die Funktion nun korrekt ablaufen und die eingelesenen Werte zurückgeben.
109
Zusammenfassung
Zusammenfassung der wichtigsten Anweisungen:
•
•
•
fid = fopen(filename, mode): Öffnen einer Datei
data = fgetl(fid): Einlesen einer Zeile
data = fscanf(fid, format, n): Liest eine durch n bestimmte
Anzahl von Dateneinheiten in einem bestimmten Format ein, welches in format
spezifiziert ist.
•
•
fclose(fid): Schliessen einer Datei
feof(fid): Prüft, ob das Dateiende erreicht wurde (eof = end of file)
110
Repräsentation von Daten 3: Cell Arrays
In diesem Kapitel erlernen Sie eine weitere, komfortable Art, in Matlab Daten zu repräsentieren: in sogenannten
Cell Arrays (grob übersetzt «Zellen-Felder»).
Während in Matrizen ausschliesslich Zahlen und - mit gewissen Einschränkungen - Strings gespeichert werden
können, erlauben Cell Arrays, in jedem Feld unterschiedliche Datentypen abzulegen, insbesondere Matrizen
unterschiedlicher Grösse.
111
Datenrepräsentation in Cell Arrays
Wie im folgenden Bild ersichtlich ist, besteht ein Cell Array aus mehreren Zellen (cells). Jede Zelle kann
verschiedenste Daten enthalten:
•
numerische Matrizen, d.h. Skalare 6, Vektoren, oder n-dimensionale Matrizen 7 verschiedener Grösse
(cell 1,1 / cell 1,3 / cell 2,1 / cell 2,2)
Matrizen mit Strings (cell 1,2)
•
weitere Cell Arrays (cell 2,3)
•
Structure Arrays 8 (noch nicht behandelt und nicht abgebildet, vgl. Abschnitt Repräsentation von Daten
4: Structure Arrays).
•
Schematisches Beispiel eines Cell Arrays
112
Erzeugen und referenzieren von Cell Arrays
Cell Arrays sind daran erkennbar, dass ihre Indices nicht wie bei Matrizen in runden
Klammern, sondern in geschweiften Klammern { } notiert werden.
In den folgenden Beispielen sehen Sie, wie mit Cell Arrays gearbeitet werden kann. Als Grundlage dient das
abgebildete Cell Array:
Erzeugen des Cell Arrays: Im folgenden sehen Sie, wie das oben abgebildete Cell Array erzeugt
werden kann. Bitte versuchen Sie, die Funktion der nachfolgenden Anweisungen nachzuvollziehen.
>> A = cell(2, 2)
Damit wird ein leeres Cell Array mit m x n Zellen vordefiniert. Dies ist optional. Tut man es nicht, so wird das
Cell Array gleich wie Matrizen dynamisch erweitert, sobald neue Zellen dazukommen. Auch ein Cell Array
muss immer «rechteckig» sein (und sinngemäss bei mehr als zwei Dimensionen). Noch nicht definierte Zellen
sind einfach leer.
Nun werden die Zellen mit Inhalten gefüllt:
>> A{1,1} = [1 4 3; 0 5 8; 7 2 9];
>> A{1,2} = 'Anne Smith';
>> A{2,1} = 3+7i;
>> A{2,2} = -pi:pi/4:pi;
Möglich, wenn auch weniger übersichtlich, ist, alles auf einmal zu definieren:
A = {[1 4 3; 0 5 8; 7 2 9], 'Anne Smith'; 3+7i, -pi:pi/4:pi};
Referenzieren und umwandeln
>> A
>> A{1,1}
>> A{1,1}(2,3)
>> ischar(A{1,2})
>> cellplot(A)
>> m = randn(60,50);
>> b = num2cell(m);
>> c = mat2cell(m,[20 40],[25 25])
>> c{2,1}
>> d = cell2mat(c)
ganzes Cell Array abrufen
Zelle 1,1 anwählen
ein einzelnes Element der Matrix in Zelle 1,1 referenzieren
das ist tatsächlich ein String
Visualisierung der Struktur
irgendeine Matrix
Matrix in Cell Array umwandeln, ein Element pro Zelle
Matrix aufteilen, in Submatrizen pro Zelle
Cell Array wieder in Matrix umwandeln
113
Beispiel für Strings in Cell Arrays
Cell Arrays werden insbesondere gerne verwendet, um unterschiedlich lange Zeichenketten zu speichern, ohne
dass man sich um das Problem der unterschiedlichen Länge kümmern muss. Dazu speichert man in jeder Zelle
genau eine Zeichenkette. Diese Methode wird auch von verschiedenen Matlab-Funktionen unterstützt.
Auch hierzu ein kurzes Beispiel:
>> texte={'Hello world','The quick brown fox',num2str(pi),'jumps over the lazy dog'}
>> texte{4}
>> length(texte{3})
114
Zweites Beispiel zum Einlesen von Daten aus externer Datei
Das vorhergehende Beispiel wird nun so verändert, dass es einerseits die Namensinformationen als Cell
Arrays zurückgibt, und andererseits die eigentlichen Daten nicht mehr mit einer Schleife und fscanf einliest,
sondern mit einem einmaligen Aufruf von textscan, welcher die Daten ebenfalls als Cell Array zurückgibt.
Bitte schauen Sie sich die Funktion load_data2.m anhand der folgenden Schritte aufmerksam an.
•
Öffnen Sie die Funktion load_data2.m im Editor
•
Auf Zeile 47 sehen Sie die Anwendung von textscan.
Cdata = textscan(fid, '%s %s %s %f %s %f %f %f %f %f %s');
Dieser Befehl liest entsprechend des vorgegebenen Formats (%s sind Strings, %f Fliesskommazahlen)
Daten in ein Cell Array ein, bis das Ende der Datei erreicht ist. Cdata{x} wird dann alle Daten aus
•
der x-ten Spalte der eingelesenen Datei enthalten. Alphanumerische Daten werden als Cell Array im
Cell Array gespeichert, numerische Daten als Matrizen.
(was die Bearbeitung der Daten betrifft, ist die Funktion unvollständig)
•
auf den Zeilen 59-61 werden die Daten entsprechend den Erfordernissen umgeordnet:
Cfirstname = Cdata{1};
Cfamilyname = Cdata{2};
Mdata = [Cdata{4} Cdata{6:10}];
[Mdata,
Cfirstname,
load_data2('exp1.dat') aufgerufen werden.
Die
Funktion
kann
mit
Cfamilyname]
=
115
Zusammenfassung
Merkpunkte
•
•
Ein Cell Array besteht aus mehreren matrix-förmig angeordneten Zellen (cells).
Jede Zelle kann nicht nur eine Zahl, sondern verschiedenste Daten wie ganze
Matrizen, Strings, weitere Cell Arrays oder Structure Arrays enthalten.
Cell Arrays sind daran erkennbar, dass ihre Indices nicht wie bei Matrizen in
runden Klammern, sondern in geschweiften Klammern { } notiert werden.
Anweisungen
•
•
•
•
•
cellplot: Visualisieren der Struktur eines Cell Arrays
num2cell: Matrix in Cell Array umwandeln, ein Element pro Zelle
mat2cell: Matrix aufteilen, in Submatrizen pro Zelle
cell2mat: Cell Array in Matrix umwandeln
textscan: Einlesen von Daten aus einer Datei in ein Cell Array
116
Repräsentation von Daten 4: Structure Arrays
Eine weitere, oftmals nützliche Möglichkeit der Datenrepräsentation sind die sogenannten Structure Arrays.
Jedes Element eines Structure Arrays enthält dieselbe Struktur von verschiedenen, mit eigenen Namen
ansprechbaren «Datencontainern». Im Gegensatz zu Cell Arrays 9 ist hier jeweils klarer ersichtlich, was der
Inhalt eines angesprochenen Datenfeldes ist.
9
Eine Datenstruktur, der aus mehreren matrix-förmig angeordneten Zellen besteht. Jede Zelle kann verschiedenste Daten wie ganze
Matrizen, Strings, weitere Cell Arrays etc. enthalten.
117
Repräsentation von Daten in Structure Arrays
Jedes Element eines Structure Arrays enthält dieselbe Struktur verschiedener, mit eigenen Namen
ansprechbaren Unterelementen, genannt Felder (fields). Diese Felder kann man auch als «Datencontainer»
betrachten, die ähnlich einer Zelle eines Cell Arrays alle möglichen Inhalte haben können.
Zum Beispiel könnte ein Element eines Structure Arrays eine Zeichenkette mit einem Namen enthalten, einen
Skalar für einen Kostenbetrag, und eine Matrix mit den medizinischen Testdaten.
>> screensize.x = 800
>> screensize.y = 600
>> screensize.x
>> screensize(2).x = 1024
>> screensize(2).y = 768
screensize hat nun zwei Unterelemente
diese lassen sich genauso ansprechen
ein weiteres Element erzeugen;
dieses hat automatisch dieselbe Struktur
Erzeugen des obenstehenden Beispiels (Patientendaten):
>> patient.name = 'John Doe';
>> patient.billing = 127.00;
>> patient.test = [79 75 73; 180 178 177.5; 220 210 205]
>> fieldnames(patient)
>> lower(patient.name)
>> sum(patient.test(2, :))
>> patient(3).name='Alan Johnson'
>> patient(2)
Abruf der Feldnamen
Element abrufen und bearbeiten
Elemente der Matrix ansprechen
ein neuer Eintrag
patient(2) wurde dabei mit leeren Feldern gefüllt
118
Anwendungsbeispiel
Eine Funktion zum Einlesen von Experimentaldaten könnte alle allgemeinen Informationen zum
Versuchsdurchgang in einem Structure Array mit nur einem Element speichern. Dadurch erspart man sich,
allzuviele individuelle Variablen übergeben zu müssen.
Also statt:
function [Mdata, sex, age, eye, date, time] = loaddata(filename)
könnte man folgendes implementieren:
function [Mdata, expinfo] = loaddata(filename)
wobei expinfo aus den folgenden Feldern bestünde:
expinfo.sex
expinfo.age
expinfo.eye
expinfo.date
expinfo.time
119
Zusammenfassung
Zusammenfassung der wichtigsten Punkte:
•
•
Jedes Element eines Structure Arrays enthält dieselbe Struktur von verschiedenen,
mit eigenen Namen ansprechbaren «Datencontainer». Im Gegensatz zu Cell
Arrays ist hier jeweils klarer ersichtlich, was der Inhalt eines angesprochenen
Datenfeldes ist.
Die Felder werden angesprochen, indem man nach dem Variablennamen des
Arrays den Feldnamen, durch einen Punkt abgetrennt, notiert: patient.name
120
Eigenes Datenverarbeitungsprojekt
Sie kennen nun eigentlich alle Bausteine, um damit beginnen zu können, eine eigene Routine zum Verarbeiten
von Daten zu schreiben.
Das Ziel ist, am Schluss ein Programm zu haben, welches Daten einliest, verarbeitet (Zusammenfassung,
Umrechnung, grafische Darstellung etc.) und die Resultate wieder abspeichern kann.
Das Projekt wird im Rahmen verschiedener Teilaufgaben Px (P für Projekt) umgesetzt:
•
Aufgabe P1: Erstellen des Hauptprogramms und der Funktion zum Einlesen der Daten
•
Aufgabe P2: Benutzereingaben abfragen
•
Aufgabe P3: Bearbeiten und Abspeichern der Daten in eine externe Datei
•
Aufgabe P4: Verarbeitung der Daten
•
Aufgabe P5: Grafische Darstellung der Daten
121
Datenbasis
Folgende Möglichkeiten bestehen für dieses Projekt:
•
Sie haben Daten aus einem eigenen Forschungsprojekt, die Sie bearbeiten möchten.
•
Falls Sie im Moment nicht über solche Daten verfügen, können Sie mit der weiter unten
erläuterten Beispielaufgabe «EyeData Processing» dieses Kurses arbeiten (dieses wird später genauer
beschrieben).
Sie können sich so eine Vorlage erarbeiten, die Ihnen von Nutzen sein kann, falls Sie zu einem späteren
Zeitpunkt eine ähnliche Routine erstellen wollen.
Alternativ können Sie selbst einen hypothetischen Übungsdatensatz erstellen (z.B. in MS Excel), ähnlich
exp1.dat
•
122
Grobstruktur
Eine Datenverarbeitungsroutine besteht in der Regel aus einem Hauptprogramm (Skript oder Funktion), welche
den Gesamtablauf des Programms steuert - also wenn nötig mit dem Benutzer interagiert, Funktionen zum
Laden und Speichern von Daten aufruft und die Daten bearbeitet, visualisiert etc. All dies kann natürlich auch
wieder durch den Aufruf geeigneter Funktionen erfolgen.
Als Rahmenstruktur mag folgendes Skript dienen: mainprog1.m
Dieses liegt wiederum bei den heruntergeladenen Beispielprogrammen vor.
Falls es für Ihre Anwendung notwendig ist, diesem Hauptprogramm direkt Parameter zu übergeben, kann sie
natürlich auch später noch in eine Funktion umgewandelt werden.
123
Datensatz EyeData Processing
Übungsaufgabe, falls Sie keine eigenen Daten haben
Die zu bearbeitenden Daten stammen aus einem Eyetracking-Experiment. Die Versuchspersonen (Vp)
bekamen am Bildschirm Bilder natürlicher Szenen in verschiedenen Grössen präsentiert und sollten diese
im Rahmen einer Rekognitionsaufgabe während je 5,5 Sekunden betrachten (die Rekognitionsleistung wurde
jedoch nicht ausgewertet). Dabei wurden die Augenbewegungen gemessen und als Fixationen erfasst.
Obere Zeile: Beispielbilder (im Experiment in Farbe gezeigt). Untere Zeile: Die verschiedenen Bildgrössen
Das Ziel der Aufgabe ist, Augenbewegungsdaten mehrerer Vpn zu laden und diese in einer einzigen
Ausgabedatei so zusammenzufassen (merging), dass man sie anschliessend z.B. mit SPSS weiterverarbeiten
könnte. Dies erfordert beispielsweise das Hinzufügen neuer Spalten, welche die Vp-Nummer und weitere
Informationen der Versuchsdurchgangs enthalten, welche in den einzelnen Dateien nur im Dateikopf stehen.
Zudem sollen die Daten aggregiert werden, d.h. pro Vp die Mittelwerte berechnet und so gespeichert werden,
dass pro Vp nur mehr eine Datenzeile vorliegt (Vorbereitung zum Rechnen einer ANOVA etc.).
Des weiteren soll das Programm auch Funktionen enthalten, welche die Daten graphisch darstellen (z.B.
Balkendiagramme von Fixationsdauern per Bedingung oder Plots der räumlichen Fixationsverteilung auf den
Bildern).
Die Übungsdaten sind im zip-File data.zip enthalten (dieses haben Sie wahrscheinlich bereits am Anfang
heruntergeladen) und heissen vnsize x.fix (vn sind die Initialen der Vp, x bezeichnet den Trialblock 1-6).
124
Aufgabe P1: Einlesen der Daten
Übernehmen Sie die oben dargestellte Rahmenstruktur für das Hauptprogramm mainprog1.m und
speichern Sie sie unter einem passenden Namen für Ihr Projekt (eyedata.m für die Aufgabe «EyeData
Processing», ist als Musterbeispiel auch unter eyedata_sol1.m zu finden).
Erstellen Sie eine neue Funktion, um Ihre Daten aus den externen Dateien einzulesen. Sie können dafür
entweder ganz neu beginnen, oder aber auf load_data1.m aus dem früheren Beispiel basieren und diese
Funktion (unter anderem Namen) entsprechend modifizieren und erweitern.
Falls Sie eigene Daten haben, überlegen Sie sich zuerst, was Sie mit den Daten später tun möchten. Davon wird
abhängen, in welcher Form Ihre Funktion die eingelesenen Daten dem aufrufenden Skript übergeben muss.
Dies betrifft Fragen wie:
•
Welche der vorhandenen Daten sind überhaupt für die Weiterverarbeitung notwendig?
•
Müssen gewisse Einträge vielleicht umcodiert werden (typischer Fall: Umwandlung von im Klartext
codierten Bedingungen in numerische Codes)?
Welche Datenstrukturen eignen sich am besten für die weitere Verarbeitung - Einzelwerte, Matrizen,
Cell Arrays oder Structure Arrays?
•
Angaben zur Aufgabe «EyeData Processing»
Versuchen Sie eine Funktion readfixdata.m zu programmieren, welche ein einzelnes Datenfile einliest und
die Daten in geeigneter Form zurückliefert, z.B. als Struktur mit den Einträgen Studienname, Vp-Nummer,
Aufzeichnungsdatum, linkes/rechtes Auge, Anzahl Bilder und Bildschirmauflösung, ein Cell Array mit den
Bildnamen plus eine Matrix mit den Augenbewegungsdaten.
Diese Angaben beziehen sich auf die Musterlösung, aber es gibt natürlich nicht nur eine einzige richtige
Lösung, man könnte z.B. genausogut alles in einem Cell Array verpacken.
Die zu bearbeitenden Dateien haben folgende Struktur (afsize1.fix, tab-separierte Datei):
125
Die meisten Angaben im Dateikopf sind selbsterklärend, und einige Angaben sind für unser Projekt irrelevant
(Binocular, Mousedata). Side bezeichnet das Auge, von dem die Bewegungsdaten aufgezeichnet wurden (1
= links, 2 = rechts).
In der Haupttabelle (diese geht so weiter bis zum Dateiende) bedeuten:
•
eventnb - Fixationen durchnumeriert innerhalb eines Trials
•
bmpnb - Nummer des Bildes = Trial-Nummer
•
bmpname - Name des Bildes. Die letzte Zahl bezeichnet die Bildgrösse (vgl. Abbildung)
•
start - Startzeit einer Fixation relativ zum Trial-Beginn in ms
•
dur - Fixationsdauer [ms]
•
x, y - Koordinaten in Pixels
•
skipcode - Marker für Datenfilterung aufgrund Kalibrationsproblemen. -1 = ok, alles andere ist
beeinträchtigt.
126
Die Lösung ist auch im m-File readfixdata_sol.m zu finden.
127
Interaktion mit dem Benutzer
Die meisten grösseren Anwendungen erfordern ein gewisses Mass an Interaktion mit dem Benutzer. Typische
Beispiele dafür sind:
•
Auswahl der zu bearbeitenden Dateien
•
Eingabe von verschiedenen Parametern (Grenzwerte, Filtereinstellungen, Auswahl der Grafikoptionen
etc.)
Grafische Eingaben, z.B. Definition von «Regions of Interest» (ROIs) oder Kalibrationspunkten mittels
Mausclicks
Eingabe von Speicherort und -format von Daten oder Graphiken
•
•
Im folgenden werden die Wichtigsten dieser interaktiven Elemente eingeführt. Das Erstellen von integrierten
grafischen Benutzerinterfaces (graphical user interfaces, GUIs) wird hier jedoch noch nicht diskutiert.
Vgl. dazu das Hilfesystem unter MATLAB > Function Reference > Creating Graphical User
Interfaces.
128
Auswahl von Dateien und Verzeichnissen
Die von anderen Anwendungen bekannten Standard-Dialogboxen zum Auswählen von Dateien,
Verzeichnissen oder dem Speicherort für eine erstellte Datei stehen auch in Matlab zu Verfügung.
Alle drei haben eine grosse Anzahl von Einstellungsmöglichkeiten, die hier nicht alle im Detail
diskutiert werden können, daher werden nur einige typische Anwendungsbeispiele gezeigt. Für die
weiteren Optionen konsultieren Sie bitte das Hilfe-System.
Datei auswählen: uigetfile
[FileName, PathName] = uigetfile('*.m', 'Select the M-file');
Öffnet die Dialogbox zum Auswählen von Dateien. Die Funktion gibt den Dateinamen und den Pfad zurück.
Falls «Cancel» gedrückt wird, resultiert FileName = 0
Das erste Argument '*.m' ist ein Filter, d.h. nur Dateien mit dieser Endung werden angezeigt. Will man alle
Dateien sehen, gibt man '*.*' ein. Das zweite Argument gibt den Text an, der im Fensterkopf erscheint.
Die Auswahl der Datei beginnt im aktuellen Pfad, wie er in Matlab als «Current Directory» eingestellt ist.
Will man mit der Auswahl an einem bestimmten Ort im Dateisystem beginnen, kann man das wie folgt angeben:
[FileName,PathName] = ...
uigetfile('d:\matlab\daten\*.txt', 'Datensatz auswählen');
Sollen mehrere Dateitypen zur Auswahl stehen, gibt man dies mithilfe eines Cell Arrays an. Die möglichen
Dateiendungen stehen also in der erste Spalte des Cell Arrays:
[filename, pathname] = ...
uigetfile({'*.m'; '*.mdl'; '*.mat'; '*.*'}, 'File Selector');
Beispiel für einen Dateiauswahl-Dialog mit Ausgabe des Resultates. Kopieren Sie diese Zeilen ins
Command Window (>> kann mitkopiert werden).
>> [filename, pathname] = uigetfile('*.txt', 'Pick a text file');
>> if isequal(filename, 0)
>> disp('User selected ''Cancel''')
>> else
>> disp(['User selected ', fullfile(pathname, filename)])
>> end
129
Resultierendes Auswahlfenster für Dateien
Verzeichnis auswählen: uigetdir
directory_name = uigetdir('c:\data\', 'Bitte Verzeichnis wählen')
Öffnet eine Dialogbox zum Anwählen eines Verzeichnisses. directory_name enthält den gewählten
Pfad. Drückt der Benutzer «Cancel», wird der Wert 0 zurückgegeben.
Das erste Argument bezeichnet den Pfad, wo die Auswahl beginnt, das zweite den Titeltext an, der im
Fensterkopf erscheint.
Auswahlfenster für Verzeichnisse
Verzeichnis/Dateiname zum Speichern auswählen: uiputfile
[FileName, PathName] = uiputfile('*.dat', 'Speichern als...')
[FileName, PathName] = uiputfile('vp27data.dat', 'Speichern als...')
Dialogbox zum Auswählen des Speicherortes. Die Funktion gibt den gewählten Dateinamen und den Pfad
zurück. Falls «Cancel» gedrückt wird, resultiert FileName = 0.
Das erste Argument gibt den Dateityp an, bzw. im zweiten Beispiel wird direkt ein Dateiname vorgeschlagen.
Das zweite bezeichnet wiederum den Titeltext.
130
Auswahlfenster zum Auswählen eines Dateispeicherortes
Zwei nützliche Funktionen zum Hantieren mit Datei- und Pfadnamen
Meist muss man abgefragte Dateinamen irgendwie in ihre Bestandteile zerlegen, oder aus Eingaben einen
kompletten Dateipfad zu Speichern zusammensetzen. Dazu gibt es praktische Funktionen:
Bitte probieren Sie es direkt selbst aus.
Zerlegen einer kompletten Pfadangabe in seine Bestandteile: fileparts
>> [pathstr, name, ext] = fileparts('c:\data\new\myfile.txt')
Und die Umkehrung davon: Erzeugen einer kompletten Pfadangabe aus den Bestandteilen: fullfile
>> filepath = fullfile(pathstr, [name ext])
>> filepath = fullfile('C:', 'data', 'new', 'myfile.txt')
131
Mustercode: Alle Dateien aus Verzeichnis wählen
Im folgenden finden Sie den Mustercode für eine Funktion, die Ihnen vielleicht einmal von Nutzen sein kann.
Häufig kommt es in Datenauswertungsprojekten vor, dass man alle auszuwertenden Dateien einfach in einem
Verzeichnis ablegen kann. Im Auswertungsprogramm wählt man nur das betreffende Verzeichnis aus, anstelle
einzelner Dateien.
Der unten gezeigte Code erlaubt genau dies: Der Benutzer kann ein Verzeichnis auswählen, das Programm liest
die Inhalte dieses Verzeichnisses aus und liefert eine Liste mit allen gefundenen Dateien, die eine bestimmte
Endung (z.B. .tab für Tabulator-getrennte ASCII-Dateien) haben. Diese kann man dann später in einer Schleife
nacheinander einlesen und verarbeiten.
Diesen Code-Ausschnitt können Sie in eigene Programme übernehmen. Dazu müssen Sie für die meisten
Anwendungen nur die gewünschte Dateiendung anpassen. Die Dateinamen werden in der Matrix Mfiles
zurückgegeben, die Anzahl enthaltener Namen in nbfiles.
pathname = uigetdir('', 'Verzeichnis
wählen');
if pathname == 0
return
end
Mdir = dir(pathname);
nbentries = size(Mdir, 1);
Mfiles = [];
for entry_i = 1:nbentries
if Mdir(entry_i).isdir == false
filename = Mdir(entry_i).name;
if filename(1) ~= '.'
[p, n, ext] = fileparts(filename);
if strcmpi(ext, '.tab')
Mfiles = strvcat(Mfiles, filename);
end
end
end
end
nbfiles = size(Mfiles, 1);
wenn der Benutzer 'cancel' drückt...
... das Programm verlassen
alle Verzeichniseinträge einlesen (*)
ihre Anzahl bestimmen
Resultatmatrix als leer vordefinieren
Schleife über alle Verzeichniseinträge
ist dies nicht ein Verzeichniseintrag?
--> dann ist es ein Dateiname
den aktuellen Dateinamen extrahieren
Einträge '.' und '..' ausschliessen (**)
Extension des Dateinamens bestimmen
mit der gewünschten Endung vergleichen
bei Übereinstimmung den Dateinamen
speichern
Anzahl gefundener Dateinamen bestimmen
Weitere Erläuterungen
(*) Die Funktion dir gibt den Inhalt des Verzeichnisses als Structure Array mit folgenden Feldern zurück
(für uns sind nur die Felder .isdir und .name relevant):
132
(**) Mdir(...).name enthält immer auch zwei spezielle Einträge, die zur Navigation im Dateisystem
dienen: '..' (Verzeichnis aufwärts) und '.' (aktuelles Verzeichnis).
Typischer Output von dir:
. aggr.dat jlsize3.fix rrsize4.fix slsize6.fix
.. bhsize1.fix jlsize4.fix rrsize5.fix tlsize1.fix
afsize1.fix bhsize2.fix jlsize5.fix rrsize6.fix tlsize2.fix
afsize2.fix bhsize3.fix jlsize6.fix slsize1.fix tlsize3.fix
afsize3.fix bhsize4.fix rawall.dat slsize2.fix tlsize4.fix
afsize4.fix bhsize5.fix rrsize1.fix slsize3.fix tlsize5.fix
afsize5.fix jlsize1.fix rrsize2.fix slsize4.fix tlsize6.fix
afsize6.fix jlsize2.fix rrsize3.fix slsize5.fix
133
Weitere Benutzereingaben
Dialogbox zur Eingabe von Werten: inputdlg
Auch diese Funktion hat viele Möglichkeiten zur Konfiguration, hier sind nur exemplarische Beispiele
gezeigt - Details siehe Hilfe-System.
>> answer = inputdlg('Durchmesser:', 'Bitte Wert eingeben')
answer enthält den eingegebenen Wert oder {} (leeres Cell Array), wenn «Cancel» gedrückt wurde.
Bitte beachten: Der eingegebene Wert wird als Zeichenkette zurückgegeben! Matlab weiss nicht, ob
man eine Zahl oder einen Text eingeben soll. Will man mit der Zahl weiterarbeiten, muss man die
Eingabe mit str2double oder str2num umwandeln!
Es können auch mehrere Werte auf einmal abgefragt und Default-Werte vorgeben werden:
>> prompt = {'Enter matrix size:','Enter colormap name:'};
>> dlg_title = 'Input for peaks function';
>> num_lines = 1;
>> def = {'20','hsv'};
>> answer = inputdlg(prompt,dlg_title,num_lines,def)
Die Eingaben werden dann in einem Cell Array zurückgegeben.
Eingabeaufforderung mit Buttons: questdlg
>> button = questdlg('Älter als 30?', 'Bitte antworten', ...
'Noch nicht', 'Leider ja', 'Noch nicht')
134
Erläuterung: Das letzte Argument bezeichnet, welche Schaltfläche dem "default" entspricht, also bereits
aktiviert ist (und mit der Enter-Taste übernommen werden kann). Es kann nicht weggelassen werden.
button enthält anschliessend den Klartext der gewählten Schaltfläche. Es können auch mehr als zwei
Auswahlbuttons erzeugt werden.
Viele weitere Möglichkeiten finden Sie im Hilfe-System unter dem Stichwort «Predefined Dialog
Boxes».
Grafische Eingabe von Koordinaten: ginput
Mit dieser Funktion können Koordinaten in einer vorhandenen Grafik eingegeben werden.
Bitte sehen Sie sich dies anhand des Beispiels an:
>> plot(peaks) % irgendeine Grafik erzeugen
>> hold on
>> [x, y] = ginput(3)
>> plot(x, y, '.-r')
Mit diesem Beispiel werden 3 Werte eingelesen. Mit der Return-Taste kann die Eingabe aber auch vorzeitig
abgebrochen werden. Die Koordinaten werden in den Spaltenvektoren x und y zurückgegeben.
135
Aufgabe P2: Benutzereingaben
Integrieren Sie die notwendigen Benutzereingaben in Ihr Projekt-Hauptprogramm. Je nach
Aufgabenstellung kann es sich dabei um folgendes handeln:
•
Auswahl der zu bearbeitenden Datei(en) bzw. des Verzeichnisses, in dem sie liegen.
•
Abfrage von allfälligen Parametern für die Verarbeitung der Daten (z.B. Filter).
•
Auswahl des Dateinamens und/oder des Speicherortes für die Speicherung der Daten.
•
Abfragen, ob bestimmte Auswertungen oder graphische Ausgaben gewünscht werden.
Falls bei der Dateiauswahl keine Datei gewählt wird ("Cancel" wurde bei der Dateiauswahl gedrückt), soll das
Programm abbrechen und eine entsprechende Meldung ausgeben. Auch andere Fehleingaben sollten entweder
zum Vornherein verhindert werden oder aber zu einer entsprechenden Fehlermeldung führen.
Für das Projekt EyeData Processing
•
Als erstes soll der Benutzer eine zu bearbeitende Fixationsdatei (also ein .fix-File) anwählen können.
•
Als Parameter soll der Benutzer angeben können, ob die Daten aufgrund der skipcode-Spalte in den
Daten gefiltert werden sollen.
Es soll auch angeben werden können, wo und unter welchem Namen die Daten (zusammengezogenes
Rohdaten-File, aggregierte Daten) gespeichert werden sollen.
•
Die Musterlösung finden Sie im m-File eyedata_sol2.m
136
Zusammenfassung
•
•
•
•
•
•
•
•
•
uigetfile: Dialogbox zum Auswählen von Dateien
uigetdir: Dialogbox zum Anwählen eines Verzeichnisses
uiputfile: Dialogbox zum Auswählen des Speicherortes einer Datei
fileparts: Zerlegen einer kompletten Pfadangabe in seine Bestandteile
fullfile: Erzeugen einer kompletten Pfadangabe aus den Bestandteilen
inputdlg: Dialogbox zur Eingabe von Werten
questdlg: Eingabeaufforderung mit Buttons
ginput: Grafische Eingabe von Koordinaten
dir: Verzeichniseinträge der Festplatte einlesen
137
Schreiben von Daten in externe Dateien
Grundsätzlich ist das Vorgehen analog dem Lesen aus externen Dateien: Zuerst wird die Datei mit fopen
geöffnet, dann wird geschrieben, und am Schluss muss die Datei mit fclose wieder geschlossen werden.
138
Grundlegende Funktionen zum Schreiben in externen Dateien
Die im folgenden beschriebenen Befehle haben zum Teil noch weitere Parameter - sehen Sie dazu die
Angaben im Hilfe-System.
fid = fopen(filename, mode)
Öffnen einer Datei. Hier muss für mode nun 'w' (write - Datei zum schreiben öffnen bzw. neu erstellen)
oder 'a' (append - Daten an bestehende Datei anhängen) gewählt werden.
fprintf(fid, format, M, ...)
Schreibt die Daten, die in Matrix M (und allfälligen weiteren Matrizen) enthalten sind, unter der Kontrolle des
format-Strings in die Datei.
Die Möglichkeiten zur Formatierung der Ausgabedaten mittels Format-String sind sehr umfangreich.
Einige grundlegende Formate finden Sie im nachfolgenden Beispiel, für die detaillierten
Formatangaben und alle weiteren Möglichkeiten konsultieren Sie bitte die Angaben im Hilfe-System.
fclose(fid)
Schliesst die Datei.
Beispiel: Schreiben in Datei
Sehen Sie auch das m-File writedatafile.m
% Datei im Schreibmodus öffnen
fid = fopen('C:\m\testdaten.txt', 'w');
% Schreiben von Text:
% %s heisst String, \n erzeugt einen Zeilenumbruch
fprintf(fid, '%s\n', 'Irgendein Text');
% Schreiben von numerischen Daten:
% %g ist Fixkomma-Notation, mehrere Werte werden geschrieben
% und mit Tabulator getrennt (\t).
fprintf(fid, '%g\t', pi, [7.5:3:13.5]);
fprintf(fid, '\n'); % nun fehlt noch der Zeilenumbruch
% Ausgabe mit max. 6 Vorkomma- und 2 Nachkommastellen
fprintf(fid, '%6.2f\t', [737.5:3234.273:20000]);
% Datei schliessen
fclose(fid);
Dies führt zu folgender Datei C:\m\testdaten.txt (Ansicht in MS Excel):
139
Weitere Dateifunktionen finden Sie in der Hilfe z.B. unter: MATLAB > Function Reference > File
I/O > Text files
140
Aufgabe P3: Daten speichern
Schreiben Sie den Programmcode, der es Ihnen ermöglicht, die eingelesenen und bearbeiteten Daten
in eine externe Datei zu speichern.
Die Zwischenschritte der Bearbeitung der Daten hängen natürlich von Ihrer spezifischen Aufgabenstellung ab.
Sie können damit beginnen, die Daten zuerst mal unverändert oder mit einfacheren Anpassungen übungshalber
wieder zu speichern.
•
•
Die vom Benutzer gewählte Fixationsdatei soll eingelesen werden. Die Daten müssen intern so
gespeichert werden, dass sie anschliessend für das Speichern wieder abgerufen werden können.
Das Programm soll die eingelesenen Daten anschliessend wieder speichern. Gemäss untenstehender
Abbildung sollen die Kopfzeilen nicht mit abgespeichert werden. Stattdessen werden zwei zusätzliche
Spalten hinzugefügt: Spalte 1 soll nun die Vp-Nummer (Subject) enthalten, Spalte 2 den Studiennamen
(Study).
Die Musterlösung ist im m-File eyedata_sol3.m zu finden.
141
Zusammenfassung
Merkpunkte
•
Das Vorgehen beim Schreiben in Dateien verläuft analog dem Lesen aus externen
Dateien: Zuerst wird die Datei mit fopen geöffnet, dann wird mit fprintf
geschrieben, und am Schluss muss die Datei mit fclose wieder geschlossen
werden.
Anweisungen
•
fid = fopen(filename, mode): Öffnen einer Datei
fprintf(fid, format, M): Schreibt die Daten der Matrix M enthalten
•
sind, gemäss format-String in die Datei
fclose(fid): Schliessen einer Datei
•
142
Glossar
ASCII:
American Standard Code for Information Interchange, die gebräuchlichste Norm, um alphanumerische
Zeichen zu repräsentieren.
Cell Array:
Eine Datenstruktur, der aus mehreren matrix-förmig angeordneten Zellen besteht. Jede Zelle kann
verschiedenste Daten wie ganze Matrizen, Strings, weitere Cell Arrays etc. enthalten.
copy-and-paste:
Auf PC/Windows: CTRL-C und CTRL-V. Auf Mac OS: cmd-C und cmd-V
Debugger:
Funktionen des Editors, um im geschriebenen Programm Fehler zu suchen und beheben.
Matrix:
Die wichtigste Art der Repräsentation von Daten in Matlab. In der Mathematik ist eine Matrix (Plural:
Matrizen) eine Tabelle von Zahlen oder anderen Größen. Matrizen unterscheiden sich von einfachen
Tabellen dadurch, dass mit ihnen gerechnet werden kann.
Mit dem Ausdruck Matrix ist meist eine zwei- oder höherdimensionale Matrix gemeint (vgl. Skalar,
Vektor).
Skalar:
«nulldimensionale» Matrix, d.h. nur ein Element
String:
Zeichenkette. Ein Vektor bzw. eine Matrix deren Elemente ASCII-codierte Zeichen (character) interpretiert
werden.
Structure Array:
Jedes Element eines Structure Arrays enthält dieselbe Struktur verschiedener, mit eigenen Namen
ansprechbaren Unterelementen, genannt Felder (fields). Diese Felder kann man auch als «Datencontainer»
betrachten, die alle möglichen Inhalte haben können.
Vektor:
143
Lektion 4: Verarbeitung und grafische Darstellung
von Daten
In dieser Lektion geht es darum, wie man in Matlab die Daten weiterverarbeiten kann. Einerseits geht es um
das Transformieren, Umrechnen oder Aggregieren von Daten und das Bestimmen statistischer Kenngrössen.
Andererseits werden grundlegende Möglichkeiten der Visualisierung von Messwerten besprochen.
Lernziele
•
•
•
•
Sie kennen die Möglichkeiten von Matlab, selektiv auf Daten zuzugreifen.
Sie kennen die wichtigsten Statistikfunktionen.
Sie wissen, wie man grafische Figuren mit einer oder mehreren Darstellungen erzeugt und an die
Erfordernisse anpasst.
Sie kennen die wichtigsten Grafikfunktionen und können diese auf Ihre Daten anwenden.
144
Daten selektieren: Logisches Indizieren und die «find»Funktion
In diesem Kapitel geht es um wichtige Möglichkeiten, selektiv bestimmte Daten aus grösseren Datenfeldern
zu extrahieren. Dazu stehen folgende Verfahren zur Verfügung:
•
logische Indizierung
•
die Funktion find
•
eine spezielle Hilfsfunktion subM, die diesem Zweck dient
Anschliessend wird Ihr Datenverarbeitungsprojekt um die Auswertungsfunktionen ergänzt.
145
Logische Indizierung
Diese Methode des Datenzugriffs ermöglicht, Elemente einer Matrix aufgrund logischer Vergleichsoperationen
anzusprechen. Einfacher gesagt, kann man damit alle Elemente auf einmal ansprechen, die eine bestimmte
Bedingung erfüllen. Beispielsweise:
>> a = magic(7);
>> a(a < 10) = 0
Was passiert? Alle Elemente von a, die kleiner als 10 sind, werden auf 0 gesetzt.
Und wie funktioniert das? Der Vergleich a < 10 ergibt eine gleichgrosse Matrix mit den Wahrheitswerten
des Vergleichs für jedes Element, denn Vergleichsoperatoren können auch auf ganze Vektoren oder Matrizen
angewandt werden (vgl. Abschnitt Vergleichsoperatoren in Lektion 2). Diese kann als logischer Index
verwendet werden.
Probieren Sie's bitte selbst aus:
>> a = magic(7);
>> a < 10
>> b = a(a > 20)
Ergebnis der Vergleichsoperation
Extrahiert alle Elemente von a, die der Bedingung genügen
Oft kommt es vor, dass man aus einer grösseren Datenmatrix Daten nach bestimmten Kriterien extrahieren
muss, z.B. die Werte aus Spalte 7 aus allen Zeilen der Matrix Mdata, in deren Spalte 3 ein Wert grösser als
0,5 steht. Eine naheliegende Lösung dafür ist, dass man eine Schleife schreibt und Zeile für Zeile mit einem
if-Statement prüft, ob dies der Fall ist und dann den Wert ausliest:
Mdata = rand(50, 7);
Mselect = [];
[nbrows, nbcols] = size(Mdata);
for row_i = 1:nbrows
if Mdata(row_i, 3) > .5
Mselect = vertcat(Mselect, Mdata(row_i, 7));
end
end
Sehr viel kürzer und damit eleganter (und auch schneller) geht dies mit der logischen Indizierung:
>> Mdata = rand(50, 7);
>> Mselect = Mdata(Mdata(:,3)>.5, 7)
Um zu sehen, wie das funktioniert, schauen wir uns den "inneren" Ausdruck genauer an:
>> Mdata(:,3)>.5
Wie Sie sehen, ergibt dies einen Vektor mit den Wahrheitswerten des Vergleiches aller Werte in Spalte 3 mit
0,5. Dieser kann wiederum als logischer Index in eine Matrix gebraucht werden. D.h. es werden alle Zeilen
genommen, deren korrespondierender Eintrag true (numerischer Wert 1) enthält.
146
Die find-Funktion
Die find-Funktion eröffnet ähnliche Möglichkeiten wie die eben besprochene logische Indizierung. Sie
liefert als Resultat aber keine Matrix mit logischen Vergleichswerten, sondern einen Vektor mit den «linearen
Indices» (vgl. Lektion 1, Abschnitt Matrizen, Unterabschnitt «Lineare Indizierung» ganz unten auf der Seite).
Am Besten probieren Sie auch dies gleich selbst aus:
>> a = magic(10);
>> selected = find(a > 50)
>> length(selected)
alle Elemente von a finden, die > 50 sind
Anzahl gefundener Elemente
Dies ergibt einen Vektor mit den linearen Indizes der entsprechenden Elemente. Dieser kann nun für weitere
Operationen gebraucht werden.
>> b = a(selected)
>> a(selected) = inf
die entsprechenden Elemente extrahieren
die Elemente in a auf inf setzen
In den meisten Fällen lässt sich find durch eine logische Indizierung ersetzen, was auch sinnvoll ist,
weil dies schneller ausgeführt wird.
147
Eine hilfreiche Funktion: subM
Sie finden diese praktische Hilfsfunktion (sie gehört nicht zum Funktionsumfang von Matlab) bei den
Beispielprogrammen (zip-File). Sie ist wie folgt definiert:
function Mselected = subM(Min, col, min, max)
subM ist eine Funktion, die alle Zeilen aus einer Matrix Min extrahiert, in denen der Wert in einer bestimmten
Spalte col in einem definierten Bereich von min bis max (inklusive) liegt.
>> M1 = magic(10);
>> column = 3; minvalue = 10; maxvalue = 30;
>> Mneu = subM(M1, column, minvalue, maxvalue)
Natürlich kann man das mithilfe der logischen Indizierung auch direkt programmieren, dies ist aber weniger
komfortabel und ergibt schlechter lesbaren Programmcode:
>> Mneu = M1(M1(:, column) >= minvalue & M1(:, column) <= maxvalue, :)
Erläuterung: Die Ergebnisse der beiden Teilvergleiche werden mit & logisch verknüpft (AND-Verknüpfung).
Nochmals im Detail angeschaut:
>> M1(:, column) >= minvalue
>> M1(:, column) <= maxvalue
>> M1(:, column) >= minvalue & M1(:, column) <= maxvalue
Wenn man sich die Funktion subM im Editor anschaut (mit edit subM), sieht man, dass sie ausser einem
Plausibilitätscheck eigentlich nichts Anderes macht. Trotzdem kann es hilfreich sein, solche oft verwendeten
Operationen als Funktionen zu schreiben. So spart man später beim Programmieren Zeit und erhält besser
lesbaren Code.
148
Zusammenfassung
Merkpunkte
•
Logische Indizierung: Eine Methode des Datenzugriffs, mit welcher gleichzeitigh
alle Elemente einer Matrix angesprochen werden können, die eine bestimmte
Bedingung erfüllen.
z.B. alle Elemente aus a auslesen, die kleiner als 10 sind: b = a(a < 10)
Anweisungen
•
•
find: Elemente in einer Matrix finden. Resultat sind die linearen Indices auf die
betreffenden Elemente.
subM: Hilfsfunktion (nicht aus dem Funktionsumfang von Matlab). Extrahiert
alle Zeilen aus einer Matrix, in denen der Wert in einer bestimmten Spalte in einem
definierten Wertebereich liegt.
149
Grundlegende Statistikfunktionen
In diesem Kapitel werden die grundlegenden statistischen Funktionen besprochen, die bereits in der
Grundversion von Matlab enthalten sind. Es handelt sich dabei um
•
Funktionen zum Berechnen statistischer Kennwerte (Deskriptivstatistik)
•
Berechnung von Korrelations- und Kovarianzwerten
•
Funktionen zum Erstellen von Zufallsdatensätzen mit bestimmten statistischen Verteilungen
150
Deskriptivstatistik
Bereits die Grundversion von Matlab bietet eine Anzahl an hauptsächlich deskriptiven Statistikfunktionen.
Weitere Funktionen sind in der Statistik-Toolbox zu Matlab enthalten, die separat lizensiert werden muss. Ihre
Funktionen werden daher hier nicht besprochen.
Falls Sie über die Statistik-Toolbox verfügen, finden Sie alle notwendigen Informationen im HilfeSystem unter Statistics Toolbox (Hauptkategorie im Contents-Teil)
Minimum und Maximum
Die Funktionen dazu heissen min und max. Sie besitzen dieselben Möglichkeiten der Anwendung:
Probieren Sie's aus:
>> a = magic(5);
>> min(a)
>> max(max(a))
>> b=fix(rand(5)*25)
>> max(a, b)
>> min(a, [], 2)
So werden die Minima in Spalten berechnet.
So erhält man das Minimum oder Maximum der ganzen Tabelle
eine zweite Matrix definieren
Vergleicht a und b Element für Element
und schreibt das jeweilige Maximum in eine gleichgrosse Matrix.
a und b müssen natürlich die gleichen Dimensionen haben.
Mit diesem Schreibweise kann man die Dimension der Berechnung angeben.
1 sind Spalten (default), 2 die Zeilen, 3 die Ebenen etc.
Mittelwert, Median etc.
Zur Berechnung dieser Werte gibt es drei Funktionen, die wiederum dieselbe Struktur besitzen: mean,
median und mode.
Auch hier erfahren Sie es am Besten selbst:
>> m=fix(randn(200,6)*18+48);
>> mean(m)
>> modeval=mode(m)
>> [vals,freq]=mode(m)
>> median(m,2)
Matrix mit normalverteilten Werten
Mittelwert der Spalten
Modalwert, d.h. der häufigste Wert
So erhält man auch die Anzahl der entsprechenden Werte
So kann man wieder die Dimension angeben
Will man den Wert für ein ganzes Array bestimmen, muss man dieses zuerst in einen Spaltenvektor umwandeln.
Eine «logische Lösung» dafür wäre z.B.:
m1 = reshape(m, numel(m), 1);
Es gibt aber eine «Abkürzung»:
>> m1 = m(:)
>> mode(m1)
>> mean(m(:))
m(:) heisst: einfach alle Werte von m nehmen
oder auch einfach direkt
Varianz und Standardabweichung
Die beiden Funktionen var und std werden meist in der einfachsten Form verwendet (Details siehe HilfeSystem). Diese berechnet die Werte ebenfalls in Spalten:
151
Auch hier bitte wieder selbst nachvollziehen:
>> var(m)
>> std(m)
>> std(m1)
Varianz
Standardabweichung
oder über das einspaltige Array
Perzentile
Die Funktion prctile(data,
percvalues) erlaubt die Berechnung von Perzentilen auf
komfortable Weise. Auch diese Berechnung läuft über die Spalten einer Matrix data. Der Parameter
percvalues ist ein Zeilenvektor, der die gewünschten Prozentwerte enthält.
Perzentilberechnung:
>> prctile(m, [5 50 95])
>> prctile(m, [25 75], 2)
Berechnet das 5%-, 50%- und 95%-Perzentil für jede Spalte.
Jede Zeile des Resultates enthält die drei Perzentilwerte einer Spalte.
auch hier kann man die Dimension angeben
152
Korrelation und Kovarianz
Die einzige inferenzstatistische Funktion der Matlab-Grundversion ist die Berechnung von Korrelationen
mittels corrcoef. Die wichtigsten Formen lauten wie folgt:
R = corrcoef(X)
Dies ergibt eine Matrix R mit den Korrelationskoeffizienten. Die Funktion arbeitet über eine zweidimensionale
Matrix. Diese wird so interpretiert, dass die Spalten den abhängigen Variablen AV entsprechen, und die
Zeilen die individuellen Beobachtungen (also Messwerte) repräsentieren.
R = corrcoef(x, y)
x und y sind Spaltenvektoren, die zwei abhängigen Variablen entsprechen. Genauer gesagt, falls x und y nicht
Spaltenvektoren sind, werden sie automatisch in solche umgewandelt. Natürlich muss die Anzahl Elemente
in beiden Arrays gleich sein.
[R, P, RLO, RUP] = corrcoef(X, 'alpha', .01)
So erhält man weitere Werte. P enthält die Signifikanzwerte auf der Basis des spezifizierten alpha Wertes. Die Angabe von alpha kann auch weggelassen werden, dann ist der default-Wert .05 für 95%Konfidenzintervalle.
RLO und RUP enthalten die unteren (RLO) und oberen (RUP) Grenzen für ein 95%-Konfidenzintervall für
jeden Korrelationskoeffizient.
Details dazu sowie zu weiteren Parametern erhalten Sie wie üblich im Hilfe-System.
Dazu ein Beispiel aus dem Matlab-Hilfesystem. Dabei wird eine Datenmatrix erzeugt, die eine
Korrelation zwischen Spalte 4 und den anderen Spalten aufweist.
>> x = randn(30, 4);
>> x(:, 4) = sum(x, 2);
>> [r, p] = corrcoef(x)
>> [i, j] = find(p < 0.05);
>> [i, j]
unkorrelierte Zufallsdaten
nun bauen wir eine Korrelation ein
Korrelationskoeffiziente und p-Werte berechnen
signifikante Korrelationen finden (Spalten, Zeilen)
ihre Spalten und Zeilen anzeigen
153
Zufallsdaten mit bestimmten Verteilungen
Oft ist die Möglichkeit hilfreich, zum Testen von Auswertungsfunktionen zufällige Daten mit bestimmten
Verteilungen erzeugen zu können.
Permutation
Um eine zufällig geordnete Folge von Zahlen in einen bestimmten Bereich zu erhalten, verwenden Sie die
Funktion randperm (random permutation).
randperm(n)
Dies erzeugt eine zufällig geordnete Reihe der Zahlen von 1 bis n als Zeilenvektor, z.B. [3 2 6 4 1 5].
Indem man dazu eine Konstante addiert, kann man diese Folge in einen bestimmten Bereich «verschieben».
Gleichverteilte Zufallszahlen
Die Grundfunktion, um gleichmässig verteilte zufällige Zahlen zu erzeugen, heisst rand. Sie erzeugt Zahlen
zwischen 0 und 1. Ihre Syntax lautet:
a = rand(rows, cols)
Dies erzeugt eine Matrix mit rows Zeilen und cols Spalten.
Meist braucht man aber Zufallszahlen in einem bestimmten Zahlenbereich. Um Daten im Bereich von
LowerBound bis UpperBound zu erzeugen, verwenden Sie folgende Methode:
data = rand(rows, cols) * (UpperBound - LowerBound) + LowerBound;
Ergebnis von data = rand(4000, 1) * (37 - 12) + 12
Für die meisten Anwendungen genügt diese Form. Falls Sie sicher sein müssen, dass jedesmal
eine andere Zahlenfolge erzeugt wird bzw. Sie immer die gleiche Folge haben wollen, oder den
Algorithmus der Zufallszahlenerzeugung genau kennen müssen, seien Sie auf das Hilfe-System zu
rand verwiesen.
154
Normalverteilte Zufallsdaten
Mit der Funktion randn erhalten Sie normalverteilte Zufallsdaten mit dem Mittelwert 0 und der
Standardabweichung 1.
data = randn(rows, cols)
Um Daten mit beliebigem Mittelwert und Standardabweichung zu generieren, geht man wie folgt vor:
>> M = 27;
>> SD = 10;
>> data = randn(4000, 1) * SD + M;
>> mean(data)
>> std(data)
Mittelwert definieren
Standardabweichung definieren
Daten erzeugen
Mittelwert nachprüfen
Standardabweichung nachprüfen
155
Aufgabe P4: Projektarbeit - Verarbeitung der Daten
Implementieren Sie in Ihrem Projekt die Verarbeitung der Daten. Die Art der Bearbeitung der
Daten hängen natürlich von Ihrer spezifischen Aufgabenstellung ab; es kann sich beispielsweise
um Transformationen, Aggregation, Berechnen von Mittelwerten oder Zusammenziehen und
Umgruppieren von Daten handeln.
1.
2.
3.
4.
5.
Erweitern Sie die Eingabefunktion zur Abfrage der zu bearbeitenden Dateien wie folgt: In einer Schleife
sollen nun mehrere Datenfiles (also .fix-Files) anwählbar sein (Abbruch des Vorgangs, wenn der
Benutzer "cancel" / "Abbrechen" drückt.
Alternativ kann auch folgendes realisiert werden: Der Benutzer kann ein Verzeichnis auswählen, aus
dem dann anschliessend alle vorhandenen .fix-Files eingelesen werden. Beispielcode siehe Lektion 3
Mustercode: Alle Dateien aus Verzeichnis wählen (realisiert in der Musterlösung zu Aufgabe P5,
eyedata_sol5.m).
In einer Schleife sollen nun alle vom Benutzer gewählten Fixationsdateien eingelesen werden. Die Daten
müssen intern so gespeichert werden, dass sie anschliessend für das Speichern wieder abgerufen werden
können.
Das Programm soll die Daten (entsprechend der Benutzereingabe) aufgrund der Spalte "Skipcode"
filtern. Alle Daten mit -1 sind ok, die anderen sind aus dem Datensatz zu entfernen.
Die gefilterten Daten aller Versuchspersonen sollen in ein einziges Datenfile gespeichert werden
(zusammengezogenes Rohdaten-File). Das Format bleibt das gleiche wie bei der Aufgabe P3, nur sind
jetzt halt die Daten mehrere Personen nacheinander enthalten.
Pro Versuchsperson und Bildgrösse soll folgendes berechnet werden: (1) die mittlere Anzahl von
Fixationen pro Bild, (2) der Median der Dauer (da schiefe Verteilung!) der Fixationen, die auf allen
Bildern einer bestimmten Grösse gemacht wurden. Die Bildgrösse ergibt sich aus den letzten Zeichen
des Bildnamens (1 bis 4). Diese Werte sollen dann gemäss untenstehender Abbildung als Daten mit
Messwiederholung in das Datenfile "aggregierte Daten" gespeichert werden.
Die Musterlösung ist im m-File eyedata_sol4.m zu finden.
156
Zusammenfassung
•
•
•
•
•
•
•
•
min, max: Minimum und Maximum
mean, mode, median: Mittelwert, Modalwert, Median
var, std: Varianz und Standardabweichung
prctile: Perzenzilberechnung
corrcoef: Korrelationskoeffizienten
randperm: Zufällig geordnete Reihe der Zahlen von 1 bis n
rand: gleichverteilte Zufallszahlen zwischen 0 und 1
randn: normalverteilte Zufallszahlen mit Mittelwert 0 und Standardabweichung
1
•
data = rand(rows, cols) * (UpperBound - LowerBound)
+ LowerBound;
Erzeugen von Zufallszahlen in einem bestimmten Zahlenbereich
157
Grafikgrundlagen: Figuren und Achsensysteme
Allgemeines zum Thema Grafik in Matlab
Matlab bietet sehr umfangreiche Möglichkeiten der grafischen Darstellung an. Es ist hier nicht möglich, eine
auch nur annähernd vollständige Übersicht davon zu geben. Stattdessen werden wieder die grundlegenden
Mechanismen eingeführt, zusammen mit einer Demonstration der in unserem Fachgebiet am häufigsten
verwendeten Grafiken.
•
der Umgang mit Figur-Fenstern
•
interaktives Bearbeiten von Grafiken
•
Achsensystemen
•
Universelle Plots
•
Balkengrafiken
•
Weitere Grafiktypen kurz demonstriert
•
Beschriften und erweitern von Grafiken
158
Erzeugung und Manipulation von Figuren
Jede Grafikausgabe spielt sich in einem speziellen Fenster ab, einem sogenannten figure graphics object, im
folgenden kurz «Figur» genannt. Im Direktmodus ist das explizite Kreieren einer Figur oft nicht notwendig,
da Matlab automatisch eine solche erzeugt, falls noch keine vorhanden ist. Allerdings werden dazu DefaultEinstellungen (Fenstergrösse, Hintergrundfarbe etc.) verwendet, die den Anforderungen der Aufgabe oft nicht
entsprechen. Daher wird man in einem Programm, welches Grafikausgaben verwendet, die Figuren i.d.R.
explizit erzeugen und deren Eigenschaften gezielt einstellen.
Zum Verständnis der Arbeitsweise von Matlab im Zusammenhang mit Grafikausgaben sehen Sie sich
bitte folgende Beispiele an:
>> plot(sin(-pi:.1:pi))
>> plot(cos(-pi:.1:pi))
>> hold on
>> plot(sin(-pi:.1:pi),'r')
Matlab erzeugt selbstständig eine Figur mit den
Default-Einstellungen
die neue Grafikausgabe ersetzt die alte
fixiert die Grafik (Gegenstück ist hold off)
nochmals den Sinus plotten, diesmal in rot - nun wird die
vorherige Kurve nicht mehr überschrieben
Wie man sieht, geht jede Grafikausgabe in das momentan aktive (also im Vordergrund stehende bzw. zuletzt
benutzte) Grafikfenster. Will man eine zusätzliche Grafik erstellen, muss man eine neue Figur erzeugen:
>> figure
>> bar(rand(10,4))
Eine zusätzliche Figur kann man auch erzeugen, indem man im Menu der vorhandenen Figur File > New >
Figure wählt.
Die Darstellungseigenschaften jeder Grafik können mit den im Grafik-Fenster eingebauten Tools nachträglich
verändert werden. So kann man eine Grafik nach eigenen Bedürfnissen modifizieren und anschliessend
ausdrucken oder in verschiedenen Formaten speichern.
Aufgabe: Schauen Sie sich die Funktion der verschiedenen Plotting-Tools direkt an; Sie können sich
auch im Hilfe-System (docsearch 'interactive plotting') über die Möglichkeiten
informieren.
159
Aber was, wenn Sie jetzt wieder in die erste Figur zeichnen wollen? Solange Sie im Direktmodus
arbeiten, können Sie dazu das erste Fenster «von Hand» in den Vordergrund holen, und dann mit den
Grafikanweisungen weitermachen:
>> bar(rand(10,1))
>> close all
nun wird wieder in das erste Fenster gezeichnet
damit schliesst man alle offenen Figuren
Wenn man in einem Programm mit mehreren Figuren arbeiten will, geht man wie folgt vor: Jede benötigte
Figur wird separat erzeugt und erhält einen sog. figure handle, was soviel wie «Griff» oder «Henkel» bedeutet.
Damit kann man sich später immer wieder auf eine bestimmte Figur beziehen.
>> fig1=figure('Name','bar graphs');
>> bar3(rand(10,3))
>> fig2=figure('Name','line graphs');
>> plot(sin(-pi:.1:pi),'r')
>> figure(fig1)
>> grid off
>> clf
die Parameter bestimmen den Titel des
Fensters (optional)
eine zweite Figur
so wechselt man wieder zur 1. Figur
z.B. das Raster ausschalten
ganze Grafik löschen (clear figure)
Bei Funktionen wie clf, close etc. kann man auch direkt angeben, welche Figur man ansprechen will,
ohne dass diese aktiv sein muss (also ohne dass man sie vorher mit z.B. mit figure(fig1) zur aktiven
Figur gemacht hat). Also zum Beispiel clf(fig2) oder close(fig1).
160
Eigenschaften von Figuren
Das Verändern der Eigenschaften von Figuren erfolgt über Argument-Paare, wie im
obigen Beispiel mit dem Fenstertitel bereits gesehen. Das erste Argument eines Paares
gibt an, welche Eigenschaft man verändern will (also z.B. 'Name'), das zweite enthält
die konkreten Einstellungen.
Für Figuren stehen eine Unmenge von veränderbaren Eigenschaften zur Verfügung. Die komplette
Übersicht finden Sie in der Hilfe z.B. unter dem Stichwort 'figure properties' (docsearch 'figure
properties'). Die wichtigsten davon werden im nächsten Abschnitt kurz beschrieben.
Die Eigenschaften können entweder direkt beim Erzeugen einer Figur gesetzt werden, wie oben bereits
gesehen:
>> fig2=figure('Name','line graphs');
Sie können aber auch später jederzeit mit set verändert werden. Dafür benötigt man den handle der
anzusprechenden Figur. Entweder notiert man direkt den entsprechenden Handle (also fig2), oder man ruft
mit gcf (get current figure) den handle der gerade aktiven Figur ab. Beispiel:
>> set(fig2, 'Name', 'Ein anderer Name');
>> set(gcf, 'Name', 'Ein anderer Name');
Die wichtigsten Figur-Eigenschaften
'Name', 'titeltext'
Titel des Figur-Windows
'Color', ColorSpec
Hintergrundfarbe. Informationen dazu, wie die Farben spezifiziert werden können, finden Sie z.B. mit doc
colorspec. Beispiele:
>> set(gcf,'Color','yellow')
>> set(gcf,'Color','r')
>> set(gcf,'Color',[.8 .8 .8])
'yellow' ist eine der vordefinierten Farben
'r' ist eine Kurzform für 'red'
RGB-Farbtripel, ergibt Hellgrau
'Position', [left, bottom, width, height]
Position und Grösse des Fensters.
left, bottom: Abstand in Pixels vom linken bzw. unteren Rand
width, height: Breite und Höhe des Fensters
Beispiel:
>> fig=figure('Position', [100 100 800 600]);
Nützliche Funktion dazu: Abrufen der Bildschirmgrösse, falls man das Fenster relativ dazu dimensionieren
möchte
>> ss=get(0,'ScreenSize')
'Resize', 'on' oder 'off'
Bestimmt, ob der Benutzer die Fenstergrösse manuell verändern kann.
'Toolbar', 'none' oder 'auto'
Bestimmt, ob die Toolbar (Werkzeugleiste) des Figur-Windows sichtbar ist. Default ist 'auto', also sichtbar.
'Visible', 'on' oder 'off'
Mit 'off' kann das Fenster versteckt werden, es ist aber weiterhin intern vorhanden und für Grafikausgaben
brauchbar.
161
Achsensysteme (Axes)
Jede Grafikausgabe geht genau genommen nicht in eine Figur, sondern in das darin enthaltene Achsensystem.
Dies wird in der Matlab-Terminologie als Axes (Achsen, Mz. von axis) bezeichnet, also eben ein System aus
zwei (x, y) oder drei (x, y, z) Achsen - nicht zu verwechseln mit axis, womit Einstellungen der eigentlichen
Achsen (z.B. der Skalen) vorgenommen werden können (s. unten).
Auch Achsensysteme haben wieder eine Vielzahl von Eigenschaften (docsearch 'axes
properties'), mit Ausnahme von 'Color' werden die meisten davon für unsere
Anwendungsfälle kaum gebraucht.
Alle anderen Eigenschaften der Achsen können über separate Befehle verändert werden. Für die
Demonstration schliessen Sie mal wieder alle Figuren und erzeugen eine neue Grafik (am Einfachsten
mit copy/paste):
>> close all
>> figure('Position', [100 100 800 600])
>> plot(peaks)
Nun können wir die Eigenschaften verändern:
>> title('Die peaks-Funktion')
>> grid off
>> grid on
>> axis off
>> axis on
>> axis([0 100 -20 20])
>> axis tight
>> set(gca,'Color','blue')
Titel der Grafik
Raster ausschalten
und wieder ein
Achsen entfernen
Skalen verändern: [xmin xmax ymin ymax]
Skalen eng an die Daten anpassen
Hintergrundfarbe setzen. gca = get current axes
Weitere Möglichkeiten von axis: siehe Hilfe-System doc axis
>> box on
>> xlabel('Abszisse')
>> ylabel('Ordinate')
Rahmen um die Grafik
Achsen beschriften
Eine weitere nützliche Funktion ist waitforbuttonpress: Damit kann mit der weiteren
Programmausführung gewartet werden, bis der Benutzer in die Grafik hineinclickt bzw. bei aktiver Grafik eine
Taste drückt:
>> figure, plot(peaks), waitforbuttonpress, bar(peaks)
Eine andere Möglichkeit für Benutzereingaben: die Figur-Eigenschaft currentcharacter (s.
Hilfe-System).
162
Multiple Achsensysteme
Oft ist es nützlich, in einer Figur mehrere Untergrafiken oder Panels zu haben. Mit der Funktion subplot
kann man zu diesem Zweck mehrere Achsensysteme in einer Figur erzeugen.
Multiple Achsensysteme
Bitte spielen Sie folgendes Beispiel durch.
>> close all, figure('Position', [100 100 800 600])
>> subplot(2,2,1)
>> plot(sin(-pi:.1:pi))
>> subplot(2,2,2)
>> barh(rand(10,3))
>> subplot(2,2,3)
>> plot(peaks)
>> subplot(2,2,4)
>>
scatter(randn(1,40),
randn(1,40))
>> subplot(2,2,1)
>> cla
erzeugt 2x2 Untergrafiken und aktiviert die erste davon
plotten in die erste Subgrafik
die zweite Subgrafik anwählen
horizontale Balkengrafik
Subgrafik unten rechts
und die letzte
wieder die erste anwählen
löscht nur die Inhalte der aktuellen Untergrafik (clear axes).
clf würde alle Achsensysteme aus der Figur entfernen.
163
Zusammenfassung
Merkpunkte
•
Jede Grafikausgabe spielt sich in einem speziellen Figurfenster ab.
•
Noch genauer: Jede Grafikausgabe geht eigentlich nicht in die Figur, sondern in
das darin enthaltene Achsensystem, von denen eine Figur auch mehrere enthalten
kann.
Das Verändern der meisten Eigenschaften von Figuren erfolgt über ArgumentPaare. Das erste Argument eines Paares gibt an, welche Eigenschaft man
verändern will (also z.B. 'Name'), das zweite enthält die konkreten Einstellungen.
•
Anweisungen: Figur-Eigenschaften
•
•
•
•
figure: Erzeugen eines Figurfensters
clf: Inhalt des Figurfensters löschen
close, close all: Figur(en) schliessen
set(gcf, 'Eigenschaft', Parameter);
Verändern der Eigenschaften eines Figurfensters mittels Argument-Paaren
Einige Eigenschaften: Name, Color, Position, Toolbar,
•
Visible
gcf = get current figure handle
waitforbuttonpress: Auf Tastendruck oder Mausclick warten
Anweisungen: Achsensysteme
•
•
•
•
•
•
•
•
•
•
•
title: Titel des Achsensystems setzen
xlabel, ylabel, zlabel: Achsen beschriften
grid on, grid off: Raster ein- und ausblenden
axis on, axis off: Achsen ein- und ausblenden
axis tight: Skalen eng an Daten anpassen
axis([xmin xmax ymin ymax]): Skalen setzen
box on, box off: Rahmen um die Achsen ein- und ausblenden
hold on, hold off: Grafikausgabe fixieren bzw. Fixierung aufheben
set(gca,'Color','blue') :
Eigenschaften des Achsensystems verändern; gca = get current axes handle
subplot: Untergrafiken (= Achsensysteme) erzeugen und ansprechen
cla: Aktuelles Achsensystem löschen
164
Grafikwerkzeuge
Im folgenden werden Sie einige wichtige Grafikwerkzeuge kennenlernen. Auch hier gilt wieder: Matlab
stellt eine Unmenge von Grafikmöglichkeiten zur Verfügung, und es ist nicht möglich, im Rahmen dieses
Lehrmittels alle davon zu besprechen. Wie immer seien Sie auf das Hilfesystem verwiesen.
Einen Überblick über alle Grafikbefehle finden Sie im Hilfesystem unter Function reference >
graphics > basic plots and graphs
An der Funktionsweise von plot wird exemplarisch das Prinzip der meisten Grafikbefehle gezeigt.
Anschliessend werden weitere häufig gebrauchte Grafiktypen in kurzen Demonstrationen gezeigt.
165
Die plot-Funktion
Die plot-Anweisung erzeugt zweidimensionale Liniengrafiken. Die Daten müssen als Spaltenvektoren
übergeben werden. Die Datenpunkte werden in der Reihenfolge miteinander verbunden, wie sie in den
übergebenen Vektoren stehen.
Die beiden Formen der plot-Funktion sehen Sie in den folgenden Beispielen:
Form 1: plot(Y)
Wird nur ein Vektor übergeben, werden die Daten als Y-Werte interpretiert, und gegen ihren Index (auf der
X-Achse) geplottet.
>> ydata = sin(-pi:.1:pi);
>> plot(ydata)
Form 2: plot(X, Y)
Werden zwei Vektoren übergeben, werden sie als X und Y interpretiert.
>> xdata = 20:39; ydata = rand(20, 1);
>> plot(xdata, ydata)
>> figure
>> plot(sin(-pi:.1:pi), cos(-pi:.1:pi))
LineSpec: Linieneigenschaften einstellen
plot(X1, Y1, LineSpec, ...)
Die Plot-Funktion erlaubt ein Argument, womit drei Eigenschaften der Kurve angegeben werden können,
nämlich:
•
Line style specifier: die Art der Linie (durchgezogen, gestrichelt, gepunktet etc.)
•
Marker specifier: die Art der Datenpunkt-Marker (Punkt, Kreis, Dreieck, Stern etc.)
•
Color specifier: die Farbe der Kurve
Beispiel: Um Daten mit einer roten, gestrichelten Linie und Kreuzen als Marker zu plotten, notiert man
folgendes:
plot(x, y, '--xr')
166
167
Es ist auch möglich, Plots ohne Linien oder ohne Marker zu zeichnen, indem man die entsprechenden Specifiers
einfach weglässt.
Siehe auch die Angaben im Hilfesystem (doc linespec).
Folgendes Beispiel zeigt auch, wie in einem Plot-Befehl mehrere Datensätze auf einmal angegeben
werden können:
>> t = 0:pi/100:2*pi;
>> y1 = sin(t);
>> y2 = sin(t-0.25);
>> y3 = sin(t-0.5);
>> plot(t, y1, '-', t, y2, '--', t, y3, ':')
Weitere Eigenschaften
Weitere Eigenschaften der Linie und der Marker können wiederum mit paarweisen Argumenten beeinflusst
werden:
plot(..., 'PropertyName', PropertyValue,...)
•
MarkerFaceColor - Füllfarbe der Marker
•
MarkerEdgeColor - Farbe der Marker-Umrandung
•
MarkerSize - Grösse der Marker
•
LineWidth - Breite der Linie
•
Color - Farbe der Linie
Beispiel:
>> clf
>> x = -pi:pi/10:pi;
>> y = tan(sin(x)) - sin(tan(x));
168
>> plot(x, y, '--rs', 'LineWidth', 2,...
'MarkerEdgeColor', 'k', ...
'MarkerFaceColor', 'g', ...
'MarkerSize', 10)
Weitere Optionen finden Sie mit doc plot.
169
Balkengrafiken
Auch häufig verwendet werden Balkengrafiken. Die zweidimensionale Grundform mit vertikalen Balken heisst
bar, barh zeichnet horizontale Balken, und bar3 bzw. bar3h dasselbe dreidimensional.
Beispiele für zweidimensionale Balkengrafiken:
>> figure
>> data=rand(10,3)*20+5;
>> bar(data(:,1))
>> bar(data(:,1),0.5)
>> bar(10:10:100,data(:,1))
>> bar(data)
eine Datenspalte
andere Balkenbreite (default ist 0.8)
x-Achse anders beschriften
mehrere Gruppen von Daten
Beispiele für 3D-Balkengrafiken in verschiedenen Varianten. Kopieren Sie alle Zeilen aufs Mal ins
Command Window.
Y = cool(7);
subplot(2,3,1)
bar3(Y,'detached')
title('Detached')
subplot(2,3,2)
bar3(Y,0.25,'detached')
title('Width = 0.25')
subplot(2,3,3)
bar3(Y,'grouped')
title('Grouped')
subplot(2,3,4)
bar3(Y,0.5,'grouped')
subplot(2,3,5)
bar3(Y,'stacked')
title('Stacked')
subplot(2,3,6)
bar3(Y,0.3,'stacked')
colormap([1 0 0;0 1 0;0 0 1])
170
171
Weitere Grafik-Funktionen kurz demonstriert
Im folgenden werden Ihnen mit einem Skript weitere interessante Grafikmöglichkeiten von Matlab
demonstriert.
Bitte wechseln Sie in den Matlab-Editor, laden Sie den Skript graph_examples.m und starten
Sie ihn mit der Taste F5. Mit einem Tastendruck oder Mausclick ins Grafikfenster (Funktion
waitforbuttonpress) wechseln Sie jeweils zur nächsten Grafik.
172
Grafiken beschriften und erweitern
Meist ist es sinnvoll, Grafiken mit zusätzlichen Beschriftungen, Pfeilen, Linien und Legenden zu versehen. Im
folgenden erhalten Sie einen Überblick über die wichtigsten Funktionen.
Legenden
Die Funktion legend versieht eine Grafik mit einer Legende. In der einfachsten Form lautet der
Funktionsaufruf:
h = legend('string1', 'string2', ...)
h ist der «handle» der Legende, die Strings sind die Texte, die die einzelnen Kurven beschreiben. Beispiel:
>> x = -pi:pi/20:pi;
>> plot(x, cos(x), '-ro', x, sin(x), '-.b')
>> h = legend('cos_x', 'sin_x', 2);
>> set(h, 'Interpreter', 'none')
Erläuterung: Die letzte Zeile bezieht sich auf den von Matlab verwendeten Text-Interpreter. Dieser ist per
Default TeX - dies hat zur Folge, dass z.B. ein _ im Text so interpretiert wird, dass das folgende Zeichen als
Subscript dargestellt wird. Da dies hier nicht gewünscht ist, schalten wir diesen Interpreter aus. Weitere Details
finden Sie im Hilfe-System.
Ein nettes Feature: In der Grafik können Sie die Legende einfach mit der Maus aufgreifen und
frei verschieben, falls sie relevante Teile der Grafik verdeckt. Anschliessend können Sie die Grafik
speichern.
Die legend-Funktion hat unzählige weitere Optionen und Möglichkeiten, s. Hilfe-System.
173
Grafik mit Text versehen
Mit der text-Funktion können Sie Texte an beliebigen Orten in der aktuellen Grafik plazieren. Die
Koordinaten für die Plazierung entsprechen denjenigen der Daten (wie in den Skalen eingestellt).
Im folgenden Beispiel sehen Sie die Anwendung des TeX-Interpreters, um eine Formel anzuzeigen. Mit einem
weiteren Parameter wird die Textgrösse eingestellt.
>> plot(0:pi/20:2*pi, sin(0:pi/20:2*pi))
>> text(pi, 0, ' \leftarrow sin(\pi)', 'FontSize', 18)
Auch hier muss wieder auf das Hilfe-System verwiesen werden, da eine ausführliche Beschreibung
aller Text-Optionen den Rahmen dieses Kapitels sprengen würden.
Geometrische Elemente
Mit den folgenden beiden Elementen kann man direkt in die Grafik zeichnen. Die Koordinaten entsprechen
wiederum denjenigen der Achsen.
Linien
Mit der line-Funktion kann man beliebige Linien in die Grafik zeichnen. Die Grundform dieser Funktion
lautet für die zweidimensionale Anwendung:
line(X, Y, 'PropertyName', propertyvalue,...)
X und Y sind Vektoren, die zwei oder mehr Koordinaten spezifizieren, welche von der Funktion durch gerade
Linien verbunden werden. Die Properties müssen auch hier als Argument-Paare notiert werden. Beispiel:
>> line([0 1 .5], [0 1 .8], 'LineStyle', '--', 'Color', 'blue', 'LineWidth', 5)
174
Rechtecke und Ellipsen
Mit der Funktion rectangle können Rechtecke (auch mit beliebig abgerundeten Ecken) und Ellipsen
konstruiert werden. Diese können auch gefüllt werden.
rectangle('Position', [x,y,w,h], 'PropertyName', 'PropertyValue', ...)
x und y sind die Koordinaten der linken unteren Ecke, w und h sind Breite und Höhe des Rechtecks. Mittels
dem Property Curvature kann man die Ecken abrunden.
Einige Beispiele:
>> figure, axis([0 16 0 8])
>> rectangle('Position', [1 1 4 3], 'LineWidth', 2) % default:schwarz
>> rectangle('Position', [11 2 4 3], 'Curvature', .2, 'EdgeColor', 'red')
>> rectangle('Position', [6 .5 4 6], 'Curvature', [1 1], 'FaceColor', [.4 .4 .8])
Annotations
Die sog. «Annotations» (engl. Anmerkung, Kommentar, Vermerk) sind eine weitere Möglichkeit, Grafiken mit
Texten und geometrischen Elementen zu versehen. Auch mit Annotations kann man Texte, Linien, Rechtecke
und Ellipsen zeichnen, zusätzlich auch Pfeile/Textpfeile.
Der Unterschied zu text/line/rectangle ist, dass die Koordinaten für die Plazierung von
Annotations nicht diejenigen der Achsen sind, sondern «normalisierte» Koordinaten, also zwischen 0
und 1 für die ganze Figur (nicht die Achsen). 0,0 ist die linke untere Ecke, 1,1 die rechte obere.
Annotations werden in einen eigenen «Layer» gezeichnet. Dieser wird nicht verändert, auch wenn die
eigentliche Grafik z.B. in den Skalen verändert oder gelöscht wird.
Alle Annotations werden über die gleiche Funktion annotation und den entsprechenden Parametern
verwendet. Das Grundformat sieht wie folgt aus:
annotation(type, parameters)
Es gibt folgende Typen von Annotations, wobei x und y die normalisierten Koordinaten sind, w und h sind
Breite bzw. Höhe, ebenfalls normalisiert.
annotation('line', x, y)
175
annotation('arrow', x, y)
annotation('doublearrow', x, y)
annotation('textarrow', x, y)
annotation('textbox', [x y w h])
annotation('ellipse', [x y w h])
annotation('rectangle', [x y w h])
>> figure, scatter(rand(100, 1) * 20 + 12, rand(100, 1) * 30 - 10)
>> annotation('rectangle', [.05 .05 .9 .9], 'EdgeColor', 'r');
>> annotation('line', [.2 .8], [.9 .9], 'LineStyle', '-.', 'color', 'b');
>> annotation('ellipse', [.5 .5 .2 .2], 'FaceColor', 'g');
>> annotation('arrow', [0 1], [.5 .5]);
>> annotation('textarrow',[.8 .5],[.3 .5],'String','Textpfeil','HeadStyle','plain');
>> annotation('textbox', [.2 .2 .3 .15 ], 'String', 'Dies ist eine Textbox');
Bemerkung: annotation gibt immer einen Handle zurück, daher wird am Ende der Zeile ein Strichpunkt
benötigt, um die Ausgabe desselben im Command Window zu verhindern.
176
Aufgabe P5: Projektarbeit - Grafische Darstellung der Daten
Realisieren Sie in Ihrem Projekt die grafische Darstellung der Daten. Entsprechend Ihrer spezifischen
Problemstellung kann es sich dabei um Linien, Balkendiagramme etc. handeln. Oft ist es sinnvoll, die
Grafiken auch automatisch auf die Festplatte zu speichern (an einen fixen Ort, oder vom Anwender
ausgewählt).
•
•
•
Erstellen Sie eine Balkengrafik, in der die Fixationsdauern über alle Vpn pro Bedingung (Bildgrösse)
dargestellt werden (die bereits berechneten gemittelten Medianwerte). Fügen Sie eine Legende und
Fehlerbalken mit der Standardabweichung hinzu.
Zeichnen Sie für jede Bildgrösse einen Scatterplot aller Fixationen. Markieren Sie mit rectangle
den Bereich des Bildes, wie unten dargestellt.
Die Eckpunkte der Bildausschnitte sind: (startx, starty, stopx, stopy)
Size 1: volle Grösse 1600 x 1200
Size 2: 196, 148, 1402, 1052
Size 3: 385, 289, 1213, 909
Size 4: 571, 429, 1028, 771
Speichern Sie die Grafiken auf die Festplatte, entweder an einen fixen Ort mit vorgegebenen Dateinamen,
oder an einen vom Anwender ausgewählten Ort mit entsprechend frei wählbaren Dateinamen.
So ungefähr sollte die Balkengrafik der Fixationsdauern aussehen
177
Beispiel für einen Scatterplot der Fixationsdaten pro Bildgrösse
Die Musterlösung finden Sie im m-File eyedata_sol5.m
178
Zusammenfassung
•
plot: Plotten von Daten
bar, barh, bar3, bar3h: Balkengrafiken normal, horizontal, bzw. 3D
•
und 3D horizontal
legend: Legende einblenden
•
text,
•
•
line,
rectangle: Text, Linie, Rechteck im aktuellen
Achsensystem der Figur zeichnen
annotation: Grafische Elemente in relativen Koordinaten der ganzen Figur
zeichnen,
z.B. annotation('rectangle',
[.05 .05 .9 .9],
'EdgeColor', 'r');
179
Schlussbemerkungen
Sie sind nun am Ende dieses Lehrmittels angekommen. Wir hoffen, dass es Ihnen geholfen hat, einen
Einstieg in Matlab zu finden. Es ist uns bewusst, dass das Erlernen einer neuen Programmiersprache eine sehr
anspruchsvolles Unterfangen ist, besonders falls Sie vorher noch nie programmiert hatten.
Deshalb sind wir auch um eine fortlaufende Verbesserung dieses Lehrmittels bemüht. Falls sie Rückmeldungen
zu Problemen oder Fehlern haben, zögern Sie bitte nicht, uns zu kontaktieren!
180

PDF-Druckversion - eTools

Transcription

Similar documents

Folien KGÃ 7

Die Faktorenanalyse : ein modernes statistisches Hilfsmittel des

Der Tumor

300086 Zustandsmodul - SKS

Projektdokumentation

2001 - Uni Marburg

JAHRESBERICHT - des Klinikums

References -K - Extras Springer

Bedeutung von DUSP1 und die Expression MAPKinasen

Dictionary on comprehensive security in Indonesia