\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{03.10.2014 - 07.11.2014}
 %\logo{\pgfuseimage{../../resources/UT_BM_Rot_RGB.pdf}}

\subject{Einf\"uhrung in wissenschaftliche Datenverarbeitung}
\vspace{1em}
\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}[plain]
  \frametitle{Rekapitulation}
  \begin{enumerate}
  \item Variablen\pause
  \item Vektoren\pause
  \item Matrizen\pause
  \item Boolesche Operationen\pause
  \item Logische Indizierung\pause
  \item Kontrollstrukturen
  \end{enumerate}
\end{frame}


\begin{frame}
  \frametitle{Grundlagen der Programmierung}
  \frametitle{Tagesmen\"u}
  \begin{enumerate}
  \item Was ist ein Program?
  \item Skripte und Funktionen
  \item G\"ultigkeitsbereiche
  \item Vom Problem zum Algorithmus
  \item \"Ubungen, \"Ubungen, \"Ubungen. 
  \end{enumerate}
\end{frame}


\begin{frame}[plain]
  \huge{1. Was ist ein Programm?}
\end{frame}

\begin{frame}
  \frametitle{Was ist ein Programm?}
  \framesubtitle{Und wo lebt es?}
  Ein Programm ist ...
  \begin{itemize}
  \item ... eine Sammlung von Anweisungen.
  \end{itemize}\pause
  Es lebt in ...
  \begin{itemize}
  \item ... einer Datei auf dem Rechner.
  \end{itemize}\pause
  Wenn es zum Leben erweckt wird...
  \begin{itemize}
  \item ... wird es Zeile fuer Zeile von oben nach unten ausgef\"uhrt.
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Was ist ein Programm?}
  \framesubtitle{In Matlab}
  \begin{itemize}
  \item Matlab kennt verschieden Arten von Programmen:
    \begin{enumerate}
    \item Skripte
    \item Funktionen
    \item Objekte (werden wir ignorieren)
    \end{enumerate}\pause
  \item Alle werden in sogenannte m-files gespeichert (z.B. \textit{meinProgramm.m}).
  \item K\"onnen dann von der Kommandozeile aufgerufen werden.
  \item Programme erh\"ohen die Wiederverwertbarkeit von Programmcode.\pause
  \item Programme k\"onnen andere Programme aufrufen.
  \end{itemize}
\end{frame}


\begin{frame}[plain]
  \huge{2. Skripte und Funktionen}
\end{frame}


\begin{frame}[fragile]
  \frametitle{Skripte und Funktionen}
  \framesubtitle{Skripte}
  Beispiel: Plot von Sinusschwingungen
  \footnotesize
  \begin{lstlisting}
>> x = (0:0.01:2*pi);
>> frequenz_1 = 1;
>> frequenz_2 = 2;
>> y = sin(frequenz_1 * x);
>> y2 = sin(frequenz_2 * x);
>> plot(x, y);
>> hold on;
>> plot(x, y2);
\end{lstlisting}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Skripte und Funktionen}
  \framesubtitle{\"Ubungen}
  \begin{enumerate}
  \item \"Offnet den Editor und schreibt ein Skript, das vier Sinus
    mit den Amplituden \verb+amplitude = [0.25, 0.5, 1.0, 2.0]+ in
    einen Graphen plottet. Benutzt eine \verb+for+ Schleife um die Amplituden abzuarbeiten (\verb+hold on+ um linien \"ubereinander zu plotten).
  \item Speichert das Skript und f\"uhrt es von der Kommandozeile aus.
  \item Erzeuge ein zweites Skript, das nun die Frequenz setzt und das
    erste aufruft. Benutzt eine \verb+for+ Schleife um folgende
    Frequenzen abzuarbeiten \verb+frequenzen = [1.0, 2.0, 3.0] %Hz+.
  \item Speichert und ruft dieses Skript \"uber die Kommandozeile auf.
  \item Was ist geplottet, passt es zu den Erwartungen? 
  \end{enumerate}
\end{frame}

\begin{frame}
  \frametitle{Skripte und Funktionen}
  \framesubtitle{Funktionen}
  Vorherige \"Ubung hat gezeigt, dass die Verwendung von globalen Variablen gef\"ahrlich ist.
  Wie l\"ost man dieses Problem?\\
  \vspace{3em}
  \huge{Funktionen!}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Funktionen} \framesubtitle{Funktionen}
  Funktionen haben ihren eingenen G\"ultigkeitsbereich. Variablen im
  \textit{Workspace} sind ohne Konsequenzen f\"ur die Funktion.
    \footnotesize
  \begin{lstlisting}
function plot_sinus_mit_amplituden() % Funktionskopf
   x = (0:0.01:2*pi); % hier faengt der Funktionskoerper an
   frequenz = 1.0;
   amplituden = [0.25 0.5 0.75 1.0 1.25];

   for i = 1:length(amplituden)
       y = sin(frequenz * x) * amplituden(i);
       plot(x, y)
       hold on;
   end 
\end{lstlisting}\pause
Ist das eine gute Funktion?
\end{frame}


\begin{frame}[fragile]
  \frametitle{Funktionen}
  \framesubtitle{Argumente und R\"uckgabewerte}
  Grundlegende Idee ist $y = f(x)$.\\
  \"Ahnlich dazu kann man den Funktionskopf mit Argumenten und R\"uckgabewerten definieren
  \footnotesize
  \begin{lstlisting}
function y = plot_sinus(frequenz, amplitude)
%          ^                         ^            ^
%  Rueckgabewert         Argument_1       Argument_2
\end{lstlisting}
\end{frame}


\begin{frame}[fragile]
  \frametitle{Funktionen}
  \framesubtitle{Argumente und R\"uckgabewerte}
  Eine Funktion kann auch mehrere R\"uckgabewerte haben.
  \begin{lstlisting}
function [y, z] = do_something(a, b)
   y = a + b
   z  = a * b
\end{lstlisting}
\pause
\begin{itemize}
\item Alle R\"uckgabewerte m\"ussen in der Funktion definiert sein!\pause
\item Man kann auch mit variablen Anzahlen der Argumente und R\"uckgabewerte programmieren.\pause
\item Ist aber deutlich komplexer und fehleranf\"alliger.
\end{itemize} 
\end{frame}


\begin{frame}[fragile]
  \frametitle{Skripte und Funktionen}
  \framesubtitle{Programmierstil}
  Programmierstil ist:
  \begin{enumerate}
    \item Die Namensgebung fuer Variablen und Konstanten.
    \item Die Namensgebung von Skripten und Funktionen.  
    \item Die Verwendung von Einr\"uckungen und Leerzeilen um Bl\"ocke im Code hervorzuheben.
    \item Verwendung von Kommentaren und Hilfetexten.
  \end{enumerate}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Funktionen}
  \framesubtitle{Zusammenfassung}
  Funktionen sind kleine Code Fragmente, die
  \begin{enumerate}
    \item ... genau eine Aufgabe erledigen.
    \item ... Argumente entgegennehmen k\"onnen.
    \item ... R\"uckgabewerte haben k\"onnen.
    \item ... ihren eigenen G\"ueltigkeitsbereich haben.
    \item ... Skripten fast immer vorzuziehen sind.
  \end{enumerate}
\end{frame}

\begin{frame}[plain]
\huge{3. Programmierstil}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Programmierstil}
  \framesubtitle{Was soll das?}
  \begin{enumerate}
    \item Die Namensgebung fuer Variablen und Konstanten.
    \item Die Namensgebung von Skripten und Funktionen.  
    \item Die Verwendung von Einr\"uckungen und Leerzeilen um Bl\"ocke im Code hervorzuheben.
    \item Verwendung von Kommentaren und Hilfetexten.
  \end{enumerate}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Skripte und Funktionen}
  \framesubtitle{Programmierstil}
  In verschiednen Sprachen verschiedene Konventionen. In MATLAB ...
  \begin{itemize}
  \item Funktionen, Skripte: Kleinbuchstaben, Abk\"urzungen. (z.B. \verb+xcorr+, \verb+repmat+)
  \item Konvertierungen immer mit format2format (z.B. \verb+num2str+)
  \item Variablen immer klein, h\"aufig Abk\"urzungen.
  \item Kommentare h\"aufig fuer interne Zwecke aber ausf\"uhrliche Dokumentation mit Hilftexten.
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Skripte und Funktionen} \framesubtitle{Programmierstil}
  Es gibt verschiedene ''Religionen''. Ein m\"ogliches Credo k\"onnte
  sein: \\
  \textbf{``Programmcode muss lesbar sein.''}\pause
  \begin{enumerate}
  \item Variablen werden klein geschrieben. Wenn n\"otig entweder im
    \textit{camelCase} oder mit Unterstrichen (z.B. \verb+spikeCount+
    oder \verb+spike_count+).
  \item Funktionen und Skripte mit ausdrucksstarken Namen (z.B. \verb+loadSpikeData+).
  \item Kommentare sparsam. Eventuell um Abschnitte zu trennen.
  \item Hilfetexte: Ein Problem; sie m\"ussen aktuell sein sonst sind
    sie sch\"adlicher als wenn sie gar nicht da w\"aren.
  \item Einr\"uckung ist Pflicht.
  \item Bl\"ocke im Code werden durch 1 Leerzeichen getrennt.
  \end{enumerate}
\end{frame}


\begin{frame}[fragile]
  \frametitle{Programmierstil}
  Ihr d\"urft all das missachten und einen eingenen Stil entwickeln. Aber:\\
  \vspace{2.5cm}
  \centering
  \huge{Bleibt konsitent!}\pause
  \vspace{2.5cm}
  \normalsize
  
  Es gibt dazu ganze B\"ucher. z.B. Robert C. Martin: \textit{Clean
    Code: A Handbook of Agile Software Craftmanship}, Prentice Hall
\end{frame}


\begin{frame}[plain]
  \huge{4. Vom Problem zum Algorithmus zum Programm}\\
  \begin{figure}
    \centering
    \includegraphics[height=0.6\textheight]{./images/turtur}
  \end{figure}
\end{frame}


\begin{frame}
  \frametitle{Vom Problem zum Algorithmus}
  \framesubtitle{Uff, schwierig...}
  \begin{enumerate}
  \item Am besten f\"angt man mit einem weissen Blatt an. :-) \pause
  \item Begr\"abt alle Angst vor Fehlern. \pause
  \item Macht sich klar, was das die Ausgangsituation ist.\pause
  \item Macht sich klar, was das Ziel ist.\pause
  \item Zerlegt das Problem in kleinere Teile und wendet Schritte 1 - 5 auf jedes Teilproblem an.
  \end{enumerate}  
\end{frame}


\begin{frame}[fragile]
  \frametitle{Vom Problem zum Algorithmus}
  \frametitle{\"Ubungen - Funktionen}
  \begin{enumerate}
  \item Schreibe eine Funktion \verb+plotSineWave+ die die Amplitude
    des Sinus als Argument entgegennimmt.
  \item Erweitere die Funktion in der Weise, dass sie zus\"atzlich die
    gew\"unschte Frequenz \"ubernimmt.
  \item Erweitere \verb+plotSineWave+ so, dass sie eine Schar von
    Sinuswellen unterschiedlicher Frequenz plottet.
  \item Erweitere \verb+plotSineWave+ so, dass auch die Amplitude als
    Vektor \"ubergeben werden kann. Die Funktion soll alle m\"oglichen
    Kombinationen darstellen.
  \item Erweitere \verb+plotSineWave+ so, dass die berechnete Sinus in
    einer 2-D Matrize zur\"uckgegeben werden.
  \item F\"uge zwei weitere R\"uckgabeparameter hinzu, die f\"ur jede
    Berechnung die Amplitude und Frequenz zur\"uckgeben.
  \end{enumerate}
\end{frame}


\begin{frame}
  \frametitle{Vom Problem zum Algorithmus}
  \framesubtitle{\"Ubungen - eine Herausforderung}
  Wie w\"are es mit folgendem Problem:\\ 
  Ich habe die Aufnahme des Membranpotentials einer Nervenzelle... 
  \begin{enumerate}
  \item ... und m\"ochte die Zeitpunkte der Aktionspotentiale ermitteln.
  \item ... und m\"ochte die Anzahl der Aktionspotentiale wissen.
  \end{enumerate}\pause
  Aufgaben:
  \begin{enumerate}
  \item Formuliert geeignete Zwischenziele.
  \item Entwickelt einen Ansatz um dieses Problem zu lösen.
  \end{enumerate}
\end{frame}


\end{document}
