Merge solved.

modsim/ass2/report.tex

@@ -13,6 +13,15 @@
 
 \maketitle
 
+\section*{Inleiding} % {{{
+\label{sec:Inleiding}
+
+Voor elk van de zeven opgaven in dit programma hebben we een aparte executable
+gemaakt waarmee het programma voor de desbetreffende opgave wordt uitgevoerd.
+Bijvoorbeeld is \texttt{q1} de naam van de executable die het programma van
+opgave 1 uitvoert. De algoritmes die door meerdere opgaven worden gebruikt
+hebben we ge\"implementeerd in aparte C-bestanden.
+
 \section{Differentiatie} % {{{
 \label{sec:Differentiatie}
 
@@ -85,21 +94,36 @@ nauwkeurigheid en het aantal stappen van de berekening:
 berekening is logaritmisch.}
 \end{figure}
 
-\noindent Uit de grafiek kunnen we concluderen dat de groei van het aantal
-benodigde stappen voor de berekening logaritmisch (met basis 10) afneemt met de
-beoogde nauwkeurigheid.
+\noindent Uit de grafiek kunnen we concluderen dat het aantal benodigde stappen
+voor de berekening exponentieel afneemt met de beoogde nauwkeurigheid. Dit
+betekent dat de \emph{groei} van het aantal benodigde stappen lineair afneemt
+met de nauwkeurigheid. Merk op dat de datapunten niet op een perfect rechte lijn
+liggen, dit komt doordat het aantal stappen wordt afgerond op gehele getallen.
 
 % }}}
 
 \section{Benadering van $\sqrt{2}$} % {{{
 \label{sec:benadering van sqrt 2}
 
+$\sqrt{2}$ is gelijk aan het nulpunt van de functie $f(x) = x^2 - 2$. Dit nulpunt
+hebben we met verschillende methoden benaderd, waarbij we verschillende
+foutmarges hebben meegegeven. Door het aantal stappen van de berekening te
+tellen kunnen we mogelijk een verband bepalen tussen de foutmarge en het aantal
+benodigde stappen voor de berekening. We hebben de resultaten van ons programma
+ondergebracht in onderstaande grafiek:
+
 \begin{figure}[H]
-\centering
 \includegraphics[width=12cm]{sqrt}
-\caption{A}
+\caption{Het verband tussen de nauwkeurigheid en het aantal stappen van de
+berekening voor drie verschillende ``root-finding'' methodes (blauw: Bisection,
+rood: Regula Falsi, groen: Newton-Raphson).}
 \end{figure}
 
+We zien, net als bij opgave 2, dat de groei van het aantal benodigde stappen
+lineair afneemt met de nauwkeurigheid. Merk op dat ook hier de grafiekkrommen
+niet perfect recht zijn, omdat het aantal stappen is afgerond op gehele
+getallen.
+
 % }}}
 
 \section{Newton-Raphson} % {{{
@@ -193,11 +217,35 @@ sin & 0 & $8\pi$ & gauss       & $-1.797258919631 \cdot 10^{-14}$ & $1.797258919
 \section{Instelbare accuratie} % {{{
 \label{sec:Instelbare accuratie}
 
+Het in natuurlijk interessant om te weten hoeveel het ``kost'' om een bepaalde
+minimale nauwkeurigheid te bereiken bij een benadering van een integraal.
+Hiervoor hebben we de functie \texttt{accurate\_integral} geschreven, waaraan we
+een bepaalde nauwkeurigheid meegeven. Deze nauwkeurigheid is te specifi\"eren
+door het gewenste aantal ``correcte'' decimalen mee te geven aan het programma.
+Om bijvorbeeld de (in het programma gedefini\"eerde) integralen op 3 decimalen
+nauwkeurig te berekenen, moet het programma als volgt worden worden aangeroepen:
+\begin{verbatim}
+./q6 3
+\end{verbatim}
+
 % }}}
 
 \section{Fibonnaci} % {{{
 \label{sec:Fibonnaci}
 
+Het programma wat we hebben gemaakt vraagt twee argumenten: het aantal te
+simuleren generaties en optioneel de maximum leeftijd van een konijn (standaard
+is deze oneindig). De volgende aanroep simuleert bijvoorbeeld een de groei van
+een konijnenpopulatie over 25 generaties, waarbij elk konijn maximaal 3 jaar oud
+wordt:
+\begin{verbatim}
+./q7 25 3
+\end{verbatim}
+Naast de grootte van de populatie bevat de uitvoer van het programma ook de
+groei van de populatie. We hebben het programma met verschillende waarden
+uitgevoerd, de resultaten hiervan hebben we ondergebracht in de volgende
+grafieken:
+
 \begin{figure}[H]
 \centering
 \includegraphics[width=12cm]{rabbit}

modsim/ass2/sqrt.py

+
+import matplotlib.pyplot as plt
+
+data = \
+    [
+       [[3, 1e-01], [6, 1e-02], [9, 1e-03], [13,1e-04], [16,1e-05],
+        [19,1e-06], [23,1e-07], [26,1e-08], [29,1e-09]],
+
+       [[1, 1e-01], [2, 1e-02], [2, 1e-03], [2, 1e-04], [3, 1e-05],
+        [3, 1e-06], [3, 1e-07], [3, 1e-08], [4, 1e-09]],
+
+       [[3, 1e-01], [3, 1e-02], [6, 1e-03], [6, 1e-04], [6, 1e-05],
+        [6, 1e-06], [6, 1e-07], [8, 1e-08], [8, 1e-09]]
+    ]
+
+plt.plot(zip(*data[0])[1], zip(*data[0])[0], 'o',
+        zip(*data[1])[1], zip(*data[1])[0], 'o',
+        zip(*data[2])[1], zip(*data[2])[0], 'o')
+
+plt.xscale('log')
+plt.xlabel('epsilon')
+plt.ylabel('steps')
+plt.grid(True)
+plt.savefig('sqrt.pdf')
+