teaching/scientificComputing
Archived
3
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Boolean and logical indexing done

Browse Source
This commit is contained in:
Jan Grewe 2015-11-05 19:57:51 +01:00
parent 91dc9e1f3b
commit 0c8d6625f8
5 changed files with 495 additions and 300 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
programming/code/logicalIndexingBenchmark.m Normal file
View File

@ -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

12
programming/code/logicalIndexingTime.m Normal file
View File

@ -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'

12
programming/code/logicalVector.m Normal file
View File

@ -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)

9
programming/code/vectorsize.m Normal file
View File

@ -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))

737
programming/lectures/programming.tex
View File

@ -6,7 +6,7 @@
\subsection{Variablen} \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 Zeiger hat einen Namen, den Variablennamen, und einen Datentyp
(Abbildung \ref{variablefig}). Im Speicher wird der Wert der Variablen (Abbildung \ref{variablefig}). Im Speicher wird der Wert der Variablen
bin\"ar gespeichert. Wird auf den Wert der Variable zugegriffen, wird 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. befassen.
\begin{figure} \begin{figure}
\centering \centering
\begin{subfigure}{.5\textwidth} \begin{subfigure}{.5\textwidth}
\includegraphics[width=0.8\textwidth]{variable} \includegraphics[width=0.8\textwidth]{variable}
\label{variable:a} \label{variable:a}
\end{subfigure}% \end{subfigure}%
\begin{subfigure}{.5\textwidth} \begin{subfigure}{.5\textwidth}
\includegraphics[width=.8\textwidth]{variableB} \includegraphics[width=.8\textwidth]{variableB}
\label{variable:b} \label{variable:b}
\end{subfigure} \end{subfigure}
\caption{\textbf{Variablen.} Variablen sind Zeiger auf eine Adresse \caption{\textbf{Variablen.} Variablen sind Zeiger auf eine Adresse
im Speicher, die einen Namen und einen Datentypen beinhalten. Im im Speicher, die einen Namen und einen Datentypen beinhalten. Im
Speicher ist der Wert der Variable bin\"ar gespeichert. Abh\"angig Speicher ist der Wert der Variable bin\"ar gespeichert. Abh\"angig
vom Datentyp wird dieses Bitmuster unterschiedlich vom Datentyp wird dieses Bitmuster unterschiedlich
interpretiert.}\label{variablefig} interpretiert.}\label{variablefig}
\end{figure} \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 oder einer Funktion an beliebiger Stelle erzeugen. Das folgende
Listing zeigt zwei M\"oglichkeiten: Listing zeigt zwei M\"oglichkeiten:
\begin{lstlisting}[label=varListing1, caption=Erzeugen von Variablen] \begin{lstlisting}[label=varListing1, caption=Erzeugen von Variablen]
>> y = [] >> y = []
y = y =
[] []
>> >>
>> x = 38 >> x = 38
x = x =
38 38
\end{lstlisting} \end{lstlisting}
Die Zeile 1 kann etwa so gelesen werden:''Erzeuge eine Variable mit 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. Variablen diesen Datentyp.
\begin{lstlisting}[label=varListing2, caption={Erfragen des Datentyps einer Variable, Listen aller definierten Variablen.}] \begin{lstlisting}[label=varListing2, caption={Erfragen des Datentyps einer Variable, Listen aller definierten Variablen.}]
>>disp(class(x)) >>disp(class(x))
double double
>> >>
>> who % oder whos um mehr Information zu bekommen >> who % oder whos um mehr Information zu bekommen
\end{lstlisting} \end{lstlisting}
Bei der Namensgebung ist zu beachten, dass \matlab{} auf Gro{\ss}- und 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. dargestellt. Das folgende Listing zeigt, wie sie benutzt werden.
\begin{lstlisting}[label=varListing3, caption={Rechnen mit Variablen.}] \begin{lstlisting}[label=varListing3, caption={Rechnen mit Variablen.}]
>> x = 1; >> x = 1;
>> x + 10 >> x + 10
ans = ans =
11 11
>> >>
>> x % x wurde nicht veraendert >> x % x wurde nicht veraendert
ans = ans =
1 1
>> >>
>> y = 2; >> y = 2;
>> >>
>> x + y >> x + y
ans = ans =
3 3
>> >>
>> z = x + y >> z = x + y
z = z =
3 3
>> >>
>> z = z * 5; >> z = z * 5;
>> z >> z
z = z =
15 15
>> >>
>> clear z >> clear z
\end{lstlisting} \end{lstlisting}
Beachtenswert ist z.B. in Zeilen 3 und 6, dass wir mit dem Inhalt 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. unterschiedlichem Speicherbedarf und Wertebreich.
\begin{table}[] \begin{table}[]
\centering \centering
\caption{Grundlegende Datentypen und ihr Wertebereich.} \caption{Grundlegende Datentypen und ihr Wertebereich.}
\label{dtypestab} \label{dtypestab}
\begin{tabular}{llcl} \begin{tabular}{llcl}\hline
\hline Datentyp & Speicherbedarf & Wertebereich & Beispiel \rule{0pt}{2.5ex} \\ \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}\\
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 \\
int & 64 bit & $-2^{31}$ bis $2^{31}-1$ & Ganzzahlige Werte \\ int16 & 16 bit & $-2^{15}$ bis $2^{15}-1$ & Digitalisierte Spannungen. \\
int16 & 64 bit & $-2^{15}$ bis $2^{15}-1$ & Digitalisierte Spannungen. \\ uint8 & 8 bit & $0$ bis $255$ & Digitalisierte Imaging Daten. \\ \hline
uint8 & 64 bit & $0$ bis $255$ & Digitalisierte Imaging Daten. \\ \hline \end{tabular}
\end{tabular}
\end{table} \end{table}
@ -165,19 +164,19 @@ ben\"otigen.
\section{Vektoren und Matrizen} \section{Vektoren und Matrizen}
%\begin{definition}[Vektoren und Matrizen] % \begin{definition}[Vektoren und Matrizen]
Vektoren und Matrizen sind die wichtigsten Datenstrukturen in Vektoren und Matrizen sind die wichtigsten Datenstrukturen in
\matlab. In anderen Programmiersprachen spricht man von ein- \matlab. In anderen Programmiersprachen spricht man von ein-
bzw. mehrdimensionalen Feldern. Felder sind Datenstrukturen, die bzw. mehrdimensionalen Feldern. Felder sind Datenstrukturen, die
mehrere Werte des geleichen Datentyps in einer Variablen mehrere Werte des geleichen Datentyps in einer Variablen
vereinen. Da Matalb seinen Ursprung in der Verarbeitung von vereinen. Da Matalb seinen Ursprung in der Verarbeitung von
mathematischen Vektoren und Matrizen hat, werden sie hier auch so mathematischen Vektoren und Matrizen hat, werden sie hier auch so
genannt. genannt.
\matlab{} macht keinen Unterschied zwischen Vektoren und Matrizen. \matlab{} macht keinen Unterschied zwischen Vektoren und Matrizen.
Vektoren sind 2-dimsensionale Matrizen bei denen eine Dimension die Gr\"o{\ss}e 1 Vektoren sind 2-dimsensionale Matrizen bei denen eine Dimension die Gr\"o{\ss}e 1
hat. hat.
%\end{definition} % \end{definition}
\subsection{Vektoren} \subsection{Vektoren}
@ -190,27 +189,27 @@ enth\"alt in diesem Beispiel vier ganzzahlige Werte.
\begin{figure} \begin{figure}
\includegraphics[width=0.8\columnwidth]{scalarArray} \includegraphics[width=0.8\columnwidth]{scalarArray}
\caption{\textbf{Skalare und Vektoren. A)} Eine skalare Variable kann \caption{\textbf{Skalare und Vektoren. A)} Eine skalare Variable kann
genau einen Wert tragen. \textbf{B)} Ein Vektor kann mehrer genau einen Wert tragen. \textbf{B)} Ein Vektor kann mehrer
Werte des gleichen Datentyps (z.B. ganzzahlige Integer Werte) Werte des gleichen Datentyps (z.B. ganzzahlige Integer Werte)
beinhalten. \matlab{} kennt den Zeilen- (row-) und Spaltenvektor beinhalten. \matlab{} kennt den Zeilen- (row-) und Spaltenvektor
(columnvector).}\label{vectorfig} (columnvector).}\label{vectorfig}
\end{figure} \end{figure}
Das folgende Listing zeigt, wie einfache Vektoren erstellt werden Das folgende Listing zeigt, wie einfache Vektoren erstellt werden
k\"onnen. k\"onnen.
\begin{lstlisting}[label=arrayListing1, caption={Erstellen einfacher Zeilenvektoren.}] \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] % Erstellen eines Zeilenvektors
a = a =
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
>> >>
>> b = (0:9) % etwas bequemer >> b = (0:9) % etwas bequemer
b = b =
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
>> >>
>> c = (0:2:10) >> c = (0:2:10)
c = c =
0 2 4 6 8 10 0 2 4 6 8 10
\end{lstlisting} \end{lstlisting}
Die L\"ange eines Vektors, d.h. die Anzahl der Elemente des Vektors, 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: Falle des Vektors \code{a} von oben erh\"alt man folgende Ausgabe:
\begin{lstlisting}[label=arrayListing2, caption={Gr\"o{\ss}e von Vektoren.}] \begin{lstlisting}[label=arrayListing2, caption={Gr\"o{\ss}e von Vektoren.}]
>> length(a) >> length(a)
ans = ans =
10 10
>> size(a) >> size(a)
ans = ans =
1 10 1 10
\end{lstlisting} \end{lstlisting}
Diese Ausgabe zeigt, dass Vektoren im Grunde 2-dimensional sind. Bei 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. 1. \code{length(a)} gibt die l\"angste Ausdehnung an.
\begin{lstlisting}[label=arrayListing3, caption={Spaltenvektoren.}] \begin{lstlisting}[label=arrayListing3, caption={Spaltenvektoren.}]
>> b = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10] % Erstellen eines Spaltenvektors >> b = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10] % Erstellen eines Spaltenvektors
b = b =
1 1
2 2
... ...
9 9
10 10
>> length(b) >> length(b)
ans = ans =
10 10
>> size(b) >> size(b)
ans = ans =
10 1 10 1
>> b = b'; % Transponieren >> b = b'; % Transponieren
>> size(b) >> size(b)
ans = ans =
1 10 1 10
\end{lstlisting} \end{lstlisting}
Der \code{'}- Operator transponiert den Spaltenvektor zu einem 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. man mit dem Index auf die Inhalte zugreifen kann.
\begin{lstlisting}[label=arrayListing4, caption={Zugriff auf den Inhalt von Vektoren I}] \begin{lstlisting}[label=arrayListing4, caption={Zugriff auf den Inhalt von Vektoren I}]
>> a = (11:20); >> a = (11:20);
>> a(1) % das 1. Element >> a(1) % das 1. Element
ans = ans =
11 11
>> a(5) % das 5. Element >> a(5) % das 5. Element
ans = ans =
15 15
>> a(end) % das letzte Element >> a(end) % das letzte Element
ans = ans =
20 20
\end{lstlisting} \end{lstlisting}
Hierbei kann auf einzelne Werte zugegriffen werden oder, analog zur 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. Element gleichzeitig zuzugreifen.
\begin{lstlisting}[caption={Zugriff auf den Inhalt von Vektoren I}, label=arrayListing5] \begin{lstlisting}[caption={Zugriff auf den Inhalt von Vektoren I}, label=arrayListing5]
>> a([1 3 5]) % das 1., 3. und 5. Element >> a([1 3 5]) % das 1., 3. und 5. Element
ans = ans =
11 13 15 11 13 15
>> a(2:4) % alle Elemente von Index 2 bis einschliesslich 4 >> a(2:4) % alle Elemente von Index 2 bis einschliesslich 4
ans = ans =
12 13 14 12 13 14
>> a(1:2:end) %jedes zweite Element >> a(1:2:end) %jedes zweite Element
ans = ans =
11 13 15 17 19 11 13 15 17 19
\end{lstlisting} \end{lstlisting}
\begin{exercise}{vectorsize.m}{} \begin{exercise}{vectorsize.m}{vectorsize.out}
Der R\"uckgabewert von \code{size(a)} ist wieder ein Vektor der 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 L\"ange 2. Wie k\"onnte man also die Gr\"o{\ss}e von \code{a} in der
zweiten Dimension herausfinden? zweiten Dimension herausfinden?
\end{exercise} \end{exercise}
\subsubsection{Operationen auf Vektoren} \subsubsection{Operationen auf Vektoren}
@ -312,30 +311,30 @@ Mit Vektoren kann sehr einfach gerechnet werden. Listing
\ref{arrayListing5} zeigt Rechnungen mit Vektoren. \ref{arrayListing5} zeigt Rechnungen mit Vektoren.
\begin{lstlisting}[caption={Rechnen mit Vektoren.},label=arrayListing5] \begin{lstlisting}[caption={Rechnen mit Vektoren.},label=arrayListing5]
>> a = (0:2:8); >> a = (0:2:8);
>> a + 5 % addiere einen Skalar >> a + 5 % addiere einen Skalar
ans = ans =
5 7 9 11 13 5 7 9 11 13
>> a - 5 % subtrahiere einen Skalar >> a - 5 % subtrahiere einen Skalar
ans = ans =
-5 -3 -1 1 3 -5 -3 -1 1 3
>> a .* 2 % Multiplication >> a .* 2 % Multiplication
ans = ans =
0 4 8 12 16 0 4 8 12 16
>> a ./ 2 % Division >> a ./ 2 % Division
ans = ans =
0 1 2 3 4 0 1 2 3 4
>> a(1:3) + a(2:4) % Addieren von 2 Vektoren >> a(1:3) + a(2:4) % Addieren von 2 Vektoren
ans = ans =
2 6 10 2 6 10
>> >>
>> a(1:2) + a(2:4) % Vektoren muessen gleich gross sein! >> a(1:2) + a(2:4) % Vektoren muessen gleich gross sein!
??? Error using ==> plus ??? Error using ==> plus
Matrix dimensions must agree. Matrix dimensions must agree.
\end{lstlisting} \end{lstlisting}
Wird ein Vektor mit einem skalaren Wert verrechnet, dann ist das 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. entsprechenden Zellen einen leeren Wert (\code{[]}) zu.
\begin{lstlisting}[label=arrayListing6, caption={L\"oschen von Elementen aus einem Vektor.}] \begin{lstlisting}[label=arrayListing6, caption={L\"oschen von Elementen aus einem Vektor.}]
>> a = (0:2:8); >> a = (0:2:8);
>> length(a) >> length(a)
ans = ans =
5 5
>> a(1) = [] % loesche das erste Element >> a(1) = [] % loesche das erste Element
a = 2 4 6 8 a = 2 4 6 8
>> a([1 3]) = [] >> a([1 3]) = []
a = 4 8 a = 4 8
>> length(a) >> length(a)
ans = ans =
2 2
\end{lstlisting} \end{lstlisting}
Neben dem L\"oschen von Vektorinhalten k\"onnen Vektoren auch 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. ``rechenintensiv'' und sollte soweit m\"oglich vermieden werden.
\begin{lstlisting}[caption={Zusammenf\"ugen und Erweitern von Vektoren.}, label=arrayListing7] \begin{lstlisting}[caption={Zusammenf\"ugen und Erweitern von Vektoren.}, label=arrayListing7]
>> a = (0:2:8); >> a = (0:2:8);
>> b = (10:2:19); >> b = (10:2:19);
>> c = [a b] % erstelle einen Vektor aus einer Liste von Vektoren >> c = [a b] % erstelle einen Vektor aus einer Liste von Vektoren
c = c =
0 2 4 6 8 10 12 14 16 18 0 2 4 6 8 10 12 14 16 18
>> length(c) >> length(c)
ans = ans =
10 10
>> length(a) + length(b) >> length(a) + length(b)
ans = ans =
10 10
>> c = [a b']; >> c = [a b'];
Error using horzcat Error using horzcat
Dimensions of matrices being concatenated are not consistent. Dimensions of matrices being concatenated are not consistent.
>> b(6:8) = [1 2 3 4]; >> b(6:8) = [1 2 3 4];
\end{lstlisting} \end{lstlisting}
@ -425,24 +424,24 @@ Vektor, durch \code{[]} eingeschlossen. Das \code{;} trennt die
einzelnen Zeilen der Matrize. einzelnen Zeilen der Matrize.
\begin{lstlisting}[label=matrixListing, caption={Erzeugen von Matrizen.}] \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]
>> a = >> a =
1 2 3 1 2 3
4 5 6 4 5 6
7 8 9 7 8 9
>> >>
>> b = ones(3,3,2); >> b = ones(3,3,2);
>> b >> b
b(:,:,1) = b(:,:,1) =
1 1 1 1 1 1
1 1 1 1 1 1
1 1 1 1 1 1
b(:,:,2) = b(:,:,2) =
1 1 1 1 1 1
1 1 1 1 1 1
1 1 1 1 1 1
\end{lstlisting} \end{lstlisting}
Zur Defintion von mehr-dimensionalen Matrizen ist die Notation in 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, \begin{lstlisting}[caption={Zugriff auf Inhalte von Matrizen,
Indexierung.}, label=matrixIndexing] Indexierung.}, label=matrixIndexing]
>> x = randi(100, [3, 4, 5]); % 3-D Matrix mit Zufallszahlen >> x = randi(100, [3, 4, 5]); % 3-D Matrix mit Zufallszahlen
>> size(x) >> size(x)
ans = ans =
3 4 5 3 4 5
>> x(1,1,1); % obere linke Ecke >> x(1,1,1); % obere linke Ecke
ans(1,1,1) = ans(1,1,1) =
14 14
>> >>
>> x(1,1,:) % obere linke Ecke entlang der 3. Dimension >> x(1,1,:) % obere linke Ecke entlang der 3. Dimension
ans(1,1,:) = ans(1,1,:) =
14 14
ans(:,:,2) = ans(:,:,2) =
58 58
ans(:,:,3) = ans(:,:,3) =
4 4
ans(:,:,4) = ans(:,:,4) =
93 93
ans(:,:,5) = ans(:,:,5) =
56 56
\end{lstlisting} \end{lstlisting}
Alternativ zum \textit{subscript indexing} k\"onnen die Zellen einer 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} \end{figure}
\begin{lstlisting}[label=matrixLinearIndexing, caption={Lineares Indexieren in Matrizen.}] \begin{lstlisting}[label=matrixLinearIndexing, caption={Lineares Indexieren in Matrizen.}]
>> x = randi(100, [3, 4, 5]); % 3-D Matrix mit Zufallszahlen >> x = randi(100, [3, 4, 5]); % 3-D Matrix mit Zufallszahlen
>> size(x) >> size(x)
ans = ans =
3 4 5 3 4 5
>> numel(x) >> numel(x)
ans = ans =
60 60
>> min(min(min(x))) % Minumum uber die Zeilen, Spalten, Blaetter... >> min(min(min(x))) % Minumum uber die Zeilen, Spalten, Blaetter...
ans = ans =
4 4
>> min(x(:)) % oder so >> min(x(:)) % oder so
ans = ans =
4 4
\end{lstlisting} \end{lstlisting}
@ -545,29 +544,29 @@ Eine elementweise Multiplikation (\code{.*} Operator, Listing
durchgef\"uhrt werden soll. durchgef\"uhrt werden soll.
\begin{lstlisting}[label=matrixOperations, caption={Zwei Arten von Multiplikationen auf Matrizen.}] \begin{lstlisting}[label=matrixOperations, caption={Zwei Arten von Multiplikationen auf Matrizen.}]
>> A = randi(10, [3, 3]) % 2-D Matrix >> A = randi(10, [3, 3]) % 2-D Matrix
A = A =
3 8 2 3 8 2
2 10 3 2 10 3
10 7 1 10 7 1
>> B = randi(10, [3, 3]) % dto >> B = randi(10, [3, 3]) % dto
B = B =
2 1 7 2 1 7
1 5 9 1 5 9
5 10 5 5 10 5
>> >>
>> A * B % Matrix Multiplikation >> A * B % Matrix Multiplikation
ans = ans =
24 63 103 24 63 103
29 82 119 29 82 119
32 55 138 32 55 138
>> >>
>> A .* B % Elementweise Multiplikation >> A .* B % Elementweise Multiplikation
ans = ans =
6 8 14 6 8 14
2 50 27 2 50 27
50 70 5 50 70 5
>> >>
\end{lstlisting} \end{lstlisting}
\section{Boolesche Operationen} \section{Boolesche Operationen}
@ -680,62 +679,204 @@ grundverschiedene Dinge sind. Da sie umgangsprachlich gleich sind kann
man sie leider leicht verwechseln. man sie leider leicht verwechseln.
\begin{lstlisting}[caption={Boolesche Ausdr\"ucke.}, label=booleanexpressions] \begin{lstlisting}[caption={Boolesche Ausdr\"ucke.}, label=booleanexpressions]
>> true >> true
ans = ans =
1 1
>> false >> false
ans = ans =
0 0
>> logical(1) >> logical(1)
ans = ans =
1 1
>> 1 == true >> 1 == true
ans = ans =
1 1
>> 1 == false >> 1 == false
ans = ans =
0 0
>> logical('test') >> logical('test')
ans = ans =
1 1 1 1 1 1 1 1
>> 1 > 2 >> 1 > 2
ans = ans =
0 0
>> 1 < 2 >> 1 < 2
ans = ans =
1 1
>> x = [2 0 0 5 0] & [1 0 3 2 0] >> x = [2 0 0 5 0] & [1 0 3 2 0]
x = x =
1 0 0 1 0 1 0 0 1 0
>> ~([2 0 0 5 0] & [1 0 3 2 0]) >> ~([2 0 0 5 0] & [1 0 3 2 0])
ans = ans =
0 1 1 0 1 0 1 1 0 1
>> [2 0 0 5 0] | [1 0 3 2 0] >> [2 0 0 5 0] | [1 0 3 2 0]
ans = ans =
1 0 1 1 0 1 0 1 1 0
\end{lstlisting} \end{lstlisting}
\section{Logisches Indizieren}\label{logicalindexingsec} \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}
\begin{exercise}{logicalVector.m}{logicalVector.out}
Erstelle einen Vektor x mit den Werten 0-10.
\begin{enumerate}
\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}
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} \section{Kontrollstrukturen}\label{controlstructsec}
%\begin{definition}[Kontrollstrukturen] In der Regel wird ein Programm Zeile f\"ur Zeile von oben nach unten
In der Regel wird ein Programm Zeile f\"ur Zeile von oben nach unten ausgef\"uhrt. Manchmal muss der Kontrollfluss aber so gesteuert
ausgef\"uhrt. Manchmal muss der Kontrollfluss aber so gesteuert werden, dass bestimmte Teile des Programmcodes wiederholt oder nur
werden, dass bestimmte Teile des Programmcodes wiederholt oder nur unter bestimmten Bedingungen ausgef\"uhrt werden. Von gro[\ss]er
unter bestimmten Bedingungen ausgef\"uhrt werden. Von grosser Bedeutung sind hier zwei Strukturen:
Bedeutung sind hier zwei Strukturen:
\begin{enumerate}
\item Schleifen. \begin{enumerate}
\item Bedingte Anweisungen und Verzweigungen. \item Schleifen.
\end{enumerate} \item Bedingte Anweisungen und Verzweigungen.
%\end{definition} \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} \section{Skripte und Funktionen}