1051 lines
25 KiB
TeX
1051 lines
25 KiB
TeX
\documentclass{beamer}
|
||
\usepackage{xcolor}
|
||
\usepackage{listings}
|
||
\usepackage{pgf}
|
||
%\usepackage{pgf,pgfarrows,pgfnodes,pgfautomata,pgfheaps,pgfshade}
|
||
%\usepackage{multimedia}
|
||
|
||
\usepackage[english]{babel}
|
||
\usepackage{movie15}
|
||
\usepackage[latin1]{inputenc}
|
||
\usepackage{times}
|
||
\usepackage{amsmath}
|
||
\usepackage{bm}
|
||
\usepackage[T1]{fontenc}
|
||
\usepackage[scaled=.90]{helvet}
|
||
\usepackage{scalefnt}
|
||
\usepackage{tikz}
|
||
\usepackage{ textcomp }
|
||
\usepackage{soul}
|
||
\usepackage{hyperref}
|
||
\definecolor{lightblue}{rgb}{.7,.7,1.}
|
||
\definecolor{mygreen}{rgb}{0,1.,0}
|
||
|
||
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||
\mode<presentation>
|
||
{
|
||
\usetheme{Singapore}
|
||
\setbeamercovered{opaque}
|
||
\usecolortheme{tuebingen}
|
||
\setbeamertemplate{navigation symbols}{}
|
||
\usefonttheme{default}
|
||
\useoutertheme{infolines}
|
||
% \useoutertheme{miniframes}
|
||
}
|
||
|
||
\AtBeginSection[]
|
||
{
|
||
\begin{frame}<beamer>
|
||
\begin{center}
|
||
\Huge \insertsectionhead
|
||
\end{center}
|
||
% \frametitle{\insertsectionhead}
|
||
% \tableofcontents[currentsection,hideothersubsections]
|
||
\end{frame}
|
||
}
|
||
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%5
|
||
|
||
\setbeamertemplate{blocks}[rounded][shadow=true]
|
||
|
||
\title[]{Scientific Computing -- Grundlagen der Programmierung }
|
||
\author[]{Jan Grewe\\Abteilung f\"ur Neuroethologie\\
|
||
Universit\"at T\"ubingen}
|
||
|
||
\institute[Wissenschaftliche Datenverarbeitung]{}
|
||
\date{13.10.2014 - 07.11.2014}
|
||
%\logo{\pgfuseimage{../../resources/UT_BM_Rot_RGB.pdf}}
|
||
|
||
\subject{Einf\"uhrung in wissenschaftliche Datenverarbeitung}
|
||
|
||
\titlegraphic{
|
||
\includegraphics[width=0.5\linewidth]{../../resources/UT_WBMW_Rot_RGB}
|
||
}
|
||
%%%%%%%%%% configuration for code
|
||
\lstset{
|
||
basicstyle=\ttfamily,
|
||
numbers=left,
|
||
showstringspaces=false,
|
||
language=Matlab,
|
||
commentstyle=\itshape\color{darkgray},
|
||
keywordstyle=\color{blue},
|
||
stringstyle=\color{green},
|
||
backgroundcolor=\color{blue!10},
|
||
breaklines=true,
|
||
breakautoindent=true,
|
||
columns=flexible,
|
||
frame=single,
|
||
captionpos=b,
|
||
xleftmargin=1em,
|
||
xrightmargin=1em,
|
||
aboveskip=10pt
|
||
}
|
||
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||
\newcommand{\mycite}[1]{
|
||
\begin{flushright}
|
||
\tiny \color{black!80} #1
|
||
\end{flushright}
|
||
}
|
||
|
||
\input{../../latex/environments.tex}
|
||
\makeatother
|
||
|
||
\begin{document}
|
||
|
||
\begin{frame}[plain]
|
||
\frametitle{}
|
||
\vspace{-1cm}
|
||
\titlepage % erzeugt Titelseite
|
||
\end{frame}
|
||
|
||
\begin{frame}
|
||
\frametitle{Grundlagen der Programmierung}
|
||
\frametitle{Resourcen}
|
||
\begin{enumerate}
|
||
\item Kursmaterialien auf Ilias \url{https://ovidius.uni-tuebingen.de/ilias3/goto.php?target=crs_869632&client_id=pr02}
|
||
\item Wintersemester 2014--2015 $\rightarrow$ 7
|
||
Mathematisch--Naturwissenschaftliche Fakult<6C>t $\rightarrow$ Biologie
|
||
$\rightarrow$ Biologie -- Master $\rightarrow$ Neurobiologie
|
||
$\rightarrow$ W1 Einf<6E>hrung is wissenschaftlich
|
||
Datenverarbeitung\pause
|
||
\item Einloggen mit Uni-Kennung und Passwort
|
||
\item Zugriff auf den Kurs mit dem geheimen Passwort ``Spikes'' \pause
|
||
\item Ladet eure L<>sungen in den entsprechenden Ordner hoch.
|
||
\end{enumerate}
|
||
\end{frame}
|
||
|
||
|
||
\begin{frame}
|
||
\frametitle{Grundlagen der Programmierung}
|
||
\framesubtitle{Themen Woche 1}
|
||
\begin{enumerate}
|
||
\item MATLAB Entwicklungsumgebung
|
||
\item Variablen und Datentypen
|
||
\item Vektoren und Matrizen
|
||
\item Boolesche Operationen
|
||
\item Kontrollstrukturen
|
||
\item Was ist ein Programm, Stil und Kommentare
|
||
\item Vom Problem zum Algorithmus
|
||
\item Skripte und Funktionen
|
||
\item Graphische Darstellung von Neuro Daten, PSTH, Rasterplot, STA
|
||
\item Fortgeschrittene Datenstrukturen
|
||
\item String Parsing
|
||
\item Lesen und schreiben von Dateien, Navigation im Dateisystem
|
||
\end{enumerate}
|
||
\end{frame}
|
||
|
||
|
||
\begin{frame}
|
||
\frametitle{Grundlagen der Programmierung}
|
||
\frametitle{Themen Woche 1}
|
||
\begin{figure}
|
||
\centering
|
||
\includegraphics[width=0.8\columnwidth]{./images/wueste}
|
||
\end{figure}
|
||
\end{frame}
|
||
|
||
\begin{frame}
|
||
\frametitle{Grundlagen der Programmierung}
|
||
\frametitle{Themen Woche 1}
|
||
\begin{figure}
|
||
\centering
|
||
\includegraphics[width=0.8\columnwidth]{./images/ski_wueste}
|
||
\end{figure}
|
||
\end{frame}
|
||
|
||
\begin{frame}
|
||
\frametitle{Grundlagen der Programmierung}
|
||
\frametitle{Tagesmen\"u}
|
||
\begin{enumerate}
|
||
\item [] Die MATLAB Entwicklungsumgebung \& Das Hilfesystem
|
||
\item Variablen und Datentypen
|
||
\item Skalare, Vektore und Matrizen
|
||
\item Boolesche Operatoren
|
||
\item Kontrollstrukturen
|
||
\end{enumerate}
|
||
\end{frame}
|
||
|
||
\begin{frame}[plain]
|
||
\huge{MATLAB IDE \& das Hilfesystem}
|
||
\end{frame}
|
||
|
||
\begin{frame}[plain]
|
||
\huge{1. Variablen}
|
||
\end{frame}
|
||
|
||
\begin{frame}
|
||
\frametitle{Grundlagen der Programmierung}
|
||
\framesubtitle{Variablen}
|
||
\begin{figure}
|
||
\centering
|
||
\includegraphics[width=0.2\columnwidth]{./images/bucket.png}
|
||
\end{figure}
|
||
\end{frame}
|
||
|
||
\begin{frame}
|
||
\frametitle{Grundlagen der Programmierung}
|
||
\framesubtitle{Variablen}
|
||
\huge"Eine Variable ist ein Platz im Speicher."
|
||
\begin{figure}
|
||
\centering
|
||
\includegraphics[width=0.8\columnwidth]{./images/variable.pdf}
|
||
\end{figure}
|
||
\end{frame}
|
||
|
||
\begin{frame}
|
||
\frametitle{Variablen}
|
||
\framesubtitle{Datentypen}
|
||
\begin{itemize}
|
||
\item \textit{integer} - Ganze Zahlen. Hier gibt es mehrere
|
||
Unterarten, die wir in Matlab weitgehend ignorieren koennen.
|
||
\item \textit{double} - Flie{\ss}kommazahlen.
|
||
\item \textit{complex} - Komplexe Zahlen.
|
||
\item \textit{logical} - Boolesche Werte, die als wahr
|
||
(\textit{true}) oder falsch (\textit{false}) interpretiert werden.
|
||
\item \textit{char} - ASCII Zeichen
|
||
\end{itemize}
|
||
\end{frame}
|
||
|
||
|
||
\begin{frame}
|
||
\frametitle{Variablen}
|
||
\framesubtitle{Datentypen}
|
||
\only<1>{
|
||
\begin{figure}
|
||
\centering
|
||
\includegraphics[width=0.8\columnwidth]{./images/variable.pdf}
|
||
\end{figure}
|
||
}
|
||
\only<2>{
|
||
\begin{figure}
|
||
\centering
|
||
\includegraphics[width=0.8\columnwidth]{./images/variableB.pdf}
|
||
\end{figure}
|
||
}
|
||
\end{frame}
|
||
|
||
\begin{frame}[fragile]
|
||
\frametitle{Variablen}
|
||
\framesubtitle{Erzeugen von Variablen und Wertezuweisung}
|
||
\scriptsize
|
||
\begin{lstlisting}[label=varListing1]
|
||
>> y = []
|
||
y =
|
||
[]
|
||
>>
|
||
>> x = 38
|
||
x =
|
||
38
|
||
>>
|
||
\end{lstlisting}
|
||
\normalsize
|
||
\end{frame}
|
||
|
||
%\subsection{Calculations with variables}
|
||
\begin{frame}[fragile]
|
||
\frametitle{Variablen}
|
||
\framesubtitle{Rechnen mit Variablen}
|
||
\tiny
|
||
\begin{lstlisting}[label=varListing2]
|
||
>> x = 1;
|
||
>> x + 10
|
||
ans =
|
||
11
|
||
>>
|
||
>> x % x wurde nicht veraendert
|
||
ans =
|
||
1
|
||
>>
|
||
>> y = 2;
|
||
>>
|
||
>> x + y
|
||
ans =
|
||
3
|
||
>>
|
||
>> z = x + y
|
||
z =
|
||
3
|
||
>>
|
||
>> z = z * 5;
|
||
>> z
|
||
z =
|
||
15
|
||
\end{lstlisting}
|
||
\end{frame}
|
||
|
||
%\subsection{\"Ubungen}
|
||
\begin{frame}[fragile]
|
||
\frametitle{Variablen}
|
||
\framesubtitle{\"Ubungen}
|
||
\vspace{-0.25cm}
|
||
\begin{enumerate}
|
||
\item Erzeuge zwei Variablen \verb+a, b+ und weise ihnen
|
||
unterschiedliche Werte zu. Schlie{\ss}e die Zeilen mit einem
|
||
Semikolon ab.
|
||
\item Lasse die Werte der Variablen ausgeben.
|
||
\item F\"uhre einfache mathematische Operationen aus (Addition,
|
||
Subtraktion, etc.) Potenzierung erfolgt \"uber das Dach Symbol
|
||
\verb+^+). Stelle fest, ob sich der der urspruengliche Wert der
|
||
Variable ge\"andert hat.
|
||
\item Benuzte die Kommandozeile um herauszufinden, welche Variablen
|
||
es im Workspace gibt.
|
||
\item Finde in der Hilfe mehr Information \"uber das \verb+clear+ Kommando.
|
||
\item L\"osche eine Variable.
|
||
\item L\"osche alle \"ubrigen Variablen.
|
||
\item Berechne die Fakult\"at von 5 indem eine Variable \verb+x+
|
||
erzeugt wird und ihr der Wert 1 zugewiesen wird. In einzelenen
|
||
Schritten wird x jeweils das Ergebnis des vorherigen Schrittes
|
||
zugewiesen.
|
||
\end{enumerate}
|
||
\end{frame}
|
||
|
||
\begin{frame}[plain]
|
||
\huge{2. Vektoren und Matrizen}
|
||
\end{frame}
|
||
|
||
\begin{frame}
|
||
\frametitle{Vektoren und Matrizen}
|
||
\framesubtitle{Skalare vs. Vektoren}
|
||
\begin{figure}
|
||
\centering
|
||
\includegraphics[width=0.8\columnwidth]{./images/scalarArray.pdf}
|
||
\end{figure}
|
||
\end{frame}
|
||
|
||
|
||
\begin{frame}[fragile]
|
||
\frametitle{Vektoren und Matrizen}
|
||
\framesubtitle{Erzeugen von Vektoren}
|
||
\tiny
|
||
\begin{lstlisting}[label=arrayListing1]
|
||
>> 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}
|
||
\end{frame}
|
||
|
||
\begin{frame}[fragile]
|
||
\frametitle{Vektoren und Matrizen}
|
||
\framesubtitle{Spalten \& Zeilenvektoren}
|
||
\tiny
|
||
\begin{lstlisting}[label=arrayListing2]
|
||
>> a = [1 2 3 4 5 6 7 8 9 10] % Erstellen eines Zeilenvektors
|
||
a =
|
||
1 2 3 4 5 6 7 8 9 10
|
||
>>
|
||
>> b = [1; 2; 3; 4; 5] % Erstellen eines Spaltenvectors
|
||
b =
|
||
1
|
||
2
|
||
3
|
||
4
|
||
5
|
||
>>
|
||
>> b = b' % Transponieren
|
||
b =
|
||
1 2 3 4 5
|
||
>>
|
||
\end{lstlisting}
|
||
\end{frame}
|
||
|
||
\begin{frame}
|
||
\frametitle{Vektoren}
|
||
\framesubtitle{Zugriff auf Inhalte von Vektoren}
|
||
\begin{figure}
|
||
\centering
|
||
\includegraphics[width=0.8\columnwidth]{./images/arrayIndexing.pdf}
|
||
\end{figure}
|
||
\pause
|
||
Der Zugriff auf die Inhalte eines Vektors erfolgt \"uber den Index.\\
|
||
\textbf{Achtung!} Der erste Index ist die 1.
|
||
\end{frame}
|
||
|
||
\begin{frame}[fragile]
|
||
\frametitle{Vektoren}
|
||
\framesubtitle{Zugriff auf Inhalte von Vektoren}
|
||
\vspace{-0.5cm}
|
||
\tiny
|
||
\begin{lstlisting}
|
||
>> 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}
|
||
\end{frame}
|
||
|
||
|
||
\begin{frame}[fragile]
|
||
\frametitle{Vektoren}
|
||
\framesubtitle{Zugriff auf Inhalte von Vektoren}
|
||
\vspace{-0.5cm}
|
||
\tiny
|
||
\begin{lstlisting}
|
||
>> a([1 3 5]) % das 1., 3. und 5. Element
|
||
ans =
|
||
11 13 15
|
||
>>
|
||
>> a(2:4) % alle element von Index 2 bis 4
|
||
ans =
|
||
12 13 14
|
||
>>
|
||
>> a(1:2:end) %retrieve every second element
|
||
>> and =
|
||
>> 11 13 15 17 19
|
||
>>
|
||
\end{lstlisting}
|
||
\end{frame}
|
||
|
||
|
||
\begin{frame}[fragile]
|
||
\frametitle{Vektoren}
|
||
\framesubtitle{Grundlegende Operationen}
|
||
\vspace{-0.25cm}
|
||
\tiny
|
||
\begin{lstlisting}[label=arrayListing4]
|
||
>> a = (0:2:8);
|
||
>> a + 5 % addiere einen Skalar
|
||
ans =
|
||
5 7 9 11 13
|
||
>>
|
||
>> 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 gro{\ss} sein!
|
||
??? Error using ==> plus
|
||
Matrix dimensions must agree.
|
||
\end{lstlisting}
|
||
\end{frame}
|
||
|
||
|
||
\begin{frame}[fragile]
|
||
\frametitle{Vektoren}
|
||
\framesubtitle{Grundlegende Operationen}
|
||
\vspace{-0.25cm}
|
||
\tiny
|
||
Wie bekomme ich Informationen \"uber einen Vektor?
|
||
\begin{lstlisting}
|
||
>> a = (0:2:8);
|
||
>> % die Laenge eines
|
||
>> length(a)
|
||
ans =
|
||
5
|
||
>>
|
||
>> size(a)
|
||
ans =
|
||
1 5
|
||
>>
|
||
\end{lstlisting}
|
||
\end{frame}
|
||
|
||
\begin{frame}[fragile]
|
||
\frametitle{Vektoren}
|
||
\framesubtitle{Grundlegende Operationen}
|
||
\vspace{-0.25cm}
|
||
L\"oschen von Elementen:
|
||
\tiny
|
||
\begin{lstlisting}
|
||
>> a = (0:2:8);
|
||
>> length(a)
|
||
ans =
|
||
5
|
||
>>
|
||
>> a(1) = [] % loesche das erste Element
|
||
a =
|
||
2 4 6 8
|
||
>> a([1 3]) = []
|
||
a =
|
||
4 8
|
||
>> length(a)
|
||
ans =
|
||
2
|
||
\end{lstlisting}
|
||
\end{frame}
|
||
|
||
\begin{frame}[fragile]
|
||
\frametitle{Vektoren}
|
||
\framesubtitle{Grundlegende Operationen}
|
||
\vspace{-0.25cm}
|
||
\tiny
|
||
Verkettung von Vektoren:
|
||
\begin{lstlisting}
|
||
>> 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
|
||
\end{lstlisting}
|
||
\end{frame}
|
||
|
||
|
||
\begin{frame}[fragile]
|
||
\frametitle{Vektoren}
|
||
\framesubtitle{\"Ubungen}
|
||
\begin{enumerate}
|
||
\item Erzeuge Vektoren:
|
||
\begin{enumerate}
|
||
\item Von 1 bis 10 in ganzzahligen Schritten.
|
||
\item $2:20$ in 2er Schritten.
|
||
\item mit absteigendem Inhalt von 100 bis 0.
|
||
\item In 100 Schritten von 0 bis $2\pi$ ($\pi$ ist als Konstante 'pi'
|
||
in Matlab definiert).
|
||
\end{enumerate}
|
||
\item Erzeuge eine Variable und speichere etwas Text in ihr sodass
|
||
mindestens 2 Worte vorhanden
|
||
sind. \\ (\verb+x = 'some text'+). Benutze die Indizierung um die
|
||
Woerter einzeln auszugeben.
|
||
\item Definiere zwei Vektoren: \verb+x = [3 2 6 8];+ and \verb+y = [4; 1; 3; 5];+
|
||
\begin{enumerate}
|
||
\item ... addiere 5 zu jedem Element von \verb+x+.
|
||
\item ... addiere 3 zu jedem Element von y, dass einen nicht gerade Index hat.
|
||
\item ... multipliziere jedes Element von \verb+x+ mit dem
|
||
entsprechenden Element in \verb+y+ und weise das Ergebnis der
|
||
Variable \verb+z+ zu.
|
||
\end{enumerate}
|
||
\end{enumerate}
|
||
\end{frame}
|
||
|
||
\begin{frame}{Matrizen}
|
||
\vspace{-0.5cm}
|
||
\begin{figure}
|
||
\centering
|
||
\includegraphics[width=0.65\columnwidth]{./images/matrices}
|
||
\end{figure}
|
||
\end{frame}
|
||
|
||
|
||
|
||
\begin{frame}[fragile]
|
||
\frametitle{Matrizen}
|
||
\framesubtitle{Erzeugen von Matrizen}
|
||
\tiny
|
||
\begin{lstlisting}
|
||
>> 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}
|
||
\end{frame}
|
||
|
||
|
||
\begin{frame}
|
||
\frametitle{Matrizen}
|
||
\framesubtitle{Indexierung und Zugriff auf Inhalte}
|
||
\vspace{-0.5cm}
|
||
\begin{figure}
|
||
\centering
|
||
\includegraphics[width=0.9\columnwidth]{./images/matrixIndexing}
|
||
\end{figure}
|
||
\end{frame}
|
||
|
||
\begin{frame}[fragile]
|
||
\frametitle{Matrizen}
|
||
\framesubtitle{Indexierung}
|
||
\tiny
|
||
\begin{lstlisting}
|
||
>> x = roundi(100, [3, 4, 5]); % 3-D Matrix mit Zufallszahlen
|
||
>>
|
||
>> 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
|
||
>>
|
||
\end{lstlisting}
|
||
\end{frame}
|
||
|
||
|
||
\begin{frame}[fragile]
|
||
\frametitle{Matrizen}
|
||
\framesubtitle{Grundlegende Operationen}
|
||
\vspace{-0.5 cm}
|
||
\tiny
|
||
\begin{lstlisting}
|
||
>> 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}
|
||
\end{frame}
|
||
|
||
|
||
\begin{frame}[plain]
|
||
\huge{Interludium: Matrixmultiplikation}
|
||
\end{frame}
|
||
|
||
|
||
\begin{frame}[fragile]
|
||
\frametitle{Matrizen}
|
||
\framesubtitle{\"Ubungen}
|
||
\begin{enumerate}
|
||
\item Erstelle eine 5 x 5 Matrix die Zufallszahlen enth\"alt (nutze die
|
||
MATLAB Funktion \verb+randn()+, benutze die Hilfe. Was macht sie?).
|
||
\begin{enumerate}
|
||
\item Gib alle Elemente der ersten Zeile aus.
|
||
\item Gib alle Elemente der zweiten Spalte aus.
|
||
\item Greife mit einem einzigen Kommando auf die Elemnte jeder
|
||
2. Spalte zu und speichere die Daten in einer neuen Variable.
|
||
\end{enumerate}
|
||
\item Erstelle eine 3-D Matrix aus drei 2-D Matrizen. Benutze die
|
||
\verb+cat()+ Funktion f\"ur diesen Zweck ( schaue in der Hilfe
|
||
nach, wie sie benutzt wird).
|
||
\begin{enumerate}
|
||
\item Gib alle Elemente des ersten ``Blattes'' aus (Index 1 in der 3. Dimension).
|
||
\end{enumerate}
|
||
\item Erstelle eine 3-D Matrix mithilfe der Funktion
|
||
\verb+ones()+. Multipliziere das erste Blatt mit 1, das zweite mit
|
||
2, dritte mit 3 etc.
|
||
\end{enumerate}
|
||
\end{frame}
|
||
|
||
|
||
\begin{frame}[fragile]
|
||
\frametitle{Matrizen}
|
||
\framesubtitle{\"Ubungen}
|
||
\begin{enumerate}\setcounter{enumi}{3}
|
||
\item Erstelle folgende Variablen \verb+x = [1 5 9]+ and
|
||
\verb+y = [7 1 5]+ und \verb+M = [3 1 6; 5 2 7]+. Welche der
|
||
folgenden Operationen funktionieren? Wenn nicht, warum
|
||
funktioneieren sie nicht? Teste Deine Vorhersagen.
|
||
\begin{enumerate}
|
||
\item \begin{verbatim} x + y \end{verbatim}
|
||
\item \begin{verbatim} x * M \end{verbatim}
|
||
\item \begin{verbatim} x + y' \end{verbatim}
|
||
\item \begin{verbatim} M - [x y] \end{verbatim}
|
||
\item \begin{verbatim} [x; y] \end{verbatim}
|
||
\item \begin{verbatim} M - [x; y] \end{verbatim}
|
||
\end{enumerate}
|
||
\item Erzeuge eine 5 x 5 x 5 Matrix die mit ganzzahligen
|
||
Zufallszahlen zwischen 0 und 100 gefuellt ist.
|
||
\begin{enumerate}
|
||
\item Berechne den Mittelwert aller Bl\"atter dieser Matrix (benutze \verb+mean()+, siehe Hilfe).
|
||
\end{enumerate}
|
||
\end{enumerate}
|
||
\end{frame}
|
||
|
||
\begin{frame}
|
||
\frametitle{Matrizen}
|
||
\framesubtitle{Nachtrag: Lineare Indexierung}
|
||
Alternativ zum ``subscript indexing'' koennen die Elemente von Matrizen auch linear addressiert werden.
|
||
\begin{figure}
|
||
\centering
|
||
\includegraphics[width=0.75\columnwidth]{./images/matrixLinearIndexing}
|
||
\end{figure}
|
||
\end{frame}
|
||
|
||
|
||
\begin{frame}[plain]
|
||
\huge{3. Boolesche Operationen}
|
||
\end{frame}
|
||
|
||
\begin{frame}
|
||
\frametitle{Boolesche Operationen} \framesubtitle{Was ist das?}
|
||
Boolesche Operationen sind Operationen, die sich zu Wahr oder Falsch
|
||
auswerten lassen. Auf Mengen angewendet (Zeichnungen geklaut bei
|
||
Cornelia M\"uhlich, Uni-Jena):
|
||
\only<1> {
|
||
\begin{figure}
|
||
\centering
|
||
\includegraphics[width=0.75\columnwidth]{./images/grundmenge}
|
||
\end{figure}
|
||
}
|
||
\only<2> {
|
||
\begin{figure}
|
||
\centering
|
||
\includegraphics[height=0.65\textheight]{./images/beete}
|
||
\end{figure}
|
||
}
|
||
\only<3> {
|
||
\begin{figure}
|
||
\centering
|
||
\includegraphics[height=0.65\textheight]{./images/AvB}
|
||
\end{figure}
|
||
}
|
||
\only<4> {
|
||
\begin{figure}
|
||
\centering
|
||
\includegraphics[height=0.65\textheight]{./images/AundB}
|
||
\end{figure}
|
||
}
|
||
\only<5> {
|
||
\begin{figure}
|
||
\centering
|
||
\includegraphics[height=0.65\textheight]{./images/AnotB}
|
||
\end{figure}
|
||
}
|
||
\only<6> {
|
||
\begin{figure}
|
||
\centering
|
||
\includegraphics[height=0.65\textheight]{./images/AxorB}
|
||
\end{figure}
|
||
}
|
||
\end{frame}
|
||
|
||
\begin{frame}[fragile]
|
||
\frametitle{Boolesche Operationen}
|
||
\framesubtitle{Logische Operatoren}
|
||
\begin{table}[th]
|
||
\caption{\label{logicalOperatorsTab}
|
||
\textbf{Logical operators.}}
|
||
\begin{center}
|
||
\begin{tabular}{c|c}
|
||
\hline
|
||
\textbf{Operator} & \textbf{Beschreibung} \\ \hline
|
||
$\sim$ & logisches NOT\\
|
||
$\&$ & logisches UND\\
|
||
$|$ & logisches ODER\\
|
||
$\&\&$ & short-circuit logical AND\\
|
||
$\|$ & short-circuit logical OR\\
|
||
\hline
|
||
\end{tabular}
|
||
\end{center}
|
||
\vspace{1em}
|
||
Das auschliessende ODER (XOR) ist nur als Funktion \verb+xor(A, B)+ verf\"ugbar.
|
||
\end{table}
|
||
\end{frame}
|
||
|
||
|
||
\begin{frame}[fragile]
|
||
\frametitle{Boolesche Operationen}
|
||
\framesubtitle{Relationale Operatoren}
|
||
\begin{table}[th]
|
||
\caption{\label{relOperatorsTab}
|
||
\textbf{Relational Operators.}}
|
||
\begin{center}
|
||
\begin{tabular}{c|c}
|
||
\hline
|
||
\textbf{Operator} & \textbf{Beschreibung} \\ \hline
|
||
$<$ & kleiner als\\
|
||
$>$ & gr\"osser als \\
|
||
$==$ & gleich \\
|
||
$>=$ & gr\"osser oder gleich \\
|
||
$<=$ & kleiner oder gleich \\
|
||
$\sim=$ & ungleich\\
|
||
\hline
|
||
\end{tabular}
|
||
\end{center}
|
||
\end{table}
|
||
\end{frame}
|
||
|
||
|
||
\begin{frame}[fragile]
|
||
\frametitle{Boolean operations}
|
||
\framesubtitle{Beispiele}
|
||
\tiny
|
||
\begin{lstlisting}
|
||
>> 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 =
|
||
1 0 1 1 0
|
||
\end{lstlisting}
|
||
\end{frame}
|
||
|
||
|
||
\begin{frame}[fragile]
|
||
\frametitle{Boolesche Operationen}
|
||
\framesubtitle{\"Ubungen}
|
||
\vspace{-0.5cm}
|
||
\begin{enumerate}
|
||
\item Gegeben sind zwei Vektoren \verb+x = [1 5 2 8 9 0 1]+ und
|
||
\verb+y = [5 2 2 6 0 0 2]+. F\"uhre aus und erkl\"are.
|
||
\begin{enumerate}
|
||
\item \verb+x > y+
|
||
\item \verb+y < x+
|
||
\item \verb+x == y+
|
||
\item \verb+x ~= y+
|
||
\item \verb+x & ~y+
|
||
\item \verb+x | y+
|
||
\end{enumerate}
|
||
\end{enumerate}
|
||
\end{frame}
|
||
|
||
|
||
\begin{frame}[fragile]
|
||
\frametitle{Logische Indexierung}
|
||
\framesubtitle{\"Ubungen}
|
||
Boolesche Operationen koennen eingesetzt werden um aus Vektoren und
|
||
Matrizen Elemente auszuwaehlen, die einer bestimmten Bedingung
|
||
entsprechen.
|
||
\begin{enumerate}
|
||
\item Gegeben sind \verb+x = (1:10)+ und
|
||
\verb+y = [3 1 5 6 8 2 9 4 7 0]+. Try to understand the following
|
||
commands.
|
||
\begin{enumerate}
|
||
\item \verb+x( (y <= 2) )+
|
||
\item \verb+x( (x > 2) | (y < 8) )+
|
||
\item \verb+x( (x == 0) & (y == 0) )+
|
||
\end{enumerate}
|
||
\item Erzeuge eine 100x100 2-D Matrix mit Zufallswerten zwischen 0 und 100 (\verb+randi+). Ersetze \verb+x < 33+ mit 0, \verb+x >= 33 und x < 66+ mit 1 und alle \verb+x >= 66+ auf 2.
|
||
\item Ermittle die Anzahl Elemente fuer jede Klasse mithilfe eines Booleschen Ausdrucks.
|
||
\end{enumerate}
|
||
\end{frame}
|
||
|
||
\begin{frame}[plain]
|
||
\huge{4. Kontrollstrukturen}
|
||
\end{frame}
|
||
|
||
\begin{frame}[fragile]
|
||
\frametitle{Kontrollstrukturen}
|
||
\framesubtitle{Schleifen}
|
||
Schleifen werden gebrauch um wiederholte Ausfuehrung desselben Codes zu vereinfachen.
|
||
\tiny
|
||
\begin{lstlisting}
|
||
>> x = 1; % Startwert fuer x
|
||
... % etwas sinnvolles mit x
|
||
>> x = x + 1;
|
||
...
|
||
>> x = x + 1;
|
||
...
|
||
>> x = x + 1;
|
||
...
|
||
>> x = x + 1;
|
||
...
|
||
>> x = x + 1;
|
||
>>
|
||
>> x
|
||
x =
|
||
6
|
||
\end{lstlisting}
|
||
\end{frame}
|
||
|
||
|
||
\begin{frame}[fragile]
|
||
\frametitle{Kontrollstrukturen}
|
||
\framesubtitle{for - Schleife}
|
||
\tiny
|
||
\begin{lstlisting}[label=loopListing2]
|
||
>> for x = 1:5
|
||
... % etwas sinnvolles mit x ...
|
||
end
|
||
>> disp(x);
|
||
5
|
||
>>
|
||
\end{lstlisting}
|
||
\end{frame}
|
||
|
||
\begin{frame}[fragile]
|
||
\frametitle{Kontrollstrukturen}
|
||
\framesubtitle{while - Schleife}
|
||
\tiny
|
||
\begin{lstlisting}
|
||
>> x = 1;
|
||
>> while x <= 5
|
||
... % etwas sinnvolles mit x ...
|
||
disp(x);
|
||
x = x + 1;
|
||
end
|
||
1
|
||
2
|
||
3
|
||
4
|
||
5
|
||
>> disp(x)
|
||
6
|
||
>>
|
||
>> while true %never ending loop!
|
||
disp(x);
|
||
x = x + 1;
|
||
end
|
||
1
|
||
2
|
||
...
|
||
\end{lstlisting}
|
||
\end{frame}
|
||
|
||
\begin{frame}[fragile]
|
||
\frametitle{Kontrollstrukturen}
|
||
\framesubtitle{if - Anweisung (bedingte Anweisung)}
|
||
|
||
Wird eingesetzt um bestimmte Code Abschnitte
|
||
nur unter bestimmten Umst\"anden auszuf\"uhren.
|
||
|
||
\tiny
|
||
\begin{lstlisting}[label=loopListing4]
|
||
>> x = rand(1); % eine einzelne Zufallszahl
|
||
>> if x < 0.5
|
||
disp('x is less than 0.5');
|
||
end
|
||
>>
|
||
>> if x < 0.5
|
||
disp('x is less than 0.5!');
|
||
else
|
||
disp('x is greater than or equal to 0.5!')
|
||
end
|
||
>>
|
||
>> if x < 0.5
|
||
disp('x is less than 0.5!');
|
||
elseif x < 0.75
|
||
disp('x is greater than 0.5 but less than 0.75!');
|
||
else
|
||
disp('x is greater than or equal to 0.75!')
|
||
end
|
||
>>
|
||
>> if x < 0.75
|
||
disp('x is less than 0.75!');
|
||
elseif x < 0.5
|
||
disp('x is less than 0.5!');
|
||
else
|
||
disp('x is greater than or equal to 0.75!')
|
||
end
|
||
\end{lstlisting}
|
||
\end{frame}
|
||
|
||
|
||
\begin{frame}[fragile]
|
||
\frametitle{Kontrollstrukturen}
|
||
\framesubtitle{break unnd continue}
|
||
\vspace{-0.5cm}
|
||
\tiny
|
||
\begin{lstlisting}
|
||
>> for x = 1:5 % using continue
|
||
if(x > 2 & x < 5)
|
||
continue;
|
||
end
|
||
disp(x);
|
||
end
|
||
1
|
||
2
|
||
5
|
||
>>
|
||
>> for x = 1:5000 % using break
|
||
if(x > 5)
|
||
break;
|
||
end
|
||
disp(x);
|
||
end
|
||
1
|
||
2
|
||
3
|
||
4
|
||
5
|
||
>>
|
||
\end{lstlisting}
|
||
\end{frame}
|
||
|
||
|
||
\begin{frame}[fragile]
|
||
\frametitle{Kontrollstrukturen}
|
||
\framesubtitle{\"Ubungen}
|
||
\begin{enumerate}
|
||
\item Erzeuge einen Vektor 'x' mit z.B. 50 Zufallszahlen im Bereich 0 - 10.
|
||
\begin{enumerate}
|
||
\item Benutze eine Schleife um das arithmetische Mittel zu berechnen. Der Mittelwert ist definiert als:
|
||
$\overline{x}=\frac{1}{n}\sum\limits_{i=0}^{n}x_i $.
|
||
\item Benutze eine Schleife um die Standardabweichung zu bestimmen:
|
||
$\sigma=\sqrt{\frac{1}{n}\sum\limits_{i=0}^{n}(x_i-\overline{x})^2}$).
|
||
\item Suche in der MATLAB Hilfe nach Funktionen, die das fuer dich tuen :-).
|
||
\end{enumerate}
|
||
\item Erzeuge eine 5 x 5 x 5 Matrix mit Zufallszahlen.
|
||
\begin{enumerate}
|
||
\item Benutze eine for Schleife um nacheinander die Elemente jedes ``Blattes'' einzeln auszugeben.
|
||
\item Das gleich mit einer while-Schleife.
|
||
\end{enumerate}
|
||
\end{enumerate}
|
||
\end{frame}
|
||
|
||
\begin{frame}[fragile]
|
||
\frametitle{Kontrollstrukturen}
|
||
\framesubtitle{\"Ubungen}
|
||
\vspace{-0.5cm}
|
||
\begin{enumerate}\setcounter{enumi}{2}
|
||
\item Erstelle 'x' einen Vektor mit 10 Zufallszahlen im Bereich 0:10.
|
||
\begin{enumerate}
|
||
\item Benutze eine for-Schleife um all die Elemente zu loeschen,
|
||
die (\verb+x(index) = [];+) kleiner als 5 sind.
|
||
\item L\"osche alle Elemente die kleiner als 5 und groesser als 2 sind.
|
||
\item Kann man das gleiche auch ohne eine Schleife erledigen?
|
||
\end{enumerate}
|
||
\item Teste den Zufallsgenerator! Dazu z\"ahle die Anzahl der
|
||
Elemente, die durch folgende Grenzen getrennt werden [0.2 0.4 0.6
|
||
0.8 1.0]. Speichere die Ergebnisse in einem passenden
|
||
Vektor. Nutze eine Schleife um 1000 Zufallszahlen mit
|
||
\verb+rand()+ (siehe Hilfe) zu ziehen. Was w\"are die Erwartung,
|
||
was kommt heraus?
|
||
\end{enumerate}
|
||
\end{frame}
|
||
|
||
|
||
\end{document}
|