Boolean and logical indexing done
This commit is contained in:
parent
91dc9e1f3b
commit
0c8d6625f8
21
programming/code/logicalIndexingBenchmark.m
Normal file
21
programming/code/logicalIndexingBenchmark.m
Normal 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
12
programming/code/logicalIndexingTime.m
Normal 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
12
programming/code/logicalVector.m
Normal 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
9
programming/code/vectorsize.m
Normal 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))
|
||||
@ -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
|
||||
@ -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
|
||||
|
||||
b(:,:,2) =
|
||||
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
|
||||
\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}
|
||||
|
||||
\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
|
||||
Bedeutung sind hier zwei Strukturen:
|
||||
\begin{enumerate}
|
||||
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:
|
||||
|
||||
\item Schleifen.
|
||||
\item Bedingte Anweisungen und Verzweigungen.
|
||||
\end{enumerate}
|
||||
%\end{definition}
|
||||
\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}
|
||||
|
||||
Reference in New Issue
Block a user