teaching/scientificComputing
Archived
3
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[exercises] store german versions

Browse Source
This commit is contained in:
Jan Grewe 2017-10-16 11:05:17 +02:00
parent abad56902b
commit cb70e2b6f1
5 changed files with 1121 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

108
programming/exercises/boolean_logical_indexing_de.tex Normal file
View File

@ -0,0 +1,108 @@
\documentclass[12pt,a4paper,pdftex]{exam}
\usepackage[german]{babel}
\usepackage{natbib}
\usepackage{graphicx}
\usepackage[small]{caption}
\usepackage{sidecap}
\usepackage{pslatex}
\usepackage{amsmath}
\usepackage{amssymb}
\setlength{\marginparwidth}{2cm}
\usepackage[breaklinks=true,bookmarks=true,bookmarksopen=true,pdfpagemode=UseNone,pdfstartview=FitH,colorlinks=true,citecolor=blue]{hyperref}
%%%%% text size %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\usepackage[left=20mm,right=20mm,top=25mm,bottom=25mm]{geometry}
\pagestyle{headandfoot} \header{{\bfseries\large \"Ubung
3}}{{\bfseries\large Boolesche Ausdr\"ucke, logisches
Indizieren}}{{\bfseries\large 31. Oktober, 2016}}
\firstpagefooter{Dr. Jan Grewe}{Phone: 29 74588}{Email:
jan.grewe@uni-tuebingen.de} \runningfooter{}{\thepage}{}
\setlength{\baselineskip}{15pt}
\setlength{\parindent}{0.0cm}
\setlength{\parskip}{0.3cm}
\renewcommand{\baselinestretch}{1.15}
\newcommand{\code}[1]{\texttt{#1}}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{document}
\vspace*{-6.5ex}
\begin{center}
\textbf{\Large Einf\"uhrung in die wissenschaftliche Datenverarbeitung}\\[1ex]
{\large Jan Grewe, Jan Benda}\\[-3ex]
Abteilung Neuroethologie \hfill --- \hfill Institut f\"ur Neurobiologie \hfill --- \hfill \includegraphics[width=0.28\textwidth]{UT_WBMW_Black_RGB} \\
\end{center}
Die folgenden Aufgaben dienen der Wiederholung, \"Ubung und
Selbstkontrolle und sollten eigenst\"andig bearbeitet und gel\"ost
werden. Die L\"osung soll in Form eines einzelnen Skriptes (m-files)
im ILIAS hochgeladen werden. Jede Aufgabe sollte in einer eigenen
``Zelle'' gel\"ost sein. Die Zellen \textbf{m\"ussen} unabh\"angig
voneinander ausf\"uhrbar sein. Das Skript sollte nach dem Muster:\newline
``boolesche\_ausdruecke\_\{nachname\}.m'' benannt werden
(z.B. variablen\_datentypen\_mueller.m).
\section{Boolesche Ausdr\"ucke}
\begin{questions}
\question 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{parts}
\part \verb+x > y+
\part \verb+y < x+
\part \verb+x == y+
\part \verb+x ~= y+
\part \verb+x & ~y+
\part \verb+x | y+
\end{parts}
\question Finde heraus, was die Funktionen \verb+bitand+ und \verb+bitor+ machen.
\begin{parts}
\part F\"uhre aus und erkl\"are: \verb+bitand(10, 8)+
\part F\"uhre aus und erkl\"are: \verb+bitor(10, 8)+
\end{parts}
\item Implementiere folgende Boolesche Ausdr\"ucke. Teste mit
zuf\"alligen ganzzahlingen Werten f\"ur \verb+x+ und \verb+y+.
\begin{parts}
\part Das Ergebnis sei wahr, wenn \verb+x+ gr\"o{\ss}er als \verb+y+ und die
Summe aus \verb+x+ und \verb+y+ nicht kleiner als 100 ist.
\part Das Ergebnis sei wahr, wenn \verb+x+ und \verb+y+ ungleich 0
oder \verb+x+ und \verb+y+ gleich sind.
\end{parts}
\end{questions}
\newpage
\section{Logische Indizierung}
Boolesche Ausdr\"ucke k\"onnen benutzt werden um aus Vektoren und
Matrizen die Elemente herauszusuchen, die einem bestimmeten Kriterium
entsprechen.
\begin{questions}
\question Gegeben sind \verb+x = (1:10)+ und
\verb+y = [3 1 5 6 8 2 9 4 7 0]+. Versuche die Ausgaben folgender
Anweisungen zu verstehen. Erkl\"are die Ergebnisse.
\begin{parts}
\part \verb+x < 5+
\part \verb+x( x < 5) )+
\part \verb+x( (y <= 2) )+
\part \verb+x( (x > 2) | (y < 8) )+
\part \verb+x( (x == 0) & (y == 0) )+
\end{parts}
\question Teste den Zufallsgenerator:
\begin{parts}
\part Erzeuge eine 100x100 2-D Matrize mit Zufallswerten zwischen
0 und 100 (\verb+randi+). Ersetze die Werte der Elemente, die in
folgende Klassen fallen: \verb+x < 33+ mit 0,
\verb+x >= 33 und x < 66+ mit 1 und alle \verb+x >= 66+ auf 2.
\part Ermittle die Anzahl Elemente f\"ur jede Klasse mithilfe eines
Booleschen Ausdrucks (\verb+sum+ kann eingesetzt werden um die
Anzahl Treffer zu ermitteln).
\end{parts}
\end{questions}
\end{document}

138
programming/exercises/control_flow_de.tex Normal file
View File

@ -0,0 +1,138 @@
\documentclass[12pt,a4paper,pdftex]{exam}
\usepackage[german]{babel}
\usepackage{natbib}
\usepackage{graphicx}
\usepackage[small]{caption}
\usepackage{sidecap}
\usepackage{pslatex}
\usepackage{amsmath}
\usepackage{amssymb}
\setlength{\marginparwidth}{2cm}
\usepackage[breaklinks=true,bookmarks=true,bookmarksopen=true,pdfpagemode=UseNone,pdfstartview=FitH,colorlinks=true,citecolor=blue]{hyperref}
%%%%% text size %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\usepackage[left=20mm,right=20mm,top=25mm,bottom=25mm]{geometry}
\pagestyle{headandfoot}
\header{{\bfseries\large \"Ubung 4}}{{\bfseries\large Kontrollstrukturen}}{{\bfseries\large 08. November, 2016}}
\firstpagefooter{Dr. Jan Grewe}{Phone: 29 74588}{Email:
jan.grewe@uni-tuebingen.de}
\runningfooter{}{\thepage}{}
\setlength{\baselineskip}{15pt}
\setlength{\parindent}{0.0cm}
\setlength{\parskip}{0.3cm}
\renewcommand{\baselinestretch}{1.15}
\newcommand{\code}[1]{\texttt{#1}}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{document}
\vspace*{-6.5ex}
\begin{center}
\textbf{\Large Einf\"uhrung in die wissenschaftliche Datenverarbeitung}\\[1ex]
{\large Jan Grewe, Jan Benda}\\[-3ex]
Abteilung Neuroethologie \hfill --- \hfill Institut f\"ur Neurobiologie \hfill --- \hfill \includegraphics[width=0.28\textwidth]{UT_WBMW_Black_RGB} \\
\end{center}
Die folgenden Aufgaben dienen der Wiederholung, \"Ubung und
Selbstkontrolle und sollten eigenst\"andig bearbeitet und gel\"ost
werden. Die L\"osung soll in Form eines einzelnen Skriptes (m-files)
im ILIAS hochgeladen werden. Jede Aufgabe sollte in einer eigenen
``Zelle'' gel\"ost sein. Die Zellen \textbf{m\"ussen} unabh\"angig
voneinander ausf\"uhrbar sein. Das Skript sollte nach dem Muster:
``control\_flow\_\{nachname\}.m'' benannt werden
(z.B. control\_flow\_mueller.m).
\begin{questions}
\question Implementiere \code{for} Schleifen bei denen die Laufvariable:
\begin{parts}
\part ... von 0 bis 10 l\"auft. Gib den Wert der Laufvariable im
Schleifenk\"orper aus.
\part ... von 10 bis 0 l\"auft. Gib den Wert der Laufvariable aus.
\part ... von 0 bis 1 in einer Schrittweite von 0.1 l\"auft. Gib
die Laufvariable aus.
\end{parts}
\question Zugriff auf Elemente in Vektoren:
\begin{parts}
\part Definiere einen Vektor \code{x} mit Werten von 1:100.
\part Benutze eine \code{for} Schleife um jedes Element von
\code{x} auszugeben indem die Laufvariable zum indizieren benutzt wird.
\part ... gleiches nur ohne eine Laufvariable zu nutzen.
\end{parts}
\question Erzeuge einen Vektor \verb+x+ mit 50 Zufallszahlen im
Bereich 0 - 10.
\begin{parts}
\part 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 $.
\part Benutze eine Schleife um die Standardabweichung zu
bestimmen:
$\sigma=\sqrt{\frac{1}{n}\sum\limits_{i=0}^{n}(x_i-\overline{x})^2}$).
\part Suche in der MATLAB Hilfe nach Funktionen, die das f\"ur
dich tun :-).
\end{parts}
\question Implementiere eine \code{while} Schleife
\begin{parts}
\part ... die 100 mal durchlaufen wird. Gib den aktuellen
Durchlauf im Schleifenk\"orper aus.
\part ... die endlos l\"auft. Sie kann mir \code{Strg + C}
abgebrochen werden.
\end{parts}
\question Nutze eine endlose \code{while} Schleife um einzeln die
Elemente eines Vektor der L\"ange 10 auszugeben.
\question Benutze eine endlose \verb+while+ Schleife um so lange
Zufallszahlen (\verb+randn+) zu ziehen, bis eine Zahl gr\"o{\ss}er
1.33 gezogen wurde.
\begin{parts}
\part Z\"ahle die Anzahl n\"otiger Versuche.
\part Nuzte eine \code{for} Schleife um den vorherigen Test
1000 mal laufen zu lassen. Merke Dir alle Anzahlen und berechne den
Mittelwert davon.
\part Plotte die Anzahl notwendiger Versuche.
\part Spiele mit der Schwelle, was passiert?
\end{parts}
\question Erstelle \verb+x+ einen Vektor mit 10 Zufallszahlen im
Bereich 0:10.
\begin{parts}
\part Benutze eine \code{for} Schleife um all die Elemente zu
loeschen (\code{x(index) = [];}), die kleiner als 5 sind.
\part Loesche alle Elemente die kleiner als 5 und groesser als 2
sind.
\part Kann man das gleiche auch ohne eine Schleife erledigen?
\end{parts}
\question Teste den Zufallsgenerator! Dazu z\"ahle die Anzahl der
Elemente, die durch folgende Grenzen getrennt werden [0.0, 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 waere die Erwartung,
was kommt heraus?
\question String parsing: Mitunter werden Dateinamen von
Datens\"atzen benutzt um anzuzeigen, unter welchen Bedingungen die
Daten gewonnen wurden. Man muss also den Dateinamen parsen und die
f\"ur einen relevante Information herausfiltern.
\begin{parts}
\part Erstelle eine Variable
\verb+filename = '2015-10-12_100Hz_1.25V.dat'+. Der Unterstrich
ist offensichtlich das verwendete Trennzeichen.
\part Benutze eine \verb+for+ Schleife um durch alle Zeichen zu
laufen. Vergleiche jedes Zeichen mit dem Unterstrich und merke
Dir die Positionen in einem Vektor.
\part Benutze eine zweite Schleife um durch diesen
Positionsvektor zu laufen und benutze die darin enthaltene
Information um den \code{filename} in Teile zu schneiden.
\part Gib die einzelnen Teile auf dem Bildschirm aus.
\end{parts}
\end{questions}
\end{document}

219
programming/exercises/scripts_functions_de.tex Normal file
View File

@ -0,0 +1,219 @@
\documentclass[12pt,a4paper,pdftex]{exam}
%\documentclass[answers,12pt,a4paper,pdftex]{exam}
\usepackage[german]{babel}
\usepackage{natbib}
\usepackage{xcolor}
\usepackage{graphicx}
\usepackage[small]{caption}
\usepackage{sidecap}
\usepackage{pslatex}
\usepackage{amsmath}
\usepackage{amssymb}
\setlength{\marginparwidth}{2cm}
\usepackage[breaklinks=true,bookmarks=true,bookmarksopen=true,pdfpagemode=UseNone,pdfstartview=FitH,colorlinks=true,citecolor=blue]{hyperref}
%%%%% text size %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\usepackage[left=20mm,right=20mm,top=25mm,bottom=25mm]{geometry}
\pagestyle{headandfoot}
\header{{\bfseries\large \"Ubung 5}}{{\bfseries\large Skripte und Funktionen}}{{\bfseries\large 15. November, 2016}}
\firstpagefooter{Prof. Jan Benda}{Phone: 29 74 573}{Email:
jan.benda@uni-tuebingen.de}
\runningfooter{}{\thepage}{}
\setlength{\baselineskip}{15pt}
\setlength{\parindent}{0.0cm}
\setlength{\parskip}{0.3cm}
\renewcommand{\baselinestretch}{1.15}
%%%%% listings %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\usepackage{listings}
\lstset{
language=Matlab,
basicstyle=\ttfamily\footnotesize,
numbers=left,
numberstyle=\tiny,
title=\lstname,
showstringspaces=false,
commentstyle=\itshape\color{darkgray},
breaklines=true,
breakautoindent=true,
columns=flexible,
frame=single,
xleftmargin=1em,
xrightmargin=1em,
aboveskip=10pt
}
\newcommand{\code}[1]{\texttt{#1}}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{document}
\vspace*{-6.5ex}
\begin{center}
\textbf{\Large Einf\"uhrung in die wissenschaftliche Datenverarbeitung}\\[1ex]
{\large Jan Grewe, Jan Benda}\\[-3ex]
Abteilung Neuroethologie \hfill --- \hfill Institut f\"ur Neurobiologie \hfill --- \hfill \includegraphics[width=0.28\textwidth]{UT_WBMW_Black_RGB} \\
\end{center}
Die folgenden Aufgaben dienen der Wiederholung, \"Ubung und
Selbstkontrolle und sollten eigenst\"andig bearbeitet und gel\"ost
werden. Im Gegensatz zu den vorherigen \"Ubungsbl\"attern k\"onnen die
L\"osungen nicht mehr in einer Datei gemacht werden. Die L\"osungen
also als zip-Archiv auf ILIAS hochladen. Das Archiv sollte nach dem Muster:
``skripte\_funktionen\_\{nachname\}.zip'' benannt werden.
\begin{questions}
\question Berechne die Fakult\"at einer Zahl.
\begin{parts}
\part Version 1: Schreibe eine Skript, das die Fakult\"at von 5 berechnet und das
Resultat auf dem Bildschirm ausgibt.
\begin{solution}
\lstinputlisting{factorialscripta.m}
\end{solution}
\part Version 2: Wie Version 1, aber als Funktion, die als
Argument die Zahl, von der die Fakult\"at berechnet werden soll,
\"ubernimmt.
\begin{solution}
\lstinputlisting{printfactorial.m}
\lstinputlisting{factorialscriptb.m}
\end{solution}
\part Version 3: Wie Version 2, die Funktion soll den berechneten
Wert nicht ausgeben, sondern als Funktionswert zur\"uckgeben. Das
aufrufende Skript soll dann den berechneten Wert auf dem
Bildschirm ausgeben.
\begin{solution}
\lstinputlisting{myfactorial.m}
\lstinputlisting{factorialscriptc.m}
\end{solution}
\end{parts}
\question Grafische Darstellung einer Sinuswelle.
\begin{parts}
\part Implementiere eine Funktion, die einen Sinus mit der
Amplitude 1 und der Frequenz $f = $ 50\,Hz plottet ($\sin(2\pi \cdot
f \cdot t)$). Rufe die Funktion auf.
\begin{solution}
\lstinputlisting{plotsine50.m}
\lstinputlisting{plotsinea.m}
\end{solution}
\part Erweitere die Funktion so, dass die L\"ange der Zeitachse,
die Amplitude, und die Frequenz als Argumente \"ubergeben werden
k\"onnen. Die Schrittweite soll in der Funktion aus der Frequenz
berechnet werden.
\begin{solution}
\lstinputlisting{plotsine.m}
\lstinputlisting{plotsineb.m}
\end{solution}
\part Verlagere alle plot Befehle in das aufrufende Skript
und ver\"andere die Funktion so, dass sie sowohl den Sinus als
auch die Zeitachse zur\"uckgibt.
\begin{solution}
\lstinputlisting{sinewave.m}
\lstinputlisting{plotsinec.m}
\end{solution}
\part Schreibe eine zweite Funktion, die den Sinus plotted und
daf\"ur die Zeitachse und den Sinus als Argument erh\"alt. Diese
Funktion soll die Achsen richtig beschriften. Schreibe ein kleines
Skript, dass beide Funktionen aufruft, um einen Sinus von 5\,Hz
mit der Amplitude 2 \"uber 1.5 Sekunden zu plotten.
\begin{solution}
\lstinputlisting{plotsinewave.m}
\lstinputlisting{plotsined.m}
\end{solution}
\end{parts}
%\question Schreibe eine Funktion, die bin\"are Datens\"atze
%('signal.bin' und 'signal2.bin' vom Montag) liest und die Daten als
%Vektor zur\"uckgibt. Welche Argumente muss die Funktion
%\"ubernehmen?
\question Random Walk.
\begin{parts}
\part Lies die Aufgabe bis zum Ende durch. \"Uberlege dir dann ein
geeignetes ``Programmlayout'' aus Funktionen und Skripten.
Was w\"are eine geeigente Funktion f\"ur diese Aufgabe? Welche
Argumente sollte sie entgegennehmen? Was soll sie berechnen und
zur\"uckgeben?
\begin{solution}
One function that computes one realisation of a random walk.
Scripts for plotting and analysis.
\lstinputlisting{randomwalkthresh.m}
\end{solution}
\part Simuliere und plotte die Positionen von 10 Realisationen
eines random walk mit gleichen Wahrscheinlichkeiten f\"ur beide
Richtungen. Jeder Walker startet an der Position 0 und soll so
lange laufen, bis er den Wert 50 \"uberschreitet oder den Wert
$-50$ unterschreitet.
\begin{solution}
\lstinputlisting{randomwalkscriptb.m}
\end{solution}
\part Jetzt wollen wir die Wahrscheinlichkeit $p$ f\"ur eine
Bewegung zu gr\"o{\ss}eren Positionen im Bereich $0.5 \le p < 0.8$
variieren. Simuliere 10 Realisationen des random walk f\"ur vier
verschiedene Wahrscheinlichkeiten.
\begin{solution}
\lstinputlisting{randomwalkscriptc.m}
\end{solution}
\part Wie entwickelt sich die mittlere ben\"otigte Schrittanzahl
in Abh\"angigkeit der Wahrscheinlichkeit? Stelle die Mittelwerte
und die Standardabweichungen graphisch dar.
\begin{solution}
\lstinputlisting{randomwalkscriptd.m}
\end{solution}
\end{parts}
%\question Modellierung des exponentiellen Wachstums einer isolierten
%Population. Das exponentielle Wachstum einer isolierten Population
%wird \"uber folgende Differentialgleichung beschrieben:
%\begin{equation}
% \frac{dN}{dt} = N \cdot r,
%\end{equation}
%mit $N$ der Populationsgr\"o{\ss}e und $r$ der Wachstumsrate.
%\begin{parts}
% \part L\"ose die Gleichung numerisch mit dem Euler Verfahren.
% \part Implementiere eine Funktion, die die Populationsgr\"o{\ss}e
% und die Zeit zur\"uckgibt.
% \part Plotte die Populationsgr\"o{\ss}e als Funktion der Zeit.
%\end{parts}
%\question Etwas realistischer ist das logistische Wachstum einer
%isolierten Population, bei der das Wachstum durch eine Kapazit\"at
%gedeckelt ist. Sie wird mit folgender Differentialgleichung
%beschrieben:
%\begin{equation}
% \frac{dN}{dt} = N \cdot r \cdot \left( 1 - \frac{N}{K} \right)
%\end{equation}
%mit $N$ der Population, der Wachstumsrate $r$ und $K$ der ``tragenden''
%Kapazit\"at.
%\begin{parts}
% \part Implementiere die L\"osung des logistischen Wachstums in
% einer Funktion. Benutze das Euler Verfahren. Die Funktion soll die
% Parameter $r$, $K$ sowie den Startwert von $N$ als Argumente
% \"ubernehmen.
% \part Die Funktion soll die Populationsgr\"o{\ss}e und die Zeit
% zur\"uckgeben.
% \part Simuliere das Wachstum mit einer Anzahl unterschiedlicher
% Startwerte f\"ur $N$.
% \part Stelle die Ergebnisse in einem Plot graphisch dar.
% \part Plotte das Wachstum $dN/dt$ als Funktion der
% Populationsgr\"o{\ss}e $N$.
%\end{parts}
\end{questions}
\end{document}

246
programming/exercises/variables_types_de.tex Normal file
View File

@ -0,0 +1,246 @@
\documentclass[12pt,a4paper,pdftex]{exam}
\usepackage[german]{babel}
\usepackage{natbib}
\usepackage{graphicx}
\usepackage[small]{caption}
\usepackage{sidecap}
\usepackage{pslatex}
\usepackage{amsmath}
\usepackage{amssymb}
\usepackage{lipsum}
\setlength{\marginparwidth}{2cm}
\usepackage[breaklinks=true,bookmarks=true,bookmarksopen=true,pdfpagemode=UseNone,pdfstartview=FitH,colorlinks=true,citecolor=blue]{hyperref}
%%%%% text size %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\usepackage[left=20mm,right=20mm,top=25mm,bottom=25mm]{geometry}
\pagestyle{headandfoot}
\header{{\bfseries\large \"Ubung 1}}{{\bfseries\large Variablen und Datentypen}}{{\bfseries\large 18. Oktober, 2016}}
\firstpagefooter{Dr. Jan Grewe}{Phone: 29 74588}{Email:
jan.grewe@uni-tuebingen.de}
\runningfooter{}{\thepage}{}
\setlength{\baselineskip}{15pt}
\setlength{\parindent}{0.0cm}
\setlength{\parskip}{0.3cm}
\renewcommand{\baselinestretch}{1.15}
\newcommand{\code}[1]{\texttt{#1}}
\renewcommand{\solutiontitle}{\noindent\textbf{L\"osung:}\par\noindent}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{document}
\vspace*{-6.5ex}
\begin{center}
\textbf{\Large Einf\"uhrung in die wissenschaftliche Datenverarbeitung}\\[1ex]
{\large Jan Grewe, Jan Benda}\\[-3ex]
Abteilung Neuroethologie \hfill --- \hfill Institut f\"ur Neurobiologie \hfill --- \hfill \includegraphics[width=0.28\textwidth]{UT_WBMW_Black_RGB} \\
\end{center}
Die folgenden Aufgaben dienen der Wiederholung, \"Ubung und
Selbstkontrolle und sollten eigenst\"andig bearbeitet und gel\"ost
werden. Die L\"osung soll in Form eines einzelnen Skriptes (m-files)
im ILIAS hochgeladen werden. Jede Aufgabe sollte in einer eigenen
``Zelle'' gel\"ost sein. Die Zellen \textbf{m\"ussen} unabh\"angig
voneinander ausf\"uhrbar sein. Das Skript sollte nach dem Muster:\linebreak
``variablen\_datentypen\_\{nachname\}.m'' benannt werden
(z.B. variablen\_datentypen\_mueller.m).
\begin{questions}
\question Erzeugen und L\"oschen von Variablen:
\begin{parts}
\part Erzeuge zwei Variablen \code{a}, \code{b} und weise ihnen
unterschiedliche Werte zu. Schlie{\ss}e die Zeilen mit einem
Semikolon ab. Erstelle eine Variable \code{c} die leer ist.
\begin{solution}
\code{a = 1;} \code{b = 2;} \code{c = [];}
\end{solution}
\part Lass die Werte der Variablen ausgeben.
\begin{solution}
\code{disp(a)}; \code{disp(b)}; \code{disp(c)}
\end{solution}
\part Benuzte die Kommandozeile um herauszufinden, welche Variablen
es im Workspace gibt.
\begin{solution}
\code{who}
\end{solution}
\part Benuzte die Kommandozeile um herauszufinden, welche Datentypen sie haben.
\begin{solution}
\code{whos} oder \code{class(a)}, \code{class(b)}, \code{class(c)}
\end{solution}
\part Finde in der Hilfe mehr Information \"uber das \code{clear} Kommando.
\begin{solution}
\code{help clear}
\end{solution}
\part L\"osche eine Variable.
\begin{solution}
\code{clear a}
\end{solution}
\part L\"osche alle \"ubrigen Variablen.
\begin{solution}
\code{clear all} oder einfach \code{clear}
\end{solution}
\end{parts}
\question Operationen auf Variablen:
\begin{parts}
\part Erstelle die Variablen \code{a} und \code{b} und weise ihnen
beliebige Werte zu.
\begin{solution}
\code{a = 5; b = 3.14;}
\end{solution}
\part Addiere beliebige andere Zahlen zu den Variablen \code{a} und \code{b}.
\begin{solution}
\code{a + 5} \code{b + 7.28}
\end{solution}
\part Addiere die Variablen.
\begin{solution}
\code{a + b}
\end{solution}
\part Mulipliziere die Variablen miteinander.
\begin{solution}
\code{a * b}
\end{solution}
\part \"Andern sich die urspr\"unglichen Werte der Variablen?
\begin{solution}
Nein, die Operationen benutzen die Werte der Variablen. Die
Variablen bleiben unver\"andert.
\end{solution}
\part F\"uhre eine beliebige Berechnungen mit den Variablen aus und
weise die Ergebnisse einer neuen Variable \code{x} zu.
\begin{solution}
\code{x = a * b;}
\end{solution}
\part Weise \code{a} und \code{b} neue Werte zu. Hat sich etwas am
Wert von \code{x} ge\"andert?
\begin{solution}
Nein, der Variablen \code{x} wird ein Wert zugewiesen, der sich
nicht \"andert bis der Variablen ein neuer Wert zugewiesen
wird. Die Variable 'x' speichert das Resultat der Rechnung
\textbf{nicht} die Anweisung.
\end{solution}
\end{parts}
\question Berechne die Fakult\"at von 5:
\begin{parts}
\part Erzeuge eine Variable \code{x} und weise ihr den Wert 1 zu.
\part Berechne den ersten Schritt (\code{*2}) und weise das Ergebnis \code{x}
zu.
\part Fahre schrittweise fort, bis die Fakult\"at von 5 berechnet ist. \code{x}
sollte nun das Endergebnis enthalten.
\end{parts}
\begin{solution}
\code{x = 1;} \\ \code{x = x * 2;}\\ \code{x = x * 3;} \\ \code{x = x * 4;} \\ \code{x = x * 5;}\\ \code{disp(x)}\\
\code{ 120}
\end{solution}
\question Erstelle eine Variable, die einen beliebigen Text enth\"alt. Was
ist ihr Datentyp?
\begin{solution}
\code{x = 'einfacher Text'}\\ \code{class(x)\\ char}
\end{solution}
\question Was sind die gr\"o{\ss}ten Zahlen, die in den Integer 8, 16, 32
und 64 bit Datentypen abgelegt werden k\"onnen?
\begin{solution}
\verb+2^8 / 2 - 1+\\
\verb+2^16 / 2 - 1+\\
\verb+2^32 / 2 - 1+\\
\verb+2^64 / 2 - 1+
\end{solution}
\question Erstelle eine Variable des 8 Bit Integer Datentyps und weise
ihr einen Wert zu. Addiere \code{300}. Welchen Wert enth\"alt nun die
Variable? Warum?
\begin{solution}
\code{x = int8(35);\\x = x + 300;\\ disp(x)\\ 127}\\
Der Datentype int8 kann nur Werte von -128 bis 127 speichern.
\end{solution}
\question Erkl\"are die Ausgaben von \code{int8(1024)} und \code{uint8(1024)}.
\begin{solution}
Der int8 Datentyp kann Werte von -128 bis maximal 127 ablegen. Der
uint8 Typ ist \textit{unsigned}, er speichert Werte zwischen 0 und
255.
\end{solution}
\question Typkonvertierung:
\begin{parts}
\part F\"uhre aus: \code{x = 131.333}. Welchen Datentyp hat die
Variable \code{x}?
\begin{solution}
Sie hat den Typ \textit{double}.
\end{solution}
\part Wandle \code{x} in den speichereffizientesten Integer Datentypen um.
\begin{solution}
\code{x = uint8(x);}\\Ben\"otigt 8 bit anstelle der 64 bit f\"ur
den double.
\end{solution}
\part Welchen Wert hat nun \code{x} ?
\begin{solution}
131
\end{solution}
\end{parts}
\question Flie{\ss}kommazahlen 1: Endliche Pr\"azision bei Addition
\begin{parts}
\part Weise der Variablen \code{a} eine Zahl mit Nachkommastellen zu.
\begin{solution}
\code{a = 3.14;}
\end{solution}
\part Eine weitere Variable \code{b} soll den Wert \code{a+0.001}
haben. Was ist das Ergebnis von \code{b-a} ?
\begin{solution}
\code{b = a + 0.001;}\\ \code{disp(b - a)\\0.001}\\
Alles ok, Ergebnis wie erwartet.
\end{solution}
\part Einer dritte Variable \code{c} soll der Wert \code{a+1e-16}
zugewiesen werden. Was ist das Ergebnis von \code{c-a} ? Warum?
\begin{solution}
Das Ergebnis ist 0! Auch die double Werte haben nur eine endliche
P\"azision in den Nachkommastellen.
\end{solution}
\part Berechne \verb=(2^52 + 1) - 2^52= sowie
\verb=(2^53 + 1) - 2^53=.
\begin{solution}
Im Ersten Fall ist das Ergebnis = 1, im Zweiten = 0. Bei so
gro{\ss}en Zahlen k\"onnen so kleine Unterschiede nicht mehr
aufgel\"ost werden.
\end{solution}
\part Berechne \code{sqrt(1+1e-16)-1} . Ist das richtig? Warum?
\begin{solution}
Die Wurzel von 1 + etwas sollte nicht 1 sein! Das Ergebnis
sollte nicht 0 sein.
\end{solution}
\part Vergleiche mit dem Ergebnis beim Addieren einer etwas
gr\"o{\ss}eren Zahl (z.B. 1e-8).
\begin{solution}
Hier sollte das Ergebnis ungleich 0 sein.
\end{solution}
\end{parts}
\question Flie{\ss}kommazahlen 2: Endliche Pr\"azision bei Multiplikation
\begin{parts}
\part Weise der Variablen \code{a} die Zahl \code{4/3} zu.
\part Die Variable \code{b} soll den Wert \code{3*(a-1)} erhalten.
\part Welches Ergebnis erwartest du f\"ur \code{b-1} ?
\begin{solution}
\code{a = 4/3;}\\ \code{b = 3 * (a-1)}\\
b sollte nun 1 sein. d.h., \code{b-1} sollte 0 sein.
\end{solution}
\part Berechne mit matlab \code{b-1} !
\begin{solution}
\code{disp(b - 1)\\ -2.2204e-16}\\ Aufgrund von Rundungsfehlern
kommt es zu diesem Ergebnis.
\end{solution}
\part Was sollte \code{sin(pi)} ergeben ? Was sagt matlab?
\begin{solution}
Sollte 0 sein, ist es aber nicht. Wie oben, Rundungsfehler
f\"uhren zu diesen Abweichungen.
\end{solution}
\end{parts}
\end{questions}
\end{document}

410
programming/exercises/vectors_matrices_de.tex Normal file
View File

@ -0,0 +1,410 @@
\documentclass[12pt,a4paper,pdftex]{exam}
\usepackage[german]{babel}
\usepackage{natbib}
\usepackage{graphicx}
\usepackage[small]{caption}
\usepackage{sidecap}
\usepackage{pslatex}
\usepackage{amsmath}
\usepackage{amssymb}
\setlength{\marginparwidth}{2cm}
\usepackage[breaklinks=true,bookmarks=true,bookmarksopen=true,pdfpagemode=UseNone,pdfstartview=FitH,colorlinks=true,citecolor=blue]{hyperref}
%%%%% text size %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\usepackage[left=20mm,right=20mm,top=25mm,bottom=25mm]{geometry}
\pagestyle{headandfoot} \header{{\bfseries\large \"Ubung
2}}{{\bfseries\large Vektoren und Matrizen}}{{\bfseries\large 12. Oktober, 2015}}
\firstpagefooter{Dr. Jan Grewe}{Phone: 29 74588}{Email:
jan.grewe@uni-tuebingen.de} \runningfooter{}{\thepage}{}
\setlength{\baselineskip}{15pt}
\setlength{\parindent}{0.0cm}
\setlength{\parskip}{0.3cm}
\renewcommand{\baselinestretch}{1.15}
\newcommand{\code}[1]{\texttt{#1}}
\renewcommand{\solutiontitle}{\noindent\textbf{L\"osung:}\par\noindent}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{document}
\vspace*{-6.5ex}
\begin{center}
\textbf{\Large Einf\"uhrung in die wissenschaftliche Datenverarbeitung}\\[1ex]
{\large Jan Grewe, Jan Benda}\\[-3ex]
Abteilung Neuroethologie \hfill --- \hfill Institut f\"ur Neurobiologie \hfill --- \hfill \includegraphics[width=0.28\textwidth]{UT_WBMW_Black_RGB} \\
\end{center}
Die folgenden Aufgaben dienen der Wiederholung, \"Ubung und
Selbstkontrolle und sollten eigenst\"andig bearbeitet und gel\"ost
werden. Die L\"osung soll in Form eines einzelnen Skriptes (m-files)
im ILIAS hochgeladen werden. Jede Aufgabe sollte in einer eigenen
``Zelle'' gel\"ost sein. Die Zellen \textbf{m\"ussen} unabh\"angig
voneinander ausf\"uhrbar sein. Das Skript sollte nach dem Muster:
\linebreak ``vektoren\_matrizen\_\{nachname\}.m'' benannt werden
(z.B. vektoren\_matrizen\_mueller.m).
\begin{questions}
\section*{Vektoren}
\question Erzeuge Vektoren mit folgendem Inhalt:
\begin{parts}
\part Von 1 bis 10 in ganzzahligen Schritten.
\begin{solution}
\code{a = 1:10;}
\end{solution}
\part Von 0 bis 20 in 2er Schritten.
\begin{solution}
\code{a = 0:2:20;}
\end{solution}
\part Mit \textbf{absteigendem} Inhalt von 100 bis 0.
\begin{solution}
\code{a = 100:-1:0;}
\end{solution}
\part In 10 Schritten von 0 bis 1.
\begin{solution}
\code{a = 0:0.1:1;}
\end{solution}
\part In 11 Schritten von 0 bis 1.
\begin{solution}
\code{a = 0:1/11:1;}
\end{solution}
\part In 50 Schritten von 0 bis $2\pi$ ($\pi$ ist als Konstante
\code{pi} in Matlab definiert).
\begin{solution}
\code{a = 0:2*pi/50:2*pi;}
\end{solution}
\end{parts}
\question Rechnen mit Vektoren:
\begin{parts}
\part Definiere einen Vektor \code{x = [3 2 6 8];}
\part Wie gro{\ss} ist der Vektor? Benutze die Funktionen
\code{size} und \code{length}. Was ist der Unterschied zwischen
den beiden Funktionen?
\begin{solution}
\code{x = [3 2 6 8]; \\ disp(length(x));\\ 4\\ disp(size(x))\\ 1 4}
\end{solution}
\part Wie \"andern sich \code{size} und \code{length} des
Vektors wenn er transponiert wird?
\begin{solution}
L\"ange \"andert sich nicht. R\"uckgabewert von size ist invertiert.
\end{solution}
\part Addiere 5 zu jedem Element von \verb+x+.
\begin{solution}
\code{disp(x + 5)}
\end{solution}
\part Multipliziere jedes Element von \code{x} mit 2;
\begin{solution}
\code{disp(x * 2)}
\end{solution}
\part Definiere einen zweiten Vektor (\verb+y = [4 1 3 5];+).
Stelle sicher, dass \code{x} wieder in seiner urspr\"unglichen
Form ist.
\part Addiere beide Vektoren \code{x + y}.
\begin{solution}
\code{y = [4 1 3 5]; \\disp(x + y)\\7 3 9 13}
\end{solution}
\part Subtrahiere beide Vektoren \code{x - y}.
\begin{solution}
\code{disp(x - y)\\-1 1 3 3}
\end{solution}
\part Multipliziere beide Vektoren \code{x * y}.
\begin{solution}
\code{disp(x * y)\\Error using *. Inner matrix dimension must agree.}
\end{solution}
\part Erkl\"are die Fehlermeldung.
\begin{solution}
* ist der Operator f\"ur die Matrixmultiplikation. Bei dieser
muessen die inneren Dimensionen \"uebereinstimmen.\linebreak
\code{disp(size(x))\\1 4 \\disp(size(y)) \\ 1 4}\\
(m,n)*(n,o) w\"are ok.
\end{solution}
\part Was m\"usste man machen, damit \code{mtimes} bzw. der
\code{*} Operator funktionieren?
\begin{solution}
y m\"usste transponiert werden: \code{x * y'}
\end{solution}
\part Multipliziere die Vektoren elementweise (\code{x .* y})
und weise das Ergebnis eine neuen Variablen zu.
\begin{solution}
\code{z = x .* y;}
\end{solution}
\end{parts}
\question Erzeugen von Vektoren mit Helferfunktionen:
\begin{parts}
\part Erstelle einen 100 Elemente langen Vektor mit der Funktion
\code{ones} (siehe Hilfe). Was macht sie?
\begin{solution}
\code{ones(100,1)} erzeugt einen Vektor bei dem alle Elemente mit 1 gef\"ullt sind.
\end{solution}
\part Erstelle einen 100 Elemente langen Vektor mit der Funktion
\code{zeros}. Was macht diese?
\begin{solution}
\code{zeros(100,1)} erzeugt einen Vektor bei dem alle Elemente mit 0 gef\"ullt sind.
\end{solution}
\part Erstelle einen 100 Elemente langen Vektor in dem jedes
Element den Wert 4.5 hat.
\begin{solution}
\code{ones(100,1) * 4.5}
\end{solution}
\part Erzeuge einen Vektor mit 100 Zufallszahlen (\code{rand},
siehe Hilfe).
\begin{solution}
\code{x = rand(100,1)}
\end{solution}
\part Erzeuge einen Vektor mit 100 Werten zwischen 0 und 1
mithilfe der Funktion \code{linspace}.
\begin{solution}
\code{x = linspace(0,1,100)}
\end{solution}
\end{parts}
\question Indizieren in Vektoren:
\begin{parts}
\part Erzeuge einen Vektor mit 100 Elementen (0 - 100).
\begin{solution}
\code{x = linspace(0,100,100);}
\end{solution}
\part Gib jeweils den ersten, den letzten, den 5., 24. und den
vorletzten Wert aus.
\begin{solution}
\code{disp(x(1))\\ disp(x(end))\\ disp(x(5))\\ disp(x(24))\\ disp(x(end-1))}
\end{solution}
\part Gib die ersten 10 Werte aus.
\begin{solution}
\code{x(1:10)}
\end{solution}
\part Gib die letzten 10 Werte aus.
\begin{solution}
\code{disp(x(end-9:end))}
\end{solution}
\part Versuche den Wert an der Stelle 0 auszugeben.
\begin{solution}
\code{x(0)\\ Subscript indices must either be real positive integers or logicals.}
\end{solution}
\part Versuche den Wert an der Stelle 110 auszugeben.
\begin{solution}
\code{x(110)\\ Index exceeds matrix dimensions.}
\end{solution}
\part Gib die Werte an den Stellen 3, 15, und 42 zusammen als
Vektor aus.
\begin{solution}
\code{disp(x([3 15 42]))}
\end{solution}
\part Gib 10 zuf\"allig ausgew\"ahlte Werte aus (benutze
\verb+randi+ um die Indizes zu erstellen).
\begin{solution}
\code{x(randi(100,10,1))}
\end{solution}
\end{parts}
\question Erzeuge eine Variable und speichere etwas Text in ihr,
so dass mindestens 2 Worte vorhanden sind. (z.B. \code{x = 'some
text'}). Benutze die Indizierung um die W\"orter einzeln
auszugeben.
\begin{solution}
\code{x = 'some text'; \\ disp(x(1:4))\\disp(x(6:end))}
\end{solution}
\newpage
\section*{Matrizen}
\question Erstelle folgende Matrix
\[ A = \left( \begin{array}{ccc} 7 & 3 & 5 \\ 1 & 8 & 3 \\ 8 & 6 &
4 \end{array} \right) \]
\begin{parts}
\part Benutze die Funktion \code{size} um die Gr\"o{\ss}e vpm \code{A} anzeeigen zu lassen.
\begin{solution}
\code{x = [7 3 5; 1 8 3; 8 6 4];\\disp(size(x))}
\end{solution}
\part Finde heraus, wie man \code{size} aufruft um nur die L\"ange entlang einer einzelnen Dimension auszugeben. Gib einzeln die L\"angen beider Dimensionen aus.
\begin{solution}
\code{disp(size(x, 1))}\\\code{disp(size(x, 2))}
\end{solution}
\part Gib das Element in der 3. Zeile und 2. Spalte aus.
\begin{solution}
\code{x(3,2)}
\end{solution}
\part Gib jeweils alle Elemente der 1., 2. und 3. Zeile aus.
\begin{solution}
\code{disp(x([1 2 3],:));}
\end{solution}
\part Gib jeweils alle Elemente der 1., 2., und 3. Spalte aus.
\begin{solution}
\code{disp(x(:, 1))\\ disp(x(:, 2))\\ disp(x(:, 3))}
\end{solution}
\part Erh\"ohe das Element in der 2. Zeile und 3. Spalte um Eins.
\begin{solution}
\code{x(2,3) = x(2,3) + 1;}
\end{solution}
\part Ziehe von allen Elementen der 1. Zeile 5 ab.
\begin{solution}
\code{x(1,:) = x(1,:) - 5;}
\end{solution}
\part Multipliziere alle Elementen der 3. Spalte mit 2.
\begin{solution}
\code{x(:,3) = x(:,3) * 2;}
\end{solution}
\end{parts}
\question Erstelle eine $5 \times 5$ Matrix \code{M} die
Zufallszahlen enth\"alt (nutze die MATLAB Funktion
\verb+randn()+. Benutze die Hilfe: Was macht die Funktion?).
\begin{parts}
\part Gib das Element in der 2. Zeile und 3. Spalte aus.
\begin{solution}
\code{M = randn(5, 5);}
\code{disp(M(2,3))}
\end{solution}
\part Gib jeweils alle Elemente der 1., 3. und letzten Zeile aus.
\begin{solution}
\code{disp(M(1,:)) \\ disp(M(3,:))\\ disp(M(size(M,1), :))}
\end{solution}
\part Gib jeweils alle Elemente der 2. und 4. Spalte aus.
\begin{solution}
\code{disp(M(:,2))\\ disp(M(:,4))}
\end{solution}
\part Greife mit einem einzigen Kommando auf die Elemente jeder
zweiten Spalte zu und speichere die Daten in einer neuen Variable.
\begin{solution}
\code{y = M(:, [2:2:size(M,2)])}
\end{solution}
\part Berechne jeweils den Mittelwert der 1., 3. und 5. Zeile
(Funktion \code{mean}, siehe Hilfe).
\begin{solution}
\code{mean(M([1 3 5],:), 2)}
\end{solution}
\part Berechne die Summe aller Werte der 2. und 4. Spalte
(Funktion \code{sum}, siehe Hilfe).
\begin{solution}
\code{sum(M(:, [2 4]), 1)}
\end{solution}
\part Berechne die Summe aller Elemente der Matrize.
\begin{solution}
\code{sum(M(:))}
\end{solution}
\part Ersetze die Elemente der 2. Zeile mit denen der 4.
\begin{solution}
\code{M(2,:) = M(4,:)}
\end{solution}
\part F\"uhre folgendes Kommando aus: \code{M(1:2,1) = [1, 2,
3]}. Was k\"onnte die Absicht dieses Codes gewesen sein? Was
bedeutet die Fehlermeldung?
\begin{solution}
\code{M(1:2,1) = [1, 2,3];\\ Subscripted assignment dimension
mismatch.} \\ Der einzuf\"ugende Vektor hat 3 Elemente, die
Auswahl von M in die geschrieben werden soll hat nur die
Gr\"o{\ss}e 2;
\end{solution}
\end{parts}
\question Matrizen k\"onnen neben der ``normalen''
\textit{subscript} Indizierung auch \textit{linear} indiziert werden
(siehe Hilfe \"uber Indexing oder Funktionen \verb+sub2ind+ oder
\verb+ind2sub+).
\begin{parts}
\part Erstelle eine 2-D Matrix mit Zufallszahlen mit der Dimensionalit\"at
\verb+[10,10]+.
\begin{solution}
\code{x = randn(10, 10)}
\end{solution}
\part Wie viele Werte enth\"alt sie?
\begin{solution}
\code{disp(numel(x))}
\end{solution}
\part Benutze das lineare Indizieren um 50 zuf\"allige Werte
auszuw\"ahlen.
\begin{solution}
\code{x(randi(100, 50, 1)])}
\end{solution}
\part Wo liegt der Vorteil gegen\"uber der \textit{subscript}
Indizierung?
\begin{solution}
Die Matrize ist 2-dimensional. Wenn mit dem subscript index
zugegriffen werden soll, dann muss auf die Dimensionen
einzeln geachtet werden. Mit dem linearen Indexieren kann einfach
einen Vektor mit n Indices benutzt werden. Wenn es auch noch eine
eindeutige (ohne doppelte) Auswahl sein soll, dann muss bei
2-D viel komplexer kontrollieren.
\end{solution}
\part Berechne die Summe aller Werte mit einem Funktionsaufruf..
\begin{solution}
\code{sum(x(:))} oder \code{sum(sum(x))}
\end{solution}
\end{parts}
\question 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 funktionieren
sie nicht? Teste Deine Vorhersagen.
\begin{parts}
\part \code{x + y}
\begin{solution}
Funktioniert!
\end{solution}
\part \code{x * M}
\begin{solution}
Matrixmultiplikation Funktioniert nicht! Inner dimensions must agree!
\end{solution}
\part \code{x + y'}
\begin{solution}
Funktioniert nicht! Die Dimensionalit\"aten passen nicht.
\end{solution}
\part \code{M - [x y]}
\begin{solution}
Funktioniert nicht! \code{[x y] ist ein Zeilenvektor der L\"ange
6, M ist eine Martix.}
\end{solution}
\part \code{[x; y]}
\begin{solution}
Funktioniert! Gr\"o{\ss}e: 2 3
\end{solution}
\part \code{M - [x; y]}
\begin{solution}
Funktioniert!
\end{solution}
\end{parts}
\question 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{parts}
\part Gib alle Elemente des ersten ``Blattes'' aus (Index 1 der 3. Dimension).
\begin{solution}
\code{x = randn(5,5); \\y = randn(5, 5);\\ z = cat(3, x, y);\\disp(z(:,:,1))}
\end{solution}
\end{parts}
\question Erzeuge eine $5 \times 5 \times 5$ Matrix die mit
ganzzahligen, gleichverteilten Zufallszahlen zwischen 0 und 100
gef\"ullt ist.
\begin{parts}
\part Berechne den Mittelwert aller Bl\"atter dieser Matrix
(benutze \verb+mean()+, siehe Hilfe).
\begin{solution}
\code{x = round(rand(5,5,5) .* 100);\\ Disp(mean(mean(x(:,:,1))))\\ disp(mean(mean(x(:,:,2)))) \\ disp(mean(mean(x(:,:,3))))}
\end{solution}
\end{parts}
\end{questions}
\end{document}