650 lines
18 KiB
TeX
650 lines
18 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{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<72>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 <20>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}
|