Report started

- Add output parameter to methods for objective function calls
 - Adjust the code to reduce objective function calls to some methods

Work 1/report/report.tex

@@ -1,5 +1,5 @@
 %
-% Optimization Techniques Assignment 1 report
+% Optimization Techniques Work 1 report
 %
 % authors:
 %   Χρήστος Χουτουρίδης ΑΕΜ 8997
@@ -29,13 +29,176 @@
 \InstructorMail{rovithak@auth.gr}
 \CurrentDate{\today}
 
+\usepackage{capt-of}
+\usepackage{enumitem}
+
 
 \begin{document}
 
+\setlist[itemize]{topsep=0pt, partopsep=0pt, itemsep=3pt, parsep=3pt}
+
 \InsertTitle
 
+\sloppy
+
 \section{Εισαγωγή}
+Η παρούσα εργασία αφορά στις αριθμητικές μεθόδους ευρέσεως ελαχίστων σε πεπερασμένα διαστήματα, που χρησιμοποιούνται σε προβλήματα βελτιστοποίησης.
+Οι αριθμητικές μέθοδοι βελτιστοποίησης συναρτήσεων αναπτύχθηκαν ιδιαίτερα στα μέσα του 20ού αιώνα, καθώς η εύρεση ελαχίστων (ή και μεγίστων) άρχισε να έχει μεγάλη πρακτική σημασία, ειδικά σε τομείς όπως η οικονομία, η φυσική, ή η ανάλυση συστημάτων.
+Η μέθοδος της \textbf{διχοτόμου} έχει ρίζες στον Νεύτωνα και τον Ντεκάρτ, με τη διχοτόμηση να χρησιμοποιείται αρχικά για τον υπολογισμό της ρίζας μιας συνάρτησης και αργότερα να εξελίσσεται σε τεχνική για βελτιστοποίηση σε κυρτές συναρτήσεις.
+Η μέθοδος του \textbf{χρυσού τομέα} προτάθηκε στις αρχές του 20ού αιώνα και εφαρμόστηκε στην βελτιστοποίηση τη δεκαετία του 1950.
+Στη μέθοδό αυτή γίνεται χρήση της αναλογίας της "χρυσής τομής," η οποία προέρχεται από την αρχαία ελληνική γεωμετρία και χρησιμοποιούνταν για την κατασκευή αρμονικών διαστάσεων.
+Η μέθοδος \textbf{Fibonacci} εισήχθηκε τη δεκαετία του 1960 και χρησιμοποιεί την ακολουθία Fibonacci, γνωστή ήδη από το 1202 από τον Ιταλό μαθηματικό Λεονάρντο της Πίζας (Fibonacci).
+Η μέθοδος εκμεταλλεύεται τις ιδιότητες της ακολουθίας για να περιορίσει το διάστημα αναζήτησης πιο αποδοτικά σε σύγκριση με τον χρυσό τομέα.
+Τέλος, η μέθοδος \textbf{διχοτόμου με χρήση παραγώγου}, αξιοποιεί τη χρήση των παραγώγων που εισήγαγε ο Νεύτων, για να υπολογίσει την κατεύθυνση προς το ελάχιστο.
+Αυτές οι μέθοδοι αποτέλεσαν το θεμέλιο για την ανάπτυξη πιο σύγχρονων τεχνικών βελτιστοποίησης, οι οποίες συνεχίζουν να εξελίσσονται στον χώρο της μηχανικής μάθησης και των μαθηματικών.
+
+\section{Παραδοτέα}
+Τα παραδοτέα της εργασίας αποτελούνται από:
+\begin{itemize}
+    \item Την παρούσα αναφορά.
+    \item Τον κατάλογο \textbf{scripts}, που περιέχει τον κώδικα της MATLAB.
+    \item Το \href{https://git.hoo2.net/hoo2/OptimizationTechniques/src/branch/master/Work%201}{σύνδεσμο} με το αποθετήριο που περιέχει όλο το project με τον κώδικα της MATLAB, της αναφοράς και τα παραδοτέα.
+\end{itemize}
+
+
+\section{Προγραμματιστική προσέγγιση}
+Για τον προγραμματισμό και εκτέλεση των μεθόδων της παρούσας εργασίας έγινε χρήση της MATLAB.
+Στον κατάλογο \textbf{scripts}, περιέχονται όλες οι μέθοδοι με τη μορφή συναρτήσεων καθώς και scripts που τις καλούν.
+Το κεντρικό script που εκτελεί τον κώδικα όλης της εργασίας είναι το \textbf{Work1.m}.
+Στην παρούσα εργασία η υλοποίηση του κώδικα δεν ακολουθεί επακριβώς τη ροή των θεμάτων της εκφώνησης.
+Αντίθετα επιλέχθηκε μια διαφορετική προγραμματιστική προσέγγιση που ενοποιεί τα κοινά ζητούμενα από όλα τα θέματα.
+Πιο συγκεκριμένα.
+
+\subsection{Πολυμορφική κλήση μεθόδων}
+Εφόσον για κάθε θέμα ένα από τα ζητούμενα ήταν ο υπολογισμός και η απεικόνιση του αριθμού των κλήσεων των μεθόδων για διαφορετικές τιμές της παραμέτρου lambda, δημιουργήσαμε μία συνάρτηση (iterations\_over\_lambda()) η οποία καλεί μια \textit{δοθείσα} μέθοδο για κάθε μία από τις αντικειμενικές συναρτήσεις και απεικονίζει τα αποτελέσματα.
+Ομοίως, για κάθε θέμα, ζητούμενο ήταν η απεικόνιση της σύγκλισης των διαστημάτων σε κάθε επανάληψη.
+Αντίστοιχα λοιπόν δημιουργήσαμε μια συνάρτηση (interval\_over\_iterations()) η οποία ομοίως καλεί μια \textit{δοθείσα} μέθοδο για κάθε μία από τις αντικειμενικές συναρτήσεις.
+Τέλος το κεντρικό script της εργασίας (Work1.m) καλεί σε βρόχο την κάθε μία από τις παραπάνω συναρτήσεις, για κάθε μία από τις μεθόδους, την οποία και περνάει ως όρισμα στη συνάρτηση.
+\par
+Οι παραπάνω συναρτήσεις λοιπόν, δέχονται τις μεθόδους ως ορίσματα και τις καλούν με αγνωστικιστικό τρόπο εσωτερικά.
+Για το λόγο αυτό υλοποιήσαμε τις μεθόδους ώστε να έχουν \textbf{κοινό interface} ορισμάτων και επιστροφών, με αποτέλεσμα κάποιες μέθοδοι να έχουν ορίσματα που δεν χρησιμοποιούνται.
+Το κέρδος όμως είναι ο πολυμορφικός τρόπος κλήσης των διαφορετικών μεθόδων, που απλοποιεί και μικραίνει τον κώδικα. \\
+Έτσι όλες οι συναρτήσεις που υλοποιούν κάποια μέθοδο υπολογισμού ελαχίστου έχουν ως ορίσματα:
+\begin{itemize}
+    \item \textbf{fun\_expr}: Η αναπαράστηαση της αντικειμενικής συνάρτησης ως symbolic expression.
+    \item \textbf{alpha}: Η αρχή του διαστήματος αναζήτησης.
+    \item \textbf{beta}: Το τέλος του διαστήματος αναζήτησης.
+    \item \textbf{epsilon}: Η απόσταση από το μέσω του διαστήματος για τη μέθοδο της διχοτόμου και το μήκος του διαστήματος του τελικού βήματος για τη μέθοδο fibonacci. \\
+            \textit{\underline{Σημείωση}}: Στις υπόλοιπες μεθόδους το όρισμα δεν χρησιμοποιείται.
+    \item \textbf{lambda}: Η ζητούμενη ακρίβεια.
+\end{itemize}
+Επίσεις όλες οι συναρτήσεις επιστρέφουν \textbf{[a, b, k, n]}:
+\begin{itemize}
+    \item \textbf{a}: Το διάνυσμα με όλες τις τιμές που παίρνει η αρχή του διαστήματος αναζήτησης σε κάθε επανάληψη.
+    \item \textbf{b}: Το διάνυσμα με όλες τις τιμές που παίρνει το τέλος του διαστήματος αναζήτησης σε κάθε επανάληψη.
+    \item \textbf{k}: Ο αριθμός των επαναλήψεων μέχρι να τερματιστεί ο αλγόριθμος.
+    \item \textbf{n}: Ο αριθμός των κλήσεων της αντικειμενικής συνάρτησης.
+\end{itemize}
+
+\subsection{Symbolic sxpression functions}
+Μία ακόμη προγραμματιστική τεχνική που ακολουθήθηκε είναι η χρήση \textbf{symbolic expression} για την αναπαράσταση των διαφορετικών αντικειμενικών συναρτήσεων.
+Ο λόγος που επιλέχθηκε είναι η \textbf{δυνατότητα εξαγωγής ενός symbolic expression που αναπαριστά την παράγωγο μιας συνάρτησης} από την MATLAB, κάνοντας χρήση της εντολής diff().
+Αν αντίθετα χρησιμοποιούσαμε απλές συναρτήσεις, πολυώνυμα ή lambdas για την αναπαράσταση των αντικειμενικών συναρτήσεων, τότε για τον υπολογισμό της παραγώγου θα έπρεπε:
+\begin{itemize}
+    \item Είτε να υπολογίζαμε αριθμητικά την παράγωγο μέσα στη μέθοδο της διχοτόμου, κάτι που θα εισήγαγε \textit{\textbf{αχρείαστο αριθμητικό σφάλμα}}.
+    \item Είτε να κάναμε χρήση τριών επιπλέων συναρτήσεων (ή πολυωνύμων) για την αναπαράσταση των παραγώγων των αντικειμενικών συναρτήσεων, κάτι που ουσιαστικά θα δημιουργούσε \textit{\textbf{πλεονασμό πληροφορίας}}.
+\end{itemize}
+Η αναπαράσταση όμως με χρήση symbolic expression είναι πιο “βαριά” όταν χρειάζεται να υπολογίσουμε την τιμή μιας συνάρτησης σε κάποιο σημείο (subs(expr, number)).
+Αυτό είναι κάτι που χρειάζεται εκτενώς στον κώδικά μας.
+Για το λόγο αυτό, ενώ οι συναρτήσεις δύνονται ως symbolic expressions, εσωτερικά στις μεθόδους και όταν πρέπει να καλεστούν, μετατρέπονται σε MATLAB callable functions.
+Έτσι έχουμε την ακριβή αναπαράσταση της παραγώγου ως συνάρτηση χωρίς να πληρώνουμε το κόστος της subs().
+
+\section{Μέθοδος της διχοτόμου}
+Η μέθοδος της διχοτόμου βρίσκει το τοπικό ελάχιστο μιας κυρτής συνάρτησης στο διάστημα $[a,b]$ \textbf{μειώνοντας διαδοχικά το εύρος του διαστήματος αναζήτησης}.
+Αντί να διχοτομεί το διάστημα αυστηρά στο μέσο του, η μέθοδος αξιολογεί τη συνάρτηση σε δύο σημεία συμμετρικά γύρω από το μέσο και πολύ κοντά σε αυτό.
+Με τον τρόπο αυτό \textbf{υπολογίζει έμμεσα την κλίση της συνάρτησης} κοντά στο μέσο.
+Αν η κλίση είναι θετική, τότε το διάστημα αναζήτησης περιορίζεται στο αριστερό μισό.
+Διαφορετικά περιορίζεται στο δεξί.
+Αυτή η διαδικασία επαναλαμβάνεται μέχρι το μήκος του διαστήματος να γίνει μικρότερο από μια προκαθορισμένη ακρίβεια $\lambda$.
+\par
+Η μέθοδος στηρίζεται στην κυρτότητα της συνάρτησης, η οποία διασφαλίζει ότι το ελάχιστο βρίσκεται πάντα σε ένα από τη δύο μισά διαστήματα, καθώς οι κυρτές συναρτήσεις έχουν \textbf{μοναδικό τοπικό και ολικό ελάχιστο σε ένα κλειστό διάστημα}.
+\par\textbf{\underline{Κριτήρια Σύγκλισης}}
+\par
+Η σύγκλιση της μεθόδου καθορίζεται από δύο βασικά κριτήρια:
+\boldmath
+\begin{enumerate}
+    \item \textbf{Απαιτούμενη ακρίβεια ($\lambda$)}: Η διαδικασία σταματά όταν το μήκος του διαστήματος γίνει μικρότερο από $\lambda$.
+    \item \textbf{Αριθμός επαναλήψεων/κλήσεων της αντικειμενικής συνάρτησης:} Ο μέγιστος αριθμός επαναλήψεων $k$ εξαρτάται από το αρχικό μήκος του διαστήματος $[a,b]$, την ακρίβεια $\lambda$ και την απόσταση των συμμετρικών σημείων από το μέσο $\epsilon$.
+    Ο αριθμός των κλήσεων της αντικειμενικής συνάρτησης είναι πάντα $n = 2k$.
+    Ο αριθμός ικανοποιεί την σχέση:
+    \begin{equation} \label{eq:1}
+        n \geq 2 \cdot log_2{\frac{b-a}{\lambda - 2\epsilon}}
+    \end{equation} \\[1ex]
+    Από την παραπάνω σχέση επίσης μπορούμε να παρατηρήσουμε ότι για τιμές \textbf{$\epsilon \geq \frac{\lambda}{2}$} η μέθοδος \textbf{αποκλίνει} και κοντά στο $\frac{\lambda}{2}$ οι κλήσεις αυξάνονται σημαντικά.
+\end{enumerate}
+\unboldmath
+
+\subsection{Υλοποίηση}
+Για τη μέθοδο της διχοτόμου υλοποιήσαμε την συνάρτηση min\_bisection().
+Η συνάρτηση αυτή δέχεται τα ορίσματα που περιγράφονται παραπάνω: \textbf{fun\_expr, alpha, beta, epsilon και lambda} και επιστρέφει τα διαστήματα αναζήτησης \textbf{a} και \textbf{b}, τον αριθμό των επαναλήψεων \textbf{k} καθώς και τον αριθμό των κλήσεων της αντικειμενικής συνάρτησης \textbf{n}.
+Η συνάρτηση καλείται από τις:
+\begin{itemize}
+    \item \textbf{bisection\_over\_epsilon()}: \\
+    Εδώ κρατάμε σταθερό το $\lambda = 0.01$ και καλούμε τη μέθοδο για διαφορετικές τιμές του $\epsilon \in [0.0001, \frac{\lambda}{2}-0.0001]$, για κάθε μία από τις συναρτήσεις $f_1, f_2, f_3$ μελετώντας τον αριθμό των κλήσεων.
+    Παρατηρούμε πως κοντά στο $\frac{\lambda}{2}$ οι κλήσεις αυξάνονται κάτι που επιβεβαιώνει και τη σχέση \ref{eq:1}. \\
+    \includegraphics[width=\textwidth]{../scripts/figures/iter_over_epsilon_min_bisection.png}
+    \captionof{figure}{Κλήσεις της αντικειμενικής συνάρτησης για διάφορα $\epsilon$.}
+    \label{fig:iter_over_epsilon_bisection}
 
+    \item \textbf{iterations\_over\_lambda()}: \\
+    Εδώ κρατάμε σταθερό το $\epsilon = 0.001$ και καλούμε τη μέθοδο για διαφορετικές τιμές του $\lambda \in [2\epsilon+0.0001, 0.1]$, για κάθε μία από τις συναρτήσεις $f_1, f_2, f_3$ μελετώντας τον αριθμό των κλήσεων.
+    Ομοίως οι κλήσεις αυξάνονται καθώς το $\lambda$ γίνεται μικρότερο επιβεβαιώνοντας τη σχέση \ref{eq:1}. \\
+    Η αρχή του διαστήματος επιλέχθηκε ώστε να ικανοποιούνται τα κριτήρια σύγκλισης. \\
+    \includegraphics[width=\textwidth]{../scripts/figures/iter_over_lambda_min_bisection.png}
+    \captionof{figure}{Κλήσεις της αντικειμενικής συνάρτησης για διάφορα $\lambda$.}
+    \label{fig:iter_over_lambda_bisection}
+
+    \item \textbf{interval\_over\_iterations()}: \\
+    Εδώ κρατάμε σταθερό το $\epsilon = 0.001$ και καλούμε τη μέθοδο για τρεις διαφορετικές τιμές του $\lambda \in \{2\epsilon+0.0001, \frac{2\epsilon+0.0001}{2}, 0.1\}$, για κάθε μία από τις συναρτήσεις $f_1, f_2, f_3$ μελετώντας τη σύγκλιση του διαστήματος αναζήτησης σε σχέση με τον αριθμό των επαναλήψεων. \\
+    \includegraphics[width=\textwidth]{../scripts/figures/interval_over_iterations_min_bisection_fun1.png}
+    \captionof{figure}{Σύγκλιση του $[a_k, b_k]$ για την $f_1$ για 3 τιμές του $\lambda$.}
+    \label{fig:interval_over_iter_bisection_fun1}
+
+    \includegraphics[width=\textwidth]{../scripts/figures/interval_over_iterations_min_bisection_fun2.png}
+    \captionof{figure}{Σύγκλιση του $[a_k, b_k]$ για την $f_2$ για 3 τιμές του $\lambda$.}
+    \label{fig:interval_over_iter_bisection_fun2}
+
+    \includegraphics[width=\textwidth]{../scripts/figures/interval_over_iterations_min_bisection_fun3.png}
+    \captionof{figure}{Σύγκλιση του $[a_k, b_k]$ για την $f_3$ για 3 τιμές του $\lambda$.}
+    \label{fig:interval_over_iter_bisection_fun3}
+\end{itemize}
+
+\subsection{Παρατηρήσεις}
+Η μέθοδος της διχοτόμου έχει χαρακτηριστικά που την καθιστούν απλή και σταθερή για εύρεση του ελαχίστου.
+Μερικές παρατηρήσεις που σχετίζονται με την μέθοδο:
+\begin{itemize}
+    \item \textbf{Ταχύτητα σύγκλησης}:
+    Η μέθοδος της διχοτόμου έχει λογαριθμική ταχύτητα σύγκλισης.
+    Σε κάθε βήμα μειώνουμε το μήκος του διαστήματος κατά το μισό.
+    Ειδικότερα, η χρονική πολυπλοκότητα της είναι $O(log_2(\frac{b-a}{\lambda}))$, κάτι που επιβεβαιώνεται από τα διαγράμματα και από την έξοδο του MATLAB script.
+
+    \item \textbf{Σχέση αριθμού κλήσεων - ακρίβειας}:
+    Ο αριθμός των κλήσεων της συνάρτησης σχετίζεται με την απαιτούμενη ακρίβεια, καθώς η κάθε επανάληψη απαιτεί δύο αξιολογήσεις της συνάρτησης.
+    Συνεπώς, ο συνολικός αριθμός των κλήσεων είναι \textbf{διπλάσιος} του αριθμού των επαναλήψεων.
+
+    \item \textbf{Σταθερότητα}:
+    Η μέθοδος της διχοτόμου είναι εξαιρετικά σταθερή για κυρτές συναρτήσεις.
+    Εφόσον η συνάρτηση είναι συνεχής και κυρτή στο διάστημα $[a, b]$ η μέθοδος θα συγκλίνει πάντα προς ένα σημείο στο διάστημα αυτό, ανεξαρτήτως της μορφής της συνάρτησης.
+    Αυτό φαίνεται τόσο από την εξίσωση \ref{eq:1} η οποία δείχνει εξάρτηση του αριθμού των κλήσεων μόνο από το διάστημα, αναζήτησης, το $\lambda$ και το $\epsilon$.
+    Όσο και από τις μετρήσεις και τα διαγράμματα, όπου ο αριθμός κλήσεων για δεδομένα $\epsilon$ και $\lambda$ παραμένει αμετάβλητος για οποιαδήποτε συνάρτηση.
+\end{itemize}
+
+\section{Μέθοδος του χρυσού τομέα}
+\section{Μέθοδος Fibonacci}
+\section{Μέθοδος της διχοτόμου με χρήση παραγώγου}
+
+% Μετρικές: Αρ. κλήσεων, code complexity, arythetic stability, ...
+% Πίνακας σύγκρισης
+% trade-off επιλογή με βάση κριτηρίων
+\section{Σύγκριση των μεθόδων}
+
+%
+\section{Συμπεράσματα}
 
 
 \end{document}

Work 1/scripts/Work1.m

@@ -1,10 +1,11 @@
 %
+% The main script for the assignment.
+% * Calls the bisection method for different epsilon values (Question 1)
+% * Calls every method for different lambda values, in order to plot
+%   the iterations needed. (All questions, part A)
+% * Calls every method for 3 different lambda values, in order to plot
+%   the [a, b] convergence. (All questions part B)
 %
-%
-%
-%
-%
-
 
 disp (" ");
 disp (" ");

Work 1/scripts/bisection_over_epsilon.m

@@ -1,6 +1,6 @@
 %
-% Keeping lambda (accuracy) fixed, test the iteration needed for different
-% epsilon values.
+% Calculate and plot the iteration needed for different epsilon values,
+% keeping lambda (accuracy) fixed.
 %
 
 
@@ -26,6 +26,7 @@ lambda = 0.01;
 de = 0.0001;
 epsilon = linspace(de, (lambda/2)-de, N);
 k = zeros(1,N); % preallocate k
+n = zeros(1,N); % preallocate n
 
 
 %
@@ -39,15 +40,15 @@ set(gcf, 'Position', [100, 100, 1280, 600]); % Set the figure size to HD
 
 for i = 1:length(funs)
     for j = 1:N
-        [a, b, k(j)] = min_bisection(funs(i), a_0, b_0, epsilon(j), lambda);
+        [a, b, k(j), n(j)] = min_bisection(funs(i), a_0, b_0, epsilon(j), lambda);
     end
-    fprintf('%20s(%34s ):  [a, b]= [%f, %f], iterations(min, max)= (%d, %d)\n', ...
-            "min_bisection", char(funs(i)), a(end), b(end), k(1), k(N) );
-    subplot(1, length(funs), i)
-    plot(epsilon, k, '-b', 'LineWidth', 1.0)
-    title(titles(i), 'Interpreter', 'latex')
-    xlabel('epsilon')
-    ylabel('Iterations')
+    fprintf('%20s(%34s ):  [a, b]= [%f, %f], iters(min, max)= (%d, %d), calls(min, max)= (%d, %d)\n', ...
+            "min_bisection", char(funs(i)), a(end), b(end), k(1), k(N), n(1), n(N) );
+    subplot(1, length(funs), i);
+    plot(epsilon, n, '-b', 'LineWidth', 1.0);
+    title(titles(i), 'Interpreter', 'latex', 'FontSize', 16);
+    xlabel('epsilon');
+    ylabel("Calls of f" + i);
 end
 
 %
@@ -59,4 +60,5 @@ fig_png  = fullfile(fig_dir, "iter_over_epsilon_min_bisection" + ".png");
 %print(gcf, fig_epsc, '-depsc', '-r300');
 print(gcf, fig_png, '-dpng', '-r300');
 
-    
+close(gcf);
+

Work 1/scripts/interval_over_iterations.m

@@ -1,12 +1,15 @@
 function [] = interval_over_iterations(method)
-% Plot the [a,b] interval over the iterations for different lambda
-% values (min, mid, max))
+% Calculate and plot the [a,b] interval over the iterations for different
+% lambda values (min, mid, max)
 %
