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}