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

\subject{Einf\"uhrung in die 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}
}

\newcommand{\code}[1]{\texttt{#1}}

\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 Programmierstil
  \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 f\"r 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}
    t = (0:0.01:10); %s
    frequenz_1 = 1;
    frequenz_2 = 2;
    y = sin(frequenz_1 * t * 2 * pi);
    y2 = sin(frequenz_2 * t * 2 * pi);
    plot(t, y);
    hold on;
    plot(t, 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 \code{amplitudes = [0.25, 0.5, 1.0, 2.0]} und
    der Frequenz 2\,Hz in einen Graphen plottet (\code{sinus = sin(x *
      frequency * 2 * pi)* amplitude;}). 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 das erste aufruft aber bei
    jedem Aufruf die Frequenz (Variable \code{frequency}) neu
    setzt. Benutzt eine \verb+for+ Schleife um folgende Frequenzen
    abzuarbeiten \code{frequencies = [2.0, 4.0, 6.0]}.
    \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{Skripte}
  Vorherige \"Ubung sollte gezeigt haben, dass ...
  \begin{enumerate}
  \item die Verwendung von globalen Variablen gef\"ahrlich sein kann.
  \item jede Variable, die in einem aufgerufenen Skript definiert wird
    im globalen Workspace sichtbar wird.
  \end{enumerate}
  \large{Wie l\"ost man dieses Problem?}\\
  \vspace{3em} \huge{Funktionen!}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Skripte und Funktionen}
  \framesubtitle{Funktionen}
  Definition:
  \begin{itemize}
  \item Eine Funktion in Matlab wird \"ahnlich zu einer mathematischen
    Funktion definiert:\\
    \begin{center}
    \Large$y = f(x)$\normalsize\pause
    \end{center}
  \end{itemize}
  \tiny
  \begin{lstlisting}
function y = function_name(arg_1, arg_2)
%           ^                         ^          ^
%  Rueckgabewert         Argument_1       Argument_2
end
\end{lstlisting}
\normalsize
  \begin{itemize}
  \item Ein Funktion beginnt mit dem Schl\"usselwort \textbf{function}
    gefolgt von den R\"uckgabewerten, dem Funktionsnamen und (in
    Klammern) den Argumenten.
  \item Auf den Funktionskopf folgt der auszuf\"uhrende Programmcode
    im Funktionsk\"orper.
  \item Die Funktionsdefinition wird mit \textbf{end} abgeschlossen. 
  \item Eine Funktion ist in einer eigenen Datei definiert.
  \end{itemize}
\end{frame}


\begin{frame}
  \frametitle{Skripte und Funktionen}
  \framesubtitle{Funktionen}
  Was erreicht man damit?
  \begin{itemize}
  \item Kapseln von Programmcode, der f\"ur sich eine Aufgabe l\"ost.
  \item Definierte Schnittstelle.
  \item Eigener G\"ultigkeitsbereich:
    \begin{itemize}
    \item Variablen im Workspace sind in der Funktion \textbf{nicht} sichtbar.
    \item Variablen, die in der Funktion definiert werden erscheinen
      \textbf{nicht} im Workspace.
    \end{itemize}
  \item Erhöht die Wiederverwendbarkeit von Programmcode.
  \item Erh\"oht die Lesbarkeit von Programmen, da sie
    \"ubersichtlicher werden.
  \end{itemize}
\end{frame}


\begin{frame}[fragile]
  \frametitle{Skripte und Funktionen}
  \framesubtitle{Funktionen}
  Eine Beispielfunktion, die eine Reihe Sinus plottet.
  \footnotesize
  \begin{lstlisting}
function meine_erste_funktion() % Funktionskopf
   t = (0:0.01:2); % 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 * t * 2 * pi) * amplituden(i);
       plot(t, y)
       hold on;
   end 
\end{lstlisting}
\begin{center}
  \large{\textbf{Ist das eine gute Funktion?}}
\end{center}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Skripte und Funktionen}
  \framesubtitle{Funktionen}
  \tiny
  \begin{lstlisting}
function meine_erste_funktion()
   t = (0:0.01:2);
   frequenz = 1.0;
   amplituden = [0.25 0.5 0.75 1.0 1.25];

   for i = 1:length(amplituden)
       y = sin(frequenz * t * 2 * pi) * amplituden(i);
       plot(t, y)
       hold on;
   end 
\end{lstlisting}
\normalsize
Probleme mit dieser Funktion:
  \begin{itemize}
  \item Der Name ist nicht aussagekr\"aftig.
  \item Die Funktion ist f\"ur genau einen Zweck gut.
  \item Was sie tut, ist festgelegt und kann von au{\ss}en nicht
    beeinflusst werden.
  \item Sie tut 3 Dinge: Sinus berechnen \textbf{und} Amplituden
    \"andern \textbf{und} graphisch darstellen.
  \item Es ist nicht (einfach) m\"oglich an die berechneten Daten zu
    kommen.
  \item Keinerlei Dokumentation. Ich muss den code lesen um zu
    rekonstruieren, was sie tut.
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Skripte und Funktionen} \framesubtitle{Funktionen }
  \huge{Wie kann die Funktion besser gemacht werden?}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Skripte und Funktionen}
  \framesubtitle{Funktionen}
  \begin{enumerate}
  \item Manchmal ist es besser noch mal neu anzufangen als
    Kleiningkeiten zu verbessern:
  \item Welches Problem soll gel\"ost werden?
  \item Aufteilen in Teilprobleme. 
  \item Gute Namen finden.
  \item Definieren der Schnittstellen --- Was muss die Funktion
    wissen? Was möchte ich von ihr haben?
  \item Daten zur\"uck geben (R\"uckgabewerte definieren). 
  \end{enumerate}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Skripte und Funktionen}
  \framesubtitle{Funktionen}
  \textbf{\large{Drei Teilprobleme:}}
  \begin{enumerate}
  \item Berechnen der \textbf{einzelnen} Sinus.
  \item Plotten der Daten.
  \item Koordinieren von Berechung und Darstellung mit
    unterschiedlichen Amplituden.
  \end{enumerate}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Skripte und Funktionen}
  \framesubtitle{Funktionen}
  \large{\textbf{1. Berechnen eines einzelnen Sinus:}}
  \tiny
  \begin{lstlisting}
function meine_erste_funktion()
   t = (0:0.01:2);
   frequenz = 1.0;
   amplituden = 1.0 1.25;
   y = sin(frequenz * t * 2 * pi) * amplitude;
end 
  \end{lstlisting}
  \normalsize
  \begin{enumerate}
  \item Namen ersetzten
  \item Schnittstelle definieren: Was will ich von der Funktion?
    Welche Information muss ich ihr geben?\pause
    \begin{itemize}
    \item Funktion muss wissen: Wie weit soll gerechnet werden? Welche
      Aufl\"osung auf der Zeitachse? Welche Frequenz? Welche Amplitude?
    \item F\"ur einen Plot brauche ich die x- und die y-Werte. Diese
      muss die Funktion zur\"uckgeben.
    \end{itemize}
  \end{enumerate}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Skripte und Funktionen}
  \framesubtitle{Funktionen}
  Namens\"anderung:
  \footnotesize
  \begin{lstlisting}
    function calculate_sinewave()
      t = (0:0.01:2);
      frequenz = 1.0;
      amplituden = [0.25 0.5 0.75 1.0 1.25];
      y = sin(frequenz * t * 2 *pi) * amplituden(i);
    end 
  \end{lstlisting}
  \normalsize
\end{frame}

\begin{frame}[fragile]
  \frametitle{Skripte und Funktionen}
  \framesubtitle{Funktionen}
  Argumente:
  \footnotesize
  \begin{lstlisting}
function calculate_sinewave(frequency, amplitude, t_max, t_step)
   x = (0:t_step:t_max);
   y = sin(frequency * t * 2 * pi) * amplitude;
end 
  \end{lstlisting}
  \normalsize
\end{frame}

\begin{frame}[fragile]
  \frametitle{Skripte und Funktionen}
  \framesubtitle{Funktionen}
  R\"uckgabewerte:
  \tiny
  \begin{lstlisting}
function [t, y] = calculate_sinewave(frequency, amplitude, t_max, t_step)
   x = (0:t_step:t_max);
   y = sin(frequency * t * 2 * pi) * amplitude;
end
  \end{lstlisting}
\end{frame}


\begin{frame}[fragile]
  \frametitle{Skripte und Funktionen}
  \framesubtitle{Funktionen}
  \large{\textbf{2. Plotten einer einzelnen Schwingung:}}
  \normalsize
  \begin{enumerate}
  \item Namen finden
  \item Schnittstelle definieren: Was will ich von der Funktion?
    Welche Information muss ich ihr geben?\pause
    \begin{itemize}
    \item Funktion muss wissen: Welche Daten soll sie plotten? Zeitachse,
      y-Werte, einen Namen f\"ur die Legende?
    \item Muss nichts zur\"uckgeben.
    \end{itemize}
  \end{enumerate}
  \footnotesize
  \begin{lstlisting}
    function plot_sinewave(x_data, y_data, name)
      plot(x_data, y_data, 'displayname', name) 
    end
  \end{lstlisting}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Skripte und Funktionen}
  \framesubtitle{Funktionen}
  \large{\textbf{3. Erstellen eines \textbf{Skriptes} zur Koordinierung:}}
  \normalsize
  \begin{enumerate}
  \item Namen finden
  \item Definieren eins Vektors, f\"ur die Amplituden.
  \item Definieren einer Variable f\"ur die Frequenz.
  \item Definieren der Variablen f\"ur das Maximum und die
    Schrittweite der x-Achse.
  \item \"Offnen einer neuen Abbildung (\code{figure()}).
  \item Setzen des \code{hold on}.
  \item \code{for}-Schleife, die über die Amplituden iteriert, die
    Sinus berechnen l\"asst und die Resultate an die Plot-Funktion
    weiterreicht.
  \end{enumerate}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Skripte und Funktionen}
  \framesubtitle{Funktionen}
  Skript: \verb+plot_sinewaves.m+
  \footnotesize
  \begin{lstlisting}
amplitudes = 0.25:0.25:1.25;
frequency = 2;
t_max = 10;
t_step = 0.01;
    
figure()
hold on
 
for a = amplitudes
  name = num2str(a);
  [x_data, y_data] = calculate_sinewave(frequency, a, t_max, t_step);
  plot_sinewave(x_data, y_data, name)
end
legend('show')
  \end{lstlisting}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Skripte und Funktionen}
  \framesubtitle{Funktionen}
  Aufaben:
  \begin{enumerate}
  \item Erweitert das Programm so, dass auch ein Satz von Frequenzen
    benutzt wird.
  \end{enumerate}
\end{frame}

\begin{frame}
  \frametitle{Skripte und Funktionen}
  \framesubtitle{Funktionen --- 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\"ultigkeitsbereich haben.
    \item ... Skripten fast immer vorzuziehen sind.
  \end{enumerate}
\end{frame}


\begin{frame}
  \frametitle{Skripte und Funktionen}
  \framesubtitle{Organisation von Programmen}

  \begin{itemize}
  \item Mit den Funktionen haben wir ein Werkzeug, dass uns erlaubt
    ein Programm in kleine, ``verdauliche'', Teile zu gliedern.
  \end{itemize}
  Ein m\"ogliches Programmlayout k\"onnte so aussehen:
  \begin{figure}
    \includegraphics[width=0.5\columnwidth]{./images/simple_program.pdf}
  \end{figure}
\end{frame}


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

\begin{frame}
  \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{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 verschiedenen 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 Leerzeile 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}

\end{document}

\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}
  \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}