-% method: the minimum calculation method
+% method: the minimum calculation method, one of:
 %       * bisections
 %       * golden_section
 %       * fibonacci
 %       * bisection_der
+% return:
+%       none
+%
 
 
 % Load the functions and interval
@@ -22,7 +25,7 @@ end
 %
 % We need to test against the same lambda values for all the methods in
 % order to compare them. And since epsilon (which is related to lambda)
-% was given for bisection method, we base our calculations to that.
+% was given for the bisection method, we base our calculations to that.
 %
 %
 % epsilon: e = 0.001
@@ -37,6 +40,7 @@ lambda_min = 0.0021;
 lambda_max = 0.1;
 lambda = linspace(lambda_min, lambda_max, N);
 k = zeros(1, N); % preallocate k
+n = zeros(1, N); % preallocate n
 
 
 %
@@ -56,20 +60,20 @@ for i = 1:length(funs)
     figure('Name', "interval_over_iterations_" + char(method) + "_fun" + i, 'NumberTitle', 'off');
     set(gcf, 'Position', [100, 100, 1280, 720]); % Set the figure size to HD
     for j = 1:N
-        [a, b, k(j)] = method(funs(i), a_0, b_0, epsilon, lambda(j));
+        [a, b, k(j), n(j)] = method(funs(i), a_0, b_0, epsilon, lambda(j));
         
         fprintf('%20s(%34s ):  [a, b]= [%f, %f], @lambda=%f, iterations= %d\n', ...
             char(method), char(funs(i)), a(end), b(end), lambda(j), k(j) );
         
-        subplot(length(funs), 1, j)
-        plot(1:length(a), a, 'ob')
+        subplot(length(funs), 1, j);
+        plot(1:length(a), a, 'ob');
         hold on
-        plot(1:length(b), b, '*r')
+        plot(1:length(b), b, '*r');
         if j == 1
-            title(titles(i), 'Interpreter', 'latex')
+            title(titles(i), 'Interpreter', 'latex', 'FontSize', 16);
         end
-        xlabel("Iterations @lambda=" + lambda(j))
-        ylabel('[a_k, b_k]')
+        xlabel("Iterations @lambda=" + lambda(j));
+        ylabel('[a_k, b_k]');
     end
     
     % Print and save the figure
@@ -78,5 +82,7 @@ for i = 1:length(funs)
 
     %print(gcf, fig_epsc, '-depsc', '-r300');
     print(gcf, fig_png, '-dpng', '-r300');
+    
+    close(gcf);
 end
 

Work 1/scripts/iterations_over_lambda.m

@@ -1,12 +1,14 @@
 function [] = iterations_over_lambda(method)
-% Plot iteration needed for different lambda values.
-%
+% Calculate and plot iteration needed for different lambda values.
 %
 % method: the minimum calculation method
 %       * bisections
 %       * golden_section
 %       * fibonacci
 %       * bisection_der
+% return:
+%       none
+%
 
 
 % Load the functions and interval
@@ -22,7 +24,7 @@ end
 %
 % We need to test against the same lambda values for all the methods in
 % order to compare them. And since epsilon (which is related to lambda)
-% was given for bisection method, we base our calculations to that.
+% was given for the bisection method, we base our calculations to that.
 %
 %
 % epsilon: e = 0.001
@@ -37,6 +39,7 @@ lambda_min = 0.0021;
 lambda_max = 0.1;
 lambda = linspace(lambda_min, lambda_max, N);
 k = zeros(1, N); % preallocate k
+n = zeros(1, N); % preallocate n
 
 
 %
@@ -56,16 +59,16 @@ set(gcf, 'Position', [100, 100, 1280, 600]); % Set the figure size to HD
 disp(" ");
 for i = 1:length(funs)
     for j = N:-1:1
-        [a, b, k(j)] = method(funs(i), a_0, b_0, epsilon, lambda(j));
+        [a, b, k(j), n(j)] = method(funs(i), a_0, b_0, epsilon, lambda(j));
     end
 
-    fprintf('%20s(%34s ):  [a, b]= [%f, %f], iterations(min, max)= (%d, %d)\n', ...
-            char(method), char(funs(i)), a(end), b(end), k(N), k(1) );
-    subplot(1, length(funs), i)
-    plot(lambda, k, '-b', 'LineWidth', 1.0)
-    title(titles(i), 'Interpreter', 'latex')
-    xlabel('lambda')
-    ylabel('Iterations')
+    fprintf('%20s(%34s ):  [a, b]= [%f, %f], iters(min, max)= (%d, %d), calls(min, max)= (%d, %d)\n', ...
+            char(method), char(funs(i)), a(end), b(end), k(N), k(1), n(N), n(1) );
+    subplot(1, length(funs), i);
+    plot(lambda, n, '-b', 'LineWidth', 1.0);
+    title(titles(i), 'Interpreter', 'latex', 'FontSize', 16);
+    xlabel('lambda');
+    ylabel("Calls of f" + i);
 end
 
 
@@ -78,6 +81,6 @@ fig_png  = fullfile(fig_dir, "iter_over_lambda_" + char(method) + ".png");
 %print(gcf, fig_epsc, '-depsc', '-r300');
 print(gcf, fig_png, '-dpng', '-r300');
 
-
+close(gcf);
 
   

Work 1/scripts/min_bisection.m

@@ -1,18 +1,31 @@
-function [a, b, k] = min_bisection(fun_expression, alpha, beta, epsilon, lambda)
+function [a, b, k, n] = min_bisection(fun_expr, alpha, beta, epsilon, lambda)
+% Bisection method for finding the local minimum of a function.
 %
-% Detailed explanation goes here
+% fun_expr: (symbolic expression over x) The symbolic expression of the
+%           objective function
+% alpha:    (number) The starting point of the interval in which we seek
+%           for minimum
+% beta:     (number) The ending point of the interval in which we seek
+%           for minimum
+% epsilon:  (number) The epsilon value (distance from midpoint)
+% lambda:   (number) The lambda value (accuracy)
 %
+% return:
+%  a:       (vector) Starting points of the interval for each iteration
+%  b:       (vector) Ending points of the interval for each iteration
+%  k:       (number) The number of iterations
+%  n:       (number) The calls of objective function fun_expr
 %
 
 % Error checking
-if 2*epsilon >= lambda || lambda <= 0
-    error ('Convergence criteria not met')
+if alpha > beta || 2*epsilon >= lambda || lambda <= 0
+    error ('Input criteria not met')
 end
 
 % Init
 a = alpha;
 b = beta;
-fun = matlabFunction(fun_expression);
+fun = matlabFunction(fun_expr);
 
 k=1;
 
@@ -31,4 +44,7 @@ while b(k) - a(k) > lambda
         a(k) = x_1;
         b(k) = b(k-1);
     end
-end
+end
+
+% Set objective function calls
+n = 2*k;

Work 1/scripts/min_bisection_der.m

@@ -1,12 +1,29 @@
-function [a, b, k] = min_bisection_der(fun_expression, alpha, beta, epsilon, lambda)
+function [a, b, k, n] = min_bisection_der(fun_expression, alpha, beta, epsilon, lambda)
+% Bisection using derivatives method for finding the local minimum of a
+% function.
 %
-% Detailed explanation goes here
+% fun_expr: (symbolic expression over x) The symbolic expression of the
+%           objective function
+% alpha:    (number) The starting point of the interval in which we seek
+%           for minimum
+% beta:     (number) The ending point of the interval in which we seek
+%           for minimum
+% epsilon:  (number) The epsilon value
+%           **note:**
+%             epsilon in not used in this method, but it is part of the
+%             method calling interface.
+% lambda:   (number) The lambda value (accuracy)
 %
