From 0c8d6625f849da12b7ff8deb18b41dce9b4a45c5 Mon Sep 17 00:00:00 2001
From: Jan Grewe <jan.grewe@g-node.org>
Date: Thu, 5 Nov 2015 19:57:51 +0100
Subject: [PATCH] Boolean and logical indexing done
---
programming/code/logicalIndexingBenchmark.m | 21 +
programming/code/logicalIndexingTime.m | 12 +
programming/code/logicalVector.m | 12 +
programming/code/vectorsize.m | 9 +
programming/lectures/programming.tex | 741 ++++++++++++--------
5 files changed, 495 insertions(+), 300 deletions(-)
create mode 100644 programming/code/logicalIndexingBenchmark.m
create mode 100644 programming/code/logicalIndexingTime.m
create mode 100644 programming/code/logicalVector.m
create mode 100644 programming/code/vectorsize.m
diff --git a/programming/code/logicalIndexingBenchmark.m b/programming/code/logicalIndexingBenchmark.m
new file mode 100644
index 0000000..4a95184
--- /dev/null
+++ b/programming/code/logicalIndexingBenchmark.m
@@ -0,0 +1,21 @@
+% create a vector with a random numbers
+x = rand(1000000, 1);
+
+fprintf('time needed to manually filter elements smaller than 0.5 in a vector of length %i\n', length(x))
+
+tic
+results = [];
+matches = 1;
+for i = 1:length(x)
+ if x(i) < 0.5
+ results(matches) = x(i);
+ matches = matches + 1;
+ end
+end
+toc
+
+fprintf('\ntime needed to do the same with logical indexing\n')
+
+tic
+results = x(x < 0.5);
+toc
diff --git a/programming/code/logicalIndexingTime.m b/programming/code/logicalIndexingTime.m
new file mode 100644
index 0000000..5135f2d
--- /dev/null
+++ b/programming/code/logicalIndexingTime.m
@@ -0,0 +1,12 @@
+t = 0:0.001:10;
+x = randn(size(t));
+selection = x (t > 5 & t < 6);
+
+figure()
+hold on
+plot(t, x, 'displayname', 'measurements')
+plot(t(t > 5 & t < 6), selection, 'displayname', 'selection')
+xlabel('time [s]')
+ylabel('intensity')
+legend 'show'
+box 'off'
\ No newline at end of file
diff --git a/programming/code/logicalVector.m b/programming/code/logicalVector.m
new file mode 100644
index 0000000..33db329
--- /dev/null
+++ b/programming/code/logicalVector.m
@@ -0,0 +1,12 @@
+x = 1:10;
+
+%% Erstellen eines logischen Vektors
+y = x < 5;
+fprintf('Logischer Vektor y:\n');
+y
+fprintf('Datentyp von y: %s\n', class(y));
+
+%% Auswahl aller Element, die kleiner 5 sind
+fprintf('\nAlle Elemente aus x, die kleiner als 5 sind:\n')
+
+x(y)
\ No newline at end of file
diff --git a/programming/code/vectorsize.m b/programming/code/vectorsize.m
new file mode 100644
index 0000000..1db978d
--- /dev/null
+++ b/programming/code/vectorsize.m
@@ -0,0 +1,9 @@
+a = (11:20); % a vector with 10 Elements
+fprintf('length of a: %i\n', length(a))
+size_of_a = size(a); % get the size and store it in a new variable
+
+% size_of_a is a vector itself
+fprintf('number of dimensions (rank) of size_of_a: %i\n', length(size_of_a))
+
+% get the value of the second element of size_of_a
+fprintf('number of entries in the 2nd dimesion of a: %i\n', size_of_a(2))
\ No newline at end of file
diff --git a/programming/lectures/programming.tex b/programming/lectures/programming.tex
index 9c7f9c6..52724ec 100644
--- a/programming/lectures/programming.tex
+++ b/programming/lectures/programming.tex
@@ -1,12 +1,12 @@
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\chapter{\tr{Programming basics}{Programmierung in \matlab}}
\section{Variablen und Datentypen}
\subsection{Variablen}
-Eine Variable ist ein Zeiger auf eine Stelle im Speicher. Dieser
+aEine Variable ist ein Zeiger auf eine Stelle im Speicher. Dieser
Zeiger hat einen Namen, den Variablennamen, und einen Datentyp
(Abbildung \ref{variablefig}). Im Speicher wird der Wert der Variablen
bin\"ar gespeichert. Wird auf den Wert der Variable zugegriffen, wird
@@ -19,20 +19,20 @@ Bedeutung. Wir werden uns dennoch sp\"ater etwas genauer mit ihnen
befassen.
\begin{figure}
-\centering
-\begin{subfigure}{.5\textwidth}
- \includegraphics[width=0.8\textwidth]{variable}
- \label{variable:a}
-\end{subfigure}%
-\begin{subfigure}{.5\textwidth}
- \includegraphics[width=.8\textwidth]{variableB}
- \label{variable:b}
-\end{subfigure}
-\caption{\textbf{Variablen.} Variablen sind Zeiger auf eine Adresse
- im Speicher, die einen Namen und einen Datentypen beinhalten. Im
- Speicher ist der Wert der Variable bin\"ar gespeichert. Abh\"angig
- vom Datentyp wird dieses Bitmuster unterschiedlich
- interpretiert.}\label{variablefig}
+ \centering
+ \begin{subfigure}{.5\textwidth}
+ \includegraphics[width=0.8\textwidth]{variable}
+ \label{variable:a}
+ \end{subfigure}%
+ \begin{subfigure}{.5\textwidth}
+ \includegraphics[width=.8\textwidth]{variableB}
+ \label{variable:b}
+ \end{subfigure}
+ \caption{\textbf{Variablen.} Variablen sind Zeiger auf eine Adresse
+ im Speicher, die einen Namen und einen Datentypen beinhalten. Im
+ Speicher ist der Wert der Variable bin\"ar gespeichert. Abh\"angig
+ vom Datentyp wird dieses Bitmuster unterschiedlich
+ interpretiert.}\label{variablefig}
\end{figure}
@@ -41,13 +41,13 @@ In \matlab{} kann eine Variable auf der Kommandozeile, in einem Skript
oder einer Funktion an beliebiger Stelle erzeugen. Das folgende
Listing zeigt zwei M\"oglichkeiten:
\begin{lstlisting}[label=varListing1, caption=Erzeugen von Variablen]
->> y = []
-y =
- []
->>
->> x = 38
-x =
- 38
+ >> y = []
+ y =
+ []
+ >>
+ >> x = 38
+ x =
+ 38
\end{lstlisting}
Die Zeile 1 kann etwa so gelesen werden:''Erzeuge eine Variable mit
@@ -59,10 +59,10 @@ angegeben immer den ``double'' Datentypen benutzt, haben beide
Variablen diesen Datentyp.
\begin{lstlisting}[label=varListing2, caption={Erfragen des Datentyps einer Variable, Listen aller definierten Variablen.}]
->>disp(class(x))
- double
->>
->> who % oder whos um mehr Information zu bekommen
+ >>disp(class(x))
+ double
+ >>
+ >> who % oder whos um mehr Information zu bekommen
\end{lstlisting}
Bei der Namensgebung ist zu beachten, dass \matlab{} auf Gro{\ss}- und
@@ -79,31 +79,31 @@ gerechnet werden. \matlab{} kennt alle normalen arithmetischen Operatoren wie
dargestellt. Das folgende Listing zeigt, wie sie benutzt werden.
\begin{lstlisting}[label=varListing3, caption={Rechnen mit Variablen.}]
->> x = 1;
->> x + 10
-ans =
+ >> x = 1;
+ >> x + 10
+ ans =
11
->>
->> x % x wurde nicht veraendert
-ans =
+ >>
+ >> x % x wurde nicht veraendert
+ ans =
1
->>
->> y = 2;
->>
->> x + y
-ans =
+ >>
+ >> y = 2;
+ >>
+ >> x + y
+ ans =
3
->>
->> z = x + y
-z =
+ >>
+ >> z = x + y
+ z =
3
->>
->> z = z * 5;
->> z
-z =
+ >>
+ >> z = z * 5;
+ >> z
+ z =
15
->>
->> clear z
+ >>
+ >> clear z
\end{lstlisting}
Beachtenswert ist z.B. in Zeilen 3 und 6, dass wir mit dem Inhalt
@@ -133,17 +133,16 @@ Unter den numerischen Datentypen gibt es verschiedene Arten mit
unterschiedlichem Speicherbedarf und Wertebreich.
\begin{table}[]
-\centering
-\caption{Grundlegende Datentypen und ihr Wertebereich.}
-\label{dtypestab}
-\begin{tabular}{llcl}
-\hline
-Datentyp & Speicherbedarf & Wertebereich & Beispiel \rule{0pt}{2.5ex} \\ \hline
-double & 64 bit & $\approx -10^{308}$ bis $\approx 10^{308}$ & Flie{\ss}kommazahlen \rule{0pt}{2.5ex}\\
-int & 64 bit & $-2^{31}$ bis $2^{31}-1$ & Ganzzahlige Werte \\
-int16 & 64 bit & $-2^{15}$ bis $2^{15}-1$ & Digitalisierte Spannungen. \\
-uint8 & 64 bit & $0$ bis $255$ & Digitalisierte Imaging Daten. \\ \hline
-\end{tabular}
+ \centering
+ \caption{Grundlegende Datentypen und ihr Wertebereich.}
+ \label{dtypestab}
+ \begin{tabular}{llcl}\hline
+ Datentyp & Speicherbedarf & Wertebereich & Beispiel \rule{0pt}{2.5ex} \\ \hline
+ double & 64 bit & $\approx -10^{308}$ bis $\approx 10^{308} $& Flie{\ss}kommazahlen.\rule{0pt}{2.5ex}\\
+ int & 64 bit & $-2^{31}$ bis $2^{31}-1$ & Ganzzahlige Werte \\
+ int16 & 16 bit & $-2^{15}$ bis $2^{15}-1$ & Digitalisierte Spannungen. \\
+ uint8 & 8 bit & $0$ bis $255$ & Digitalisierte Imaging Daten. \\ \hline
+ \end{tabular}
\end{table}
@@ -165,19 +164,19 @@ ben\"otigen.
\section{Vektoren und Matrizen}
-%\begin{definition}[Vektoren und Matrizen]
- Vektoren und Matrizen sind die wichtigsten Datenstrukturen in
- \matlab. In anderen Programmiersprachen spricht man von ein-
- bzw. mehrdimensionalen Feldern. Felder sind Datenstrukturen, die
- mehrere Werte des geleichen Datentyps in einer Variablen
- vereinen. Da Matalb seinen Ursprung in der Verarbeitung von
- mathematischen Vektoren und Matrizen hat, werden sie hier auch so
- genannt.
+% \begin{definition}[Vektoren und Matrizen]
+Vektoren und Matrizen sind die wichtigsten Datenstrukturen in
+\matlab. In anderen Programmiersprachen spricht man von ein-
+bzw. mehrdimensionalen Feldern. Felder sind Datenstrukturen, die
+mehrere Werte des geleichen Datentyps in einer Variablen
+vereinen. Da Matalb seinen Ursprung in der Verarbeitung von
+mathematischen Vektoren und Matrizen hat, werden sie hier auch so
+genannt.
- \matlab{} macht keinen Unterschied zwischen Vektoren und Matrizen.
- Vektoren sind 2-dimsensionale Matrizen bei denen eine Dimension die Gr\"o{\ss}e 1
- hat.
-%\end{definition}
+\matlab{} macht keinen Unterschied zwischen Vektoren und Matrizen.
+Vektoren sind 2-dimsensionale Matrizen bei denen eine Dimension die Gr\"o{\ss}e 1
+hat.
+% \end{definition}
\subsection{Vektoren}
@@ -190,27 +189,27 @@ enth\"alt in diesem Beispiel vier ganzzahlige Werte.
\begin{figure}
\includegraphics[width=0.8\columnwidth]{scalarArray}
\caption{\textbf{Skalare und Vektoren. A)} Eine skalare Variable kann
- genau einen Wert tragen. \textbf{B)} Ein Vektor kann mehrer
- Werte des gleichen Datentyps (z.B. ganzzahlige Integer Werte)
- beinhalten. \matlab{} kennt den Zeilen- (row-) und Spaltenvektor
- (columnvector).}\label{vectorfig}
+ genau einen Wert tragen. \textbf{B)} Ein Vektor kann mehrer
+ Werte des gleichen Datentyps (z.B. ganzzahlige Integer Werte)
+ beinhalten. \matlab{} kennt den Zeilen- (row-) und Spaltenvektor
+ (columnvector).}\label{vectorfig}
\end{figure}
Das folgende Listing zeigt, wie einfache Vektoren erstellt werden
k\"onnen.
\begin{lstlisting}[label=arrayListing1, caption={Erstellen einfacher Zeilenvektoren.}]
->> a = [0 1 2 3 4 5 6 7 8 9] % Erstellen eines Zeilenvektors
- a =
- 0 1 2 3 4 5 6 7 8 9
->>
->> b = (0:9) % etwas bequemer
- b =
- 0 1 2 3 4 5 6 7 8 9
->>
->> c = (0:2:10)
- c =
- 0 2 4 6 8 10
+ >> a = [0 1 2 3 4 5 6 7 8 9] % Erstellen eines Zeilenvektors
+ a =
+ 0 1 2 3 4 5 6 7 8 9
+ >>
+ >> b = (0:9) % etwas bequemer
+ b =
+ 0 1 2 3 4 5 6 7 8 9
+ >>
+ >> c = (0:2:10)
+ c =
+ 0 2 4 6 8 10
\end{lstlisting}
Die L\"ange eines Vektors, d.h. die Anzahl der Elemente des Vektors,
@@ -219,12 +218,12 @@ Information kann \"uber die Funktion \code{size()} erhalten werden. Im
Falle des Vektors \code{a} von oben erh\"alt man folgende Ausgabe:
\begin{lstlisting}[label=arrayListing2, caption={Gr\"o{\ss}e von Vektoren.}]
->> length(a)
-ans =
- 10
->> size(a)
-ans =
- 1 10
+ >> length(a)
+ ans =
+ 10
+ >> size(a)
+ ans =
+ 1 10
\end{lstlisting}
Diese Ausgabe zeigt, dass Vektoren im Grunde 2-dimensional sind. Bei
@@ -232,23 +231,23 @@ einem Zeilenvektor hat die erste Dimension die Gr\"o{\ss}e
1. \code{length(a)} gibt die l\"angste Ausdehnung an.
\begin{lstlisting}[label=arrayListing3, caption={Spaltenvektoren.}]
->> b = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10] % Erstellen eines Spaltenvektors
- b =
- 1
- 2
- ...
- 9
- 10
->> length(b)
-ans =
- 10
->> size(b)
-ans =
- 10 1
->> b = b'; % Transponieren
->> size(b)
-ans =
- 1 10
+ >> b = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10] % Erstellen eines Spaltenvektors
+ b =
+ 1
+ 2
+ ...
+ 9
+ 10
+ >> length(b)
+ ans =
+ 10
+ >> size(b)
+ ans =
+ 10 1
+ >> b = b'; % Transponieren
+ >> size(b)
+ ans =
+ 1 10
\end{lstlisting}
Der \code{'}- Operator transponiert den Spaltenvektor zu einem
@@ -272,16 +271,16 @@ Anders als viele andere Sprachen beginnt \matlab{} mit dem Index
man mit dem Index auf die Inhalte zugreifen kann.
\begin{lstlisting}[label=arrayListing4, caption={Zugriff auf den Inhalt von Vektoren I}]
->> a = (11:20);
->> a(1) % das 1. Element
-ans =
- 11
->> a(5) % das 5. Element
-ans =
- 15
->> a(end) % das letzte Element
-ans =
- 20
+ >> a = (11:20);
+ >> a(1) % das 1. Element
+ ans =
+ 11
+ >> a(5) % das 5. Element
+ ans =
+ 15
+ >> a(end) % das letzte Element
+ ans =
+ 20
\end{lstlisting}
Hierbei kann auf einzelne Werte zugegriffen werden oder, analog zur
@@ -289,21 +288,21 @@ Erzeugung von Vektoren, die \code{:} Notation verwendet werden, um auf mehrere
Element gleichzeitig zuzugreifen.
\begin{lstlisting}[caption={Zugriff auf den Inhalt von Vektoren I}, label=arrayListing5]
->> a([1 3 5]) % das 1., 3. und 5. Element
-ans =
- 11 13 15
->> a(2:4) % alle Elemente von Index 2 bis einschliesslich 4
-ans =
- 12 13 14
->> a(1:2:end) %jedes zweite Element
-ans =
- 11 13 15 17 19
+ >> a([1 3 5]) % das 1., 3. und 5. Element
+ ans =
+ 11 13 15
+ >> a(2:4) % alle Elemente von Index 2 bis einschliesslich 4
+ ans =
+ 12 13 14
+ >> a(1:2:end) %jedes zweite Element
+ ans =
+ 11 13 15 17 19
\end{lstlisting}
-\begin{exercise}{vectorsize.m}{}
-Der R\"uckgabewert von \code{size(a)} ist wieder ein Vektor der
-L\"ange 2. Wie k\"onnte man also die Gr\"o{\ss}e von \code{a} in der
-zweiten Dimension herausfinden?
+\begin{exercise}{vectorsize.m}{vectorsize.out}
+ Der R\"uckgabewert von \code{size(a)} ist wieder ein Vektor der
+ L\"ange 2. Wie k\"onnte man also die Gr\"o{\ss}e von \code{a} in der
+ zweiten Dimension herausfinden?
\end{exercise}
\subsubsection{Operationen auf Vektoren}
@@ -312,30 +311,30 @@ Mit Vektoren kann sehr einfach gerechnet werden. Listing
\ref{arrayListing5} zeigt Rechnungen mit Vektoren.
\begin{lstlisting}[caption={Rechnen mit Vektoren.},label=arrayListing5]
->> a = (0:2:8);
->> a + 5 % addiere einen Skalar
-ans =
- 5 7 9 11 13
-
->> a - 5 % subtrahiere einen Skalar
-ans =
- -5 -3 -1 1 3
-
->> a .* 2 % Multiplication
-ans =
- 0 4 8 12 16
-
->> a ./ 2 % Division
-ans =
- 0 1 2 3 4
-
->> a(1:3) + a(2:4) % Addieren von 2 Vektoren
-ans =
- 2 6 10
->>
->> a(1:2) + a(2:4) % Vektoren muessen gleich gross sein!
- ??? Error using ==> plus
- Matrix dimensions must agree.
+ >> a = (0:2:8);
+ >> a + 5 % addiere einen Skalar
+ ans =
+ 5 7 9 11 13
+
+ >> a - 5 % subtrahiere einen Skalar
+ ans =
+ -5 -3 -1 1 3
+
+ >> a .* 2 % Multiplication
+ ans =
+ 0 4 8 12 16
+
+ >> a ./ 2 % Division
+ ans =
+ 0 1 2 3 4
+
+ >> a(1:3) + a(2:4) % Addieren von 2 Vektoren
+ ans =
+ 2 6 10
+ >>
+ >> a(1:2) + a(2:4) % Vektoren muessen gleich gross sein!
+ ??? Error using ==> plus
+ Matrix dimensions must agree.
\end{lstlisting}
Wird ein Vektor mit einem skalaren Wert verrechnet, dann ist das
@@ -359,20 +358,20 @@ Will man Elemente aus einem Vektor entfernen, dann weist man den
entsprechenden Zellen einen leeren Wert (\code{[]}) zu.
\begin{lstlisting}[label=arrayListing6, caption={L\"oschen von Elementen aus einem Vektor.}]
->> a = (0:2:8);
->> length(a)
-ans =
- 5
+ >> a = (0:2:8);
+ >> length(a)
+ ans =
+ 5
->> a(1) = [] % loesche das erste Element
-a = 2 4 6 8
+ >> a(1) = [] % loesche das erste Element
+ a = 2 4 6 8
->> a([1 3]) = []
-a = 4 8
+ >> a([1 3]) = []
+ a = 4 8
->> length(a)
-ans =
- 2
+ >> length(a)
+ ans =
+ 2
\end{lstlisting}
Neben dem L\"oschen von Vektorinhalten k\"onnen Vektoren auch
@@ -384,22 +383,22 @@ das Layout geachtet werden. Zudem ist dieser Vorgang
``rechenintensiv'' und sollte soweit m\"oglich vermieden werden.
\begin{lstlisting}[caption={Zusammenf\"ugen und Erweitern von Vektoren.}, label=arrayListing7]
->> a = (0:2:8);
->> b = (10:2:19);
->> c = [a b] % erstelle einen Vektor aus einer Liste von Vektoren
- c =
- 0 2 4 6 8 10 12 14 16 18
->> length(c)
-ans =
- 10
->> length(a) + length(b)
-ans =
- 10
->> c = [a b'];
-Error using horzcat
-Dimensions of matrices being concatenated are not consistent.
-
->> b(6:8) = [1 2 3 4];
+ >> a = (0:2:8);
+ >> b = (10:2:19);
+ >> c = [a b] % erstelle einen Vektor aus einer Liste von Vektoren
+ c =
+ 0 2 4 6 8 10 12 14 16 18
+ >> length(c)
+ ans =
+ 10
+ >> length(a) + length(b)
+ ans =
+ 10
+ >> c = [a b'];
+ Error using horzcat
+ Dimensions of matrices being concatenated are not consistent.
+
+ >> b(6:8) = [1 2 3 4];
\end{lstlisting}
@@ -425,24 +424,24 @@ Vektor, durch \code{[]} eingeschlossen. Das \code{;} trennt die
einzelnen Zeilen der Matrize.
\begin{lstlisting}[label=matrixListing, caption={Erzeugen von Matrizen.}]
->> a = [1 2 3; 4 5 6; 7 8 9]
->> a =
- 1 2 3
- 4 5 6
- 7 8 9
->>
->> b = ones(3,3,2);
->> b
-
- b(:,:,1) =
- 1 1 1
- 1 1 1
- 1 1 1
+ >> a = [1 2 3; 4 5 6; 7 8 9]
+ >> a =
+ 1 2 3
+ 4 5 6
+ 7 8 9
+ >>
+ >> b = ones(3,3,2);
+ >> b
+
+ b(:,:,1) =
+ 1 1 1
+ 1 1 1
+ 1 1 1
- b(:,:,2) =
- 1 1 1
- 1 1 1
- 1 1 1
+ b(:,:,2) =
+ 1 1 1
+ 1 1 1
+ 1 1 1
\end{lstlisting}
Zur Defintion von mehr-dimensionalen Matrizen ist die Notation in
@@ -477,25 +476,25 @@ Dimensionalit\"at der Matrize ist. Diese Art des Zugriffs wird
\begin{lstlisting}[caption={Zugriff auf Inhalte von Matrizen,
Indexierung.}, label=matrixIndexing]
->> x = randi(100, [3, 4, 5]); % 3-D Matrix mit Zufallszahlen
->> size(x)
-ans =
- 3 4 5
->> x(1,1,1); % obere linke Ecke
+ >> x = randi(100, [3, 4, 5]); % 3-D Matrix mit Zufallszahlen
+ >> size(x)
+ ans =
+ 3 4 5
+ >> x(1,1,1); % obere linke Ecke
ans(1,1,1) =
- 14
- >>
->> x(1,1,:) % obere linke Ecke entlang der 3. Dimension
-ans(1,1,:) =
- 14
-ans(:,:,2) =
- 58
-ans(:,:,3) =
- 4
-ans(:,:,4) =
- 93
-ans(:,:,5) =
- 56
+ 14
+ >>
+ >> x(1,1,:) % obere linke Ecke entlang der 3. Dimension
+ ans(1,1,:) =
+ 14
+ ans(:,:,2) =
+ 58
+ ans(:,:,3) =
+ 4
+ ans(:,:,4) =
+ 93
+ ans(:,:,5) =
+ 56
\end{lstlisting}
Alternativ zum \textit{subscript indexing} k\"onnen die Zellen einer
@@ -517,19 +516,19 @@ den Minimalwert aller Elemente einer Matrize ermitteln m\"ochte..
\end{figure}
\begin{lstlisting}[label=matrixLinearIndexing, caption={Lineares Indexieren in Matrizen.}]
->> x = randi(100, [3, 4, 5]); % 3-D Matrix mit Zufallszahlen
->> size(x)
-ans =
- 3 4 5
->> numel(x)
-ans =
- 60
->> min(min(min(x))) % Minumum uber die Zeilen, Spalten, Blaetter...
-ans =
- 4
->> min(x(:)) % oder so
-ans =
- 4
+ >> x = randi(100, [3, 4, 5]); % 3-D Matrix mit Zufallszahlen
+ >> size(x)
+ ans =
+ 3 4 5
+ >> numel(x)
+ ans =
+ 60
+ >> min(min(min(x))) % Minumum uber die Zeilen, Spalten, Blaetter...
+ ans =
+ 4
+ >> min(x(:)) % oder so
+ ans =
+ 4
\end{lstlisting}
@@ -545,29 +544,29 @@ Eine elementweise Multiplikation (\code{.*} Operator, Listing
durchgef\"uhrt werden soll.
\begin{lstlisting}[label=matrixOperations, caption={Zwei Arten von Multiplikationen auf Matrizen.}]
->> A = randi(10, [3, 3]) % 2-D Matrix
- A =
- 3 8 2
- 2 10 3
- 10 7 1
->> B = randi(10, [3, 3]) % dto
- B =
- 2 1 7
- 1 5 9
- 5 10 5
->>
->> A * B % Matrix Multiplikation
- ans =
- 24 63 103
- 29 82 119
- 32 55 138
->>
->> A .* B % Elementweise Multiplikation
- ans =
- 6 8 14
- 2 50 27
- 50 70 5
->>
+ >> A = randi(10, [3, 3]) % 2-D Matrix
+ A =
+ 3 8 2
+ 2 10 3
+ 10 7 1
+ >> B = randi(10, [3, 3]) % dto
+ B =
+ 2 1 7
+ 1 5 9
+ 5 10 5
+ >>
+ >> A * B % Matrix Multiplikation
+ ans =
+ 24 63 103
+ 29 82 119
+ 32 55 138
+ >>
+ >> A .* B % Elementweise Multiplikation
+ ans =
+ 6 8 14
+ 2 50 27
+ 50 70 5
+ >>
\end{lstlisting}
\section{Boolesche Operationen}
@@ -680,62 +679,204 @@ grundverschiedene Dinge sind. Da sie umgangsprachlich gleich sind kann
man sie leider leicht verwechseln.
\begin{lstlisting}[caption={Boolesche Ausdr\"ucke.}, label=booleanexpressions]
->> true
-ans =
- 1
->> false
-ans =
- 0
->> logical(1)
-ans =
- 1
->> 1 == true
-ans =
- 1
->> 1 == false
-ans =
- 0
->> logical('test')
-ans =
- 1 1 1 1
-
->> 1 > 2
-ans =
- 0
->> 1 < 2
-ans =
- 1
->> x = [2 0 0 5 0] & [1 0 3 2 0]
-x =
- 1 0 0 1 0
+ >> true
+ ans =
+ 1
+ >> false
+ ans =
+ 0
+ >> logical(1)
+ ans =
+ 1
+ >> 1 == true
+ ans =
+ 1
+ >> 1 == false
+ ans =
+ 0
+ >> logical('test')
+ ans =
+ 1 1 1 1
+
+ >> 1 > 2
+ ans =
+ 0
+ >> 1 < 2
+ ans =
+ 1
+ >> x = [2 0 0 5 0] & [1 0 3 2 0]
+ x =
+ 1 0 0 1 0
->> ~([2 0 0 5 0] & [1 0 3 2 0])
-ans =
- 0 1 1 0 1
+ >> ~([2 0 0 5 0] & [1 0 3 2 0])
+ ans =
+ 0 1 1 0 1
->> [2 0 0 5 0] | [1 0 3 2 0]
-ans =
- 1 0 1 1 0
+ >> [2 0 0 5 0] | [1 0 3 2 0]
+ ans =
+ 1 0 1 1 0
\end{lstlisting}
\section{Logisches Indizieren}\label{logicalindexingsec}
+Einer der wichtigsten Einsatzorte f\"ur Bollesche Ausdr\"ucke ist das
+logische Indizieren. Das logische Indizieren ist eines der
+Schl\"usselkonzepte in \matlab{}. Nur mit diesem k\"onnen
+Filteroperationen auf Vektoren und Matrizen effizient durchgef\"uhrt
+werden. Es ist sehr m\"achtig und, wenn es einmal verstanden wurde,
+sehr intuitiv zu benuzten.
+
+
+Das Grundkonzept hinter der logischen Indizierung ist, dass man durch
+die Verwendung eines Booleschen Ausdrucks auf z.B. einen Vektor einen
+logischen Vektor gleicher Gr\"o{\ss}e erh\"alt. Dieser wird nun
+benutzt um auf den urspr\"unglichen Vektor zuzugreifen. \matlab{} gibt
+nun die Werte an den Stellen zur\"uck, an denen der logische Vektor
+\textit{wahr} ist (Listing \ref{logicalindexing1}).
+
+
+\begin{lstlisting}[caption={Beispiel Logischen Indizieren.}, label=logicalindexing1]
+ >> x = randn(10, 1);
+ >> % in zwei Schritten
+ >> x_smaller_zero = x < 0; % logischer vektor
+ >> elements_smaller_zero = x(x_smaller_zero); % benutzen, um zuzugreifen
+ >> % oder in einem Schritt
+ >> elements_smaller_zero = x(x < 0);
+\end{lstlisting}
-\section{Kontrollstrukturen}\label{controlstructsec}
-
-%\begin{definition}[Kontrollstrukturen]
- In der Regel wird ein Programm Zeile f\"ur Zeile von oben nach unten
- ausgef\"uhrt. Manchmal muss der Kontrollfluss aber so gesteuert
- werden, dass bestimmte Teile des Programmcodes wiederholt oder nur
- unter bestimmten Bedingungen ausgef\"uhrt werden. Von grosser
- Bedeutung sind hier zwei Strukturen:
+\begin{exercise}{logicalVector.m}{logicalVector.out}
+ Erstelle einen Vektor x mit den Werten 0-10.
\begin{enumerate}
-
- \item Schleifen.
- \item Bedingte Anweisungen und Verzweigungen.
+ \item F\"uhre aus: \code{y = x < 5}
+ \item Gib den Inhalt von \code{y} auf dem Bildschirm aus.
+ \item Was ist der Datentyp von \code{y}?
+ \item Gibt alle Elemente aus x zur\"uck, die kleiner als 5 sind.
\end{enumerate}
-%\end{definition}
+
+ Die letzte Zeile kann wie folgt gelesen werden: Gib mir die Elemente
+ von (\code{x}) an den Stellen, an denen \code{x < 5} wahr ist.
+\end{exercise}
+
+\begin{exercise}{logicalIndexingTime.m}{}
+ Angenommen es werden \"uber einen bestimmten Zeitraum Messwerte
+ genommen. Bei solchen Messungen er\"alt man einen Vektor, der die
+ Zeitpunkte der Messung speichert und einen zweiten mit den
+ jeweiligen Messwerten.
+
+ \begin{itemize}
+ \item Erstelle einen Vektor \code{t= 0:0.001:10;}, der z.B. die Zeit
+ repr\"asentiert.
+ \item Erstelle einen zweiten Vektor \code{x} mit Zufallszahlen der
+ die gleiche L\"ange hat wie \code{t}. Die Werte darin stellen
+ Messungen zu den Zeitpunkten in \code{t} dar.
+ \item Benutze das logische Indizieren um die Messwerte
+ auszuw\"ahlen, die dem zeitlichen Abschnitt 5-6\,s entsprechen.
+ \end{itemize}
+ \begin{figure}
+ \includegraphics[width=0.6\textwidth]{logicalIndexing_time.png}
+ \end{figure}
+\end{exercise}
+
+
+\section{Kontrollstrukturen}\label{controlstructsec}
+
+In der Regel wird ein Programm Zeile f\"ur Zeile von oben nach unten
+ausgef\"uhrt. Manchmal muss der Kontrollfluss aber so gesteuert
+werden, dass bestimmte Teile des Programmcodes wiederholt oder nur
+unter bestimmten Bedingungen ausgef\"uhrt werden. Von gro[\ss]er
+Bedeutung sind hier zwei Strukturen:
+
+\begin{enumerate}
+\item Schleifen.
+\item Bedingte Anweisungen und Verzweigungen.
+\end{enumerate}
+
+\subsection{Schleifen}
+
+Schleifen werden gebraucht um wiederholte Ausf\"uhrung desselben Codes
+zu vereinfachen. In einer \"Ubung wurde die Fakult\"at von 5 wie in
+Listing \ref{facultylisting1} berechnet:
+
+\begin{lstlisting}[caption={Berechnung der Fakult\"at von 5 in f\"unf
+ Schritten}, label=facultylisting1]
+>> x = 1;
+>> x = x * 2;
+>> x = x * 3;
+>> x = x * 4;
+>> x = x * 5;
+>> x
+x =
+ 120
+\end{lstlisting}
+
+Im Prinzip ist das obige Programm v\"ollig in Ordnung. Es f\"allt
+jedoch auf, dass die Zeilen 2 bis 5 sehr \"ahnlich sind und
+
+ \begin{itemize}
+ \item Zeilen 2 bis 5 sind sehr \"ahnlich.
+ \item Die Verwendung von solchen Codeklonen ist schlechter Programmierstil!
+ \item Welche Nachteile hat es sonst noch?
+ \end{itemize}
+
+
+
+ \begin{itemize}
+ \item Wird genutzt um iterativ/wiederholt einen Codeabschnitt auszuf\"uhren.\pause
+ \item Eine \code{for} Schleife besteht aus dem \textit{(Schleifen-) Kopf} und dem \textit{(Schleifen-) K\"orper}.
+ \begin{itemize}
+ \item Der Schleifenkopf beginnt mit dem Schl\"usselwort
+ \textbf{for} auf welches folgend die \textit{Laufvariable}
+ definiert wird.
+ \item Die Schleife ``l\"auft''/iteriert immer(!) \"uber einen
+ Vektor.
+ \item Die \textit{Laufvariable} nimmt in jeder Iteration einen
+ Wert dieses Vektors an.
+ \item Im Schleifenk\"orper k\"onnen beliebige Anweisungen
+ ausgef\"uhrt werden.
+ \item Die Schleife wird durch das Schl\"usselwort \textbf{end}
+ beendet.
+ \end{itemize}
+ \end{itemize}
+
+ \begin{lstlisting}[label=loopListing2]
+ for x = 1:5
+ % ... etwas sinnvolles mit x ...
+ end
+ \end{lstlisting}
+
+
+
+ Zur\"uck zu unserer Implementation der Fakult\"at:
+ \begin{lstlisting}
+>> x = 1;
+>> x = x * 2;
+>> x = x * 3;
+>> x = x * 4;
+>> x = x * 5;
+>> x
+x =
+ 120
+\end{lstlisting}
+\normalsize
+Wie k\"onnte das in einer Schleife gel\"ost werden?
+
+
+ Implementatierung der Fakult\"at mithilfe einer \code{for} Schleife:
+ \begin{lstlisting}
+ x = 1;
+ for i = 1:5
+ x = x * i;
+ end
+ % oder auch
+ iterations = 1:5;
+ for i = iterations
+ x = x * i;
+ end
+\end{lstlisting}
+
+
+\subsection{Bedingte Anweisungen und Verzweigungen}
\section{Skripte und Funktionen}