Boolean and logical indexing done

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

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'

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)

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

programming/lectures/programming.tex

@@ -6,7 +6,7 @@
 
 \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
@@ -136,13 +136,12 @@ unterschiedlichem Speicherbedarf und Wertebreich.
   \centering
   \caption{Grundlegende Datentypen und ihr Wertebereich.}
   \label{dtypestab}
-\begin{tabular}{llcl}
+  \begin{tabular}{llcl}\hline
-\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  \\
-int16 & 64 bit & $-2^{15}$ bis $2^{15}-1$ & Digitalisierte Spannungen. \\
+    int16 & 16 bit & $-2^{15}$ bis $2^{15}-1$ & Digitalisierte Spannungen. \\
-uint8 & 64 bit & $0$ bis $255$ & Digitalisierte Imaging Daten. \\ \hline
+    uint8 & 8 bit & $0$ bis $255$ & Digitalisierte Imaging Daten. \\ \hline  
   \end{tabular}
 \end{table}
 
@@ -300,7 +299,7 @@ ans =
   11  13  15  17  19
 \end{lstlisting}
 
-\begin{exercise}{vectorsize.m}{}
+\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?
@@ -721,21 +720,163 @@ ans =
 
 \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}
 
-%\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
+unter bestimmten Bedingungen ausgef\"uhrt werden. Von gro[\ss]er
 Bedeutung sind hier zwei Strukturen:
-  \begin{enumerate}
 
+\begin{enumerate}
 \item Schleifen.
 \item Bedingte Anweisungen und Verzweigungen.
 \end{enumerate}
-%\end{definition}
+
+\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}