+% return:
+%  a:       (vector) Starting points of the interval for each iteration
+%  b:       (vector) Ending points of the interval for each iteration
+%  k:       (number) The number of iterations
+%  n:       (number) The calls of objective function fun_expr
 %
 
 % Error checking
-if lambda <= 0
-    error ('Convergence criteria not met')
+if alpha > beta || lambda <= 0
+    error ('Input criteria not met')
 end
 
 % Init output vectors
@@ -33,4 +50,8 @@ while b(k) - a(k) > lambda
         b(k) = x_mid;
         break;
     end
-end
+end
+
+% Update the objctive function calls. In this case the derivative of the
+% function ;)
+n = k;

Work 1/scripts/min_fibonacci.m

@@ -1,22 +1,38 @@
-function [a, b, N] = min_fibonacci(fun_expression, alpha, beta, epsilon, lambda)
+function [a, b, N, nn] = min_fibonacci(fun_expression, alpha, beta, epsilon, lambda)
+% Fibonacci method for finding the local minimum of a function.
 %
+% fun_expr: (symbolic expression over x) The symbolic expression of the
+%           objective function
+% alpha:    (number) The starting point of the interval in which we seek
+%           for minimum
+% beta:     (number) The ending point of the interval in which we seek
+%           for minimum
+% epsilon:  (number) The epsilon value (the interval of the last step)
+% lambda:   (number) The lambda value (accuracy)
+%
+% return:
+%  a:       (vector) Starting points of the interval for each iteration
+%  b:       (vector) Ending points of the interval for each iteration
+%  N:       (number) The number of iterations needed.
+%  nn:      (number) The calls of objective function fun_expr
+%
+
+% Error checking
+if alpha > beta || lambda <= 0 || epsilon <= 0
+    error ('Input criteria not met')
+end
 
 % Use Binet's formula instead of matlab's recursive fibonacci
 % implementation
 fibonacci = @(n) ( ((1 + sqrt(5))^n - (1 - sqrt(5))^n) / (2^n * sqrt(5)) );
 
-% Error checking
-if lambda <= 0 || epsilon <= 0
-    error ('Convergence criteria not met')
-end
-
 % Init variables
 a = alpha;
 b = beta;
 fun = matlabFunction(fun_expression);
 
 % calculate number of iterations
-N=0;
+N = 0;
 while fibonacci(N) < (b(1) - a(1)) / lambda
     N = N + 1;
 end
@@ -52,3 +68,7 @@ else
     a(N) = x_1;
     b(N) = b(N-1);
 end
+
+% Set objective function calls
+nn = 2*N -2;
+

Work 1/scripts/min_golden_section.m

@@ -1,10 +1,28 @@
-function [a, b, k] = min_golden_section(fun_expression, alpha, beta, epsilon, lambda)
+function [a, b, k, n] = min_golden_section(fun_expression, alpha, beta, epsilon, lambda)
+% Golden section method for finding the local minimum of a function.
+%
+% fun_expr: (symbolic expression over x) The symbolic expression of the
+%           objective function
+% alpha:    (number) The starting point of the interval in which we seek
+%           for minimum
+% beta:     (number) The ending point of the interval in which we seek
+%           for minimum
+% epsilon:  (number) The epsilon value
+%           **note:**
+%             epsilon in not used in this method, but it is part of the
+%             method calling interface.
+% lambda:   (number) The lambda value (accuracy)
+%
+% return:
+%  a:       (vector) Starting points of the interval for each iteration
+%  b:       (vector) Ending points of the interval for each iteration
+%  k:       (number) The number of iterations
+%  n:       (number) The calls of objective function fun_expr
 %
-
 
 % Error checking
-if lambda <= 0
-    error ('Convergence criteria not met')
+if alpha > beta || lambda <= 0
+    error ('Input criteria not met')
 end
 
 % Init variables
@@ -19,18 +37,28 @@ k=1;
 x_1 = a(k) + (1 - gamma)*(b(k) - a(k));
 x_2 = a(k) + gamma*(b(k) - a(k));
 
+f1 = fun(x_1);
+f2 = fun(x_2);
 while b(k) - a(k) > lambda    
     % set new search interval
     k = k + 1;
-    if fun(x_1) < fun(x_2)
+    if f1 < f2
         a(k) = a(k-1);
         b(k) = x_2;
         x_2 = x_1;
+        f2 = f1;
         x_1 = a(k) + (1 - gamma)*(b(k) - a(k));
+        f1 = fun(x_1);
     else
         a(k) = x_1;
         b(k) = b(k-1);
         x_1 = x_2;
+        f1 = f2;
         x_2 = a(k) + gamma*(b(k) - a(k));
+        f2 = fun(x_2);
     end
 end
+
+% Set objective function calls
+n = k+1;
+