part_4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 4\n",
    "In questa esercitazione si effettua una sperimentazione numerica relativa ai metodi per il calcolo di zeri di funzione. Sarà necessario impiegare il calcolo simbolico."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "pkg load symbolic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Metodo di bisezione\n",
    "\n",
    "    [sol, appr, nit] = bisection(fun, a, b, tolx)\n",
    "\n",
    "Input:\n",
    "- `fun`: funzione di cui si calcola lo zero,\n",
    "- `a`, `b`: estremi dell'intervallo in cui avviene la ricerca dello zero,\n",
    "- `tolx`: tolleranza.\n",
    "\n",
    "Output:\n",
    "- `sol`: miglior approssimazione dello zero di funzione trovata,\n",
    "- `appr`: vettore contenente tutte le approssimazioni calcolate,\n",
    "- `nit`: numero di iterazioni impiegate per arrivare alla soluzione."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "function [sol, appr, nit] = bisection(fun, a, b, tolx)\n",
    "\n",
    "fun_a = fun(a);\n",
    "fun_b = fun(b);\n",
    "\n",
    "if(sign(fun(a)) == sign(fun(b)))\n",
    "   error(\"Teorema degli Zeri non applicabile\"); \n",
    "end\n",
    "\n",
    "nit = 0;\n",
    "exit = 0;\n",
    "maxit = ceil((log(fun_b - fun_a) / tolx) / log(2));\n",
    "appr = zeros(1, 10); % preallocazione\n",
    "\n",
    "while exit == 0 && nit <= maxit ...\n",
    "    && abs(b - a) >= tolx + eps * max(abs(a), abs(b))\n",
    "    \n",
    "    nit = nit + 1;\n",
    "    appr(nit) = a + (b - a) / 2; % ascissa\n",
    "    fun_app = fun(appr(nit)); % ordinata\n",
    "    \n",
    "    if(sign(fun_app)) == sign(fun_a) % sposto a verso destra\n",
    "        a = appr(nit);\n",
    "        fun_a = fun_app;\n",
    "    elseif(sign(fun_app) == sign(fun_b)) % sposto b verso sinistra\n",
    "        b = appr(nit);\n",
    "        fun_b = fun_app;\n",
    "    end\n",
    "    \n",
    "    if(fun(appr) == 0)\n",
    "        exit = 1;\n",
    "    end\n",
    "end\n",
    "\n",
    "sol = appr(nit);\n",
    "\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Metodo della regula falsi\n",
    "\n",
    "    sol, appr, nit] = regula_falsi(fun, a, b, tolx, maxit)\n",
    "\n",
    "Input:\n",
    "- `fun`: funzione di cui si calcola lo zero,\n",
    "- `a`, `b`: estremi dell'intervallo in cui avviene la ricerca dello zero,\n",
    "- `tolx`: tolleranza,\n",
    "- `maxit`: numero massimo di iterazioni consentite.\n",
    "\n",
    "Output:\n",
    "- `sol`: miglior approssimazione dello zero di funzione trovata,\n",
    "- `appr`: vettore contenente tutte le approssimazioni calcolate,\n",
    "- `nit`: numero di iterazioni impiegate per arrivare alla soluzione."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "source": [
    "    By chance to truth you may procede,\n",
    "    And first work by the question,\n",
    "    Although no truth therein be done.\n",
    "    Such falsehood is a so good ground,\n",
    "    That truth by it will soon be found.\n",
    "\n",
    "Ground of Artes, di Robert Recorde (ca. 1542). Estratto da [qui](https://en.wikipedia.org/wiki/Regula_falsi)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "function [sol, appr, nit] = regula_falsi(fun, a, b, tolx, maxit)\n",
    "\n",
    "% valutazione agli estremi\n",
    "fun_a = fun(a);\n",
    "fun_b = fun(b);\n",
    "\n",
    "if(sign(fun_a) == sign(fun_b))\n",
    "   disp(\"Teorema degli Zeri non applicabile\") \n",
    "   sol = 0;\n",
    "   appr = [];\n",
    "   nit = 0;\n",
    "   return\n",
    "end\n",
    "\n",
    "nit = 0;\n",
    "exit = 0;\n",
    "fun_app = fun_a;\n",
    "appr = zeros(1, 10);\n",
    "\n",
    "% due criteri di arresto, uno sul massimo numero di iterazioni,\n",
    "% l'altro sul controllo di |tol|, considerando |eps|\n",
    "while exit == 0 && nit <= maxit ...\n",
    "    && abs(b - a) >= tolx + eps * max(abs(a), abs(b))\n",
    "    %%&& abs(fun_app) >= tolx\n",
    "\n",
    "    nit = nit + 1;\n",
    "    \n",
    "    % calcolo intersezione con l'asse x della retta che\n",
    "    % congiunge gli estremi a e b\n",
    "    appr(nit) = a - fun_a * (b - a) / (fun_b - fun_a);\n",
    "    fun_app = fun(appr(nit));\n",
    "    \n",
    "    if(fun_app == 0) % lo zero è stato trovato\n",
    "        exit = 1;\n",
    "    end\n",
    "    \n",
    "    % aggiornamento sotto-intervallo di sinistra\n",
    "    if(sign(fun_app) == sign(fun_a)) \n",
    "        a = appr(nit);\n",
    "        fun_a = fun_app;\n",
    "    % aggiornamento sotto-intervallo di destra\n",
    "    elseif(sign(fun_app) == sign(fun_b))\n",
    "        b = appr(nit);\n",
    "        fun_b = fun_app;\n",
    "    end    \n",
    "end\n",
    "\n",
    "if(nit == maxit)\n",
    "   disp(\"Raggiunto il massimo numero di iterazioni\") \n",
    "end\n",
    "\n",
    "% l'ultima approssimazione è la migliore soluzione \n",
    "% a cui si è giunti in maxit\n",
    "sol = appr(nit);\n",
    "\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Metodo delle corde\n",
    "\n",
    "Calcola lo zero di una funzione usando il metodo delle corde. A differenza del metodo delle tangenti la pendenza è costante. Richiede il calcolo della derivata della funzione di cui si vuole trovare lo zero.\n",
    "\n",
    "    [sol, appr, nit] = chords(fun, fun_der, x_i, tolx, tolf, maxit)\n",
    "\n",
    "Input:\n",
    "- `fun`, `fun_der`: funzione di cui si calcola lo zero e sua derivata prima,\n",
    "- `x_i`: punto di innesco,\n",
    "- `tolx`: tolleranza,\n",
    "- `tolf`: tolleranza,\n",
    "- `maxit`: numero massimo di iterazioni consentite.\n",
    "\n",
    "Output:\n",
    "- `sol`: miglior approssimazione dello zero di funzione trovata,\n",
    "- `appr`: vettore contenente tutte le approssimazioni calcolate,\n",
    "- `nit`: numero di iterazioni impiegate per arrivare alla soluzione."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "function [sol, appr, nit] = chords(fun, fun_der, x_i, tolx, tolf, maxit)\n",
    "\n",
    "nit = 1;\n",
    "m = fun_der(x_i); % calcolo della pendenza costante\n",
    "appr(nit) = x_i - fun(x_i) / m; % primo passo di iterazione\n",
    "fun_i = fun(appr(nit)); % prima approssimazione locale\n",
    "\n",
    "while nit < maxit && abs(fun_i / m) >= tolx * abs(appr(nit)) ...\n",
    "        && abs(fun_i) >= tolf\n",
    "    x_i = appr(nit);\n",
    "\n",
    "    temp = x_i - fun_i / m;\n",
    "    fun_i = fun(temp);\n",
    "    \n",
    "    nit = nit + 1;\n",
    "    appr(nit) = temp;\n",
    "end\n",
    "\n",
    "if(maxit == nit)\n",
    "   disp(\"Maximum number of iterations reached!\");\n",
    "end\n",
    "\n",
    "sol = appr(nit);\n",
    "\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Metodo delle tangenti\n",
    "\n",
    "Usa il metodo di Newton per calcolare lo zero di una funzione. A differenza del metodo delle secanti si ricalcola la pendenza ad ogni iterazione. Richiede il calcolo della derivata della funzione di cui si vuole trovare lo zero.\n",
    "\n",
    "    [sol, appr, nit] = newton(fun, fun_der, x_i, tolx, tolf, maxit)\n",
    "\n",
    "Input:\n",
    "- `fun`, `fun_der`: funzione di cui si calcola lo zero e sua derivata prima,\n",
    "- `x_i`: punto di innesco,\n",
    "- `tolx`: tolleranza,\n",
    "- `tolf`: tolleranza,\n",
    "- `maxit`: numero massimo di iterazioni consentite.\n",
    "\n",
    "Output:\n",
    "- `sol`: miglior approssimazione dello zero di funzione trovata,\n",
    "- `appr`: vettore contenente tutte le approssimazioni calcolate,\n",
    "- `nit`: numero di iterazioni impiegate per arrivare alla soluzione."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "function [sol, appr, nit] = newton(fun, fun_der, x_i, tolx, tolf, maxit)\n",
    "\n",
    "m_i = fun_der(x_i); % inizializzazione della pendenza\n",
    "\n",
    "if(abs(m_i) <= eps)\n",
    "   fprintf('Derivata nulla in x_0, uscita...\\n')\n",
    "   sol = 0;\n",
    "   appr = [];\n",
    "   nit = 0;\n",
    "   return\n",
    "end\n",
    "\n",
    "temp  = x_i - fun(x_i) / m_i; % primo passo di iterazione\n",
    "fun_i = fun(temp); % prima approssimazione locale\n",
    "\n",
    "nit = 1;\n",
    "appr(nit) = temp;\n",
    "\n",
    "% tre criteri di arresto, il primo sul numero di iterazioni massime,\n",
    "% il secondo su\n",
    "while nit < maxit && abs(fun_i / m_i) >= tolx * abs(appr(nit)) ...\n",
    "    && abs(fun_i) >= tolf\n",
    "\n",
    "    x_i = appr(nit);\n",
    "\n",
    "    m_i = fun_der(x_i); % ricalcolo della pendenza\n",
    "    if(abs(m_i) <= eps)\n",
    "        fprintf('Derivata nulla in x_0, uscita...\\n')\n",
    "        sol = appr(nit);\n",
    "        return\n",
    "    end\n",
    "    \n",
    "    temp = x_i - fun_i / m_i; % calcolo nuova soluzione\n",
    "    fun_i = fun(temp); \n",
    "    \n",
    "    nit = nit + 1;\n",
    "    appr(nit) = temp;\n",
    "end\n",
    "\n",
    "if(maxit == nit)\n",
    "   disp(\"Raggiunto massimo numero iterazioni\") \n",
    "end\n",
    "\n",
    "sol = appr(nit);\n",
    "\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Metodo di Newton modificato\n",
    "\n",
    "Usa il metodo di Newton per calcolare lo zero di una funzione nel caso di radici che non sono semplici.\n",
    "\n",
    "    [sol, appr, nit] = newton_mk2(fun, fun_der, x_i, tolx, tolf, maxit, m)\n",
    "\n",
    "Input:\n",
    "- `fun`, `fun_der`: funzione di cui si calcola lo zero e sua derivata prima,\n",
    "- `x_i`: punto di innesco,\n",
    "- `tolx`: tolleranza,\n",
    "- `tolf`: tolleranza,\n",
    "- `maxit`: numero massimo di iterazioni consentite,\n",
    "- `m`: molteplicità della soluzione da trovare.\n",
    "\n",
    "Output:\n",
    "- `sol`: miglior approssimazione dello zero di funzione trovata,\n",
    "- `appr`: vettore contenente tutte le approssimazioni calcolate,\n",
    "- `nit`: numero di iterazioni impiegate per arrivare alla soluzione."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "function [sol, appr, nit] = newton_mk2(fun, fun_der, x_i, tolx, tolf, maxit, m)\n",
    "\n",
    "m_i = fun_der(x_i); % inizializzazione della pendenza\n",
    "\n",
    "if(abs(m_i) <= eps)\n",
    "   fprintf('Derivata nulla in x_0, uscita...\\n')\n",
    "   sol = 0;\n",
    "   appr = 0;\n",
    "   nit = 0;\n",
    "   return\n",
    "end\n",
    "\n",
    "temp  = x_i - m * fun(x_i) / m_i; % primo passo di iterazione\n",
    "fun_i = fun(temp); % prima approssimazione locale\n",
    "\n",
    "nit = 1;\n",
    "appr(nit) = temp;\n",
    "\n",
    "% tre criteri di arresto, il primo sul numero di iterazioni massime,\n",
    "% il secondo su\n",
    "while nit < maxit && abs(fun_i / m_i) >= tolx * abs(appr(nit)) ...\n",
    "    && abs(fun_i) >= tolf\n",
    "\n",
    "    x_i = appr(nit);\n",
    "\n",
    "    m_i = fun_der(x_i); % ricalcolo della pendenza\n",
    "    if(abs(m_i) <= eps)\n",
    "        fprintf('Derivata nulla in x_0, uscita...\\n')\n",
    "        sol = appr(nit);\n",
    "        return\n",
    "    end\n",
    "    \n",
    "    temp = x_i - m * fun_i / m_i; % calcolo nuova soluzione\n",
    "    fun_i = fun(temp); \n",
    "    \n",
    "    nit = nit + 1;\n",
    "    appr(nit) = temp;\n",
    "end\n",
    "\n",
    "if(maxit == nit)\n",
    "   disp(\"Raggiunto massimo numero iterazioni\") \n",
    "end\n",
    "\n",
    "sol = appr(nit);\n",
    "\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Metodo delle secanti\n",
    "\n",
    "Calcola lo zero di una funzione sfruttando il metodo delle secanti.\n",
    "\n",
    "    [sol, appr, nit] = secants(fun, x_i, x_j, tolx, tolf, maxit)\n",
    "\n",
    "Input:\n",
    "- `x_i`, `x_j`: punti di innesco,\n",
    "- `tolx`: tolleranza,\n",
    "- `tolf`: tolleranza,\n",
    "- `maxit`: numero massimo di iterazioni consentite.\n",
    "\n",
    "Output:\n",
    "- `sol`: miglior approssimazione dello zero di funzione trovata,\n",
    "- `appr`: vettore contenente tutte le approssimazioni calcolate,\n",
    "- `nit`: numero di iterazioni impiegate per arrivare alla soluzione."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "function [sol, appr, nit] = secants(fun, x_i, x_j, tolx, tolf, maxit)\n",
    "\n",
    "fun_i = fun(x_i);\n",
    "fun_j = fun(x_j);\n",
    "\n",
    "nit = 1;\n",
    "exit = 0;\n",
    "\n",
    "% inizializzazione tramite punti di innesco |x_i| e |y_i|\n",
    "d = (x_i - x_j) / (fun_i - fun_j);\n",
    "appr(nit) = x_i - fun_i * d;\n",
    "fun_i = fun(appr(nit));\n",
    "\n",
    "% criteri di arresto basati su |tolx|, |tolf| e |maxit|\n",
    "while exit == 0 && nit < maxit ...\n",
    "    && abs(fun_i * d) >= tolx * abs(appr(nit)) ...\n",
    "    && abs(fun_i) >= tolf\n",
    "\n",
    "    x_j = x_i;\n",
    "    x_i = appr(nit);\n",
    "\n",
    "    if(fun(x_i) == fun(x_j))\n",
    "        exit = 1;\n",
    "    end\n",
    "\n",
    "    % costruzione i-esimo passo d'iterazione\n",
    "    temp = x_i - fun(x_i) * (x_i - x_j) / (fun(x_i) - fun(x_j));\n",
    "    % approssimazione locale\n",
    "    fun_i = fun(temp); \n",
    "\n",
    "    nit = nit + 1;\n",
    "    appr(nit) = temp;\n",
    "end\n",
    "\n",
    "if(nit == maxit)\n",
    "    disp(\"Maximum number of iterations reached!\");\n",
    "end\n",
    "\n",
    "sol = appr(nit);\n",
    "\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Esercizio 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Symbolic pkg v2.9.0: Python communication link active, SymPy v1.5.\n"
     ]
    }
   ],
   "source": [
    "% funzione 1\n",
    "f1 = @(x) exp(-x) - (x + 1);\n",
    "a1 = -1;\n",
    "b1 = 2;\n",
    "tolx1 = 1.e-12;\n",
    "\n",
    "% funzione 2\n",
    "f2 = @(x) log(x + 3) / log(2) - 2;\n",
    "a2 = -1;\n",
    "b2 = 2;\n",
    "tolx2 = 1.e-12;\n",
    "\n",
    "% funzione 3\n",
    "f3 = @(x) sqrt(x) - x^2 / 4;\n",
    "a3 = 1;\n",
    "b3 = 3;\n",
    "tolx3 = 1.e-12;\n",
    "\n",
    "alfa = 0;\n",
    "nmax = 1000;\n",
    "tolf = 1.e-12;\n",
    "x_0 = -0.5;\n",
    "x_j = -0.3;\n",
    "\n",
    "% calcolo della derivata prima di |f1|\n",
    "syms x;\n",
    "fx = exp(-x) - (x + 1);\n",
    "df = function_handle(diff(fx, x, 1));\n",
    "\n",
    "%figure\n",
    "%fplot(f1, [a1, b1]);\n",
    "%title('Funzione 1');\n",
    "%box off"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calcolo degli zeri di funzione"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "[~, appr, nit] = bisection(f1, a1, b1, tolx1);\n",
    "err_ass = abs(appr - alfa);\n",
    "\n",
    "[~, appr_falsi, nit_falsi] = regula_falsi(f1, a1, b1, tolx1, nmax);\n",
    "err_ass1b = abs(appr_falsi - alfa);\n",
    "\n",
    "[~, appr_chords, nit_chords] = chords(f1, df, x_0, tolx1, tolf, nmax);\n",
    "err_ass1c = abs(appr_chords - alfa);\n",
    "\n",
    "[~, appr_tangenti, nit_tangenti] = newton(f1, df, x_0, tolx1, ...\n",
    "                                                tolf, nmax);\n",
    "err_ass1d = abs(appr_tangenti - alfa);\n",
    "\n",
    "[~, appr_secant, nit_secant] = secant(f1, x_0, x_j, tolx1, ...\n",
    "                                                tolf, nmax);\n",
    "err_ass1e = abs(appr_secant - alfa);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numero di iterazioni richieste da ciascun algoritmo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "figure\n",
    "semilogy((1:nit), err_ass, 'ro--', ...\n",
    "    (1:nit_falsi), err_ass1b, 'go--', ...\n",
    "    (1:nit_chords), err_ass1c, 'm+--', ...\n",
    "    (1:nit_tangenti), err_ass1d, 'b*--', ...\n",
    "    (1:nit_secant), err_ass1e, 'co--');\n",
    "\n",
    "xlabel(\"iterazioni\")\n",
    "ylabel(\"errore assoluto\")\n",
    "legend(\"bisection\", \"regula falsi\", \"chords\", \"tangenti\", \"secant\");\n",
    "box off\n",
    "warning (\"off\", \"Octave:negative-data-log-axis\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Stima dell'ordine di convergenza per ciascun algoritmo\n",
    "\n",
    "Si vuole stimare l'ordine di convergenza di un metodo di iterazione del punto fisso."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "function [order] = stima_order(appr, nit)\n",
    "\n",
    "p = zeros(nit);\n",
    "\n",
    "for i = 3 : nit - 1\n",
    "    p(i - 2) = log(abs(appr(i + 1) - appr(i)) / ...\n",
    "    abs(appr(i) - appr(i - 1))) / ...\n",
    "        log(abs(appr(i) - appr(i - 1)) / ...\n",
    "        abs(appr(i - 1) - appr(i - 2)));\n",
    "end\n",
    "\n",
    "order = p(nit - 3);\n",
    "\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bisection_order =  1\n",
      "regula_falsi_order = -0\n",
      "chords_order =  1.0000\n",
      "tangenti_order =  2.0107\n",
      "secant_order =  1.6933\n"
     ]
    }
   ],
   "source": [
    "[bisection_order] = stima_order(appr, length(appr))\n",
    "[regula_falsi_order] = stima_order(appr_falsi, length(appr_falsi))\n",
    "[chords_order] = stima_order(appr_chords, length(appr_chords))\n",
    "[tangenti_order] = stima_order(appr_tangenti, length(appr_tangenti))\n",
    "[secant_order] = stima_order(appr_secant, length(appr_secant))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Esercizio 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "clear a b x tolx tolf fx f\n",
    "close all\n",
    "\n",
    "syms x\n",
    "fx = tan(x) - x;\n",
    "fx1 = x;\n",
    "\n",
    "a = 3/5 * pi;\n",
    "b = 37/25 * pi;\n",
    "\n",
    "f = function_handle(fx);\n",
    "df = function_handle(diff(fx, x, 1));\n",
    "\n",
    "xc = linspace(0, 5);\n",
    "\n",
    "hold on\n",
    "plot(xc,feval(f, xc));\n",
    "plot(a, linspace(-25,20, 50), \"r.-\");\n",
    "plot(b, linspace(-25,20, 50), \"b.-\");\n",
    "ylim ([-25, 20]);\n",
    "hold off"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "appr_par =\n",
      "\n",
      "   3.2673   3.9584   4.3040   4.4768\n",
      "\n"
     ]
    }
   ],
   "source": [
    "tolx = 1e-8;\n",
    "tolf = 1e-8;\n",
    "v_nit = zeros(1,1);\n",
    "\n",
    "[sol, appr, nit] = bisection(f,a,b,tolx);\n",
    "appr_par = appr(1:4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valore  dell'innesco x_0: 3.267256\n",
      "[Secant]: approssimazione: 0.002444, iterazioni 26\n",
      "[Tangenti]: approssimazione: Inf, iterazioni 507 \n",
      "\n",
      "Valore  dell'innesco x_0: 3.958407\n",
      "[Secant]: approssimazione: 0.002690, iterazioni 14\n",
      "[Tangenti]: approssimazione: Inf, iterazioni 511 \n",
      "\n",
      "Valore  dell'innesco x_0: 4.303982\n",
      "[Secant]: approssimazione: 0.002380, iterazioni 43\n",
      "[Tangenti]: approssimazione: 4.493409, iterazioni 8 \n",
      "\n",
      "Valore  dell'innesco x_0: 4.476770\n",
      "[Secant]: approssimazione: 4.493409, iterazioni 7\n",
      "[Tangenti]: approssimazione: 4.493409, iterazioni 3 \n",
      "\n"
     ]
    }
   ],
   "source": [
    "for i = 1:length(appr_par)\n",
    "    [sol_newton, ~, nit_newton] = newton(f, df, appr_par(i), tolx, ...\n",
    "        tolf, 1000);\n",
    "    [sol_secant, appr_secant, nit_secant] = secant(f,appr_par(i), ...\n",
    "        a,tolx,tolf,1000);\n",
    "\n",
    "    fprintf(\"Valore  dell'innesco x_0: %f\\n\", appr_par(i));\n",
    "    fprintf(\"[Secant]: approssimazione: %f, iterazioni %i\\n\", ...\n",
    "        sol_secant, nit_secant);\n",
    "    fprintf(\"[Tangenti]: approssimazione: %f, iterazioni %i \\n\\n\", ...\n",
    "        sol_newton, nit_newton);\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A partire dai risultati ottenuti si può osservare la sensibilità sia del metodo di Newton che delle Secanti. Entrambi i metodi hanno convergenza locale, perciò se l'approssimazione dello zero di funzione fornita inizialmente non è abbastanza accurata, i due metodi non convergono alla radice, che in questo caso è pari a: $4.493409$.\n",
    "\n",
    "Si nota che per i primi due valori di innesco forniti il metodo di Newton non converge. Per i successivi due valori invece converge.\n",
    "Il metodo delle Secanti converge alla radice solo per l'ultimo valore di innesco fornito mentre nei primi tre casi non converge alla radice richiesta."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Esercizio 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjAAAAGkCAIAAACgjIjwAAAJMmlDQ1BkZWZhdWx0X3JnYi5pY2MAAEiJlZVnUJNZF8fv8zzphUASQodQQ5EqJYCUEFoo0quoQOidUEVsiLgCK4qINEWQRQEXXJUia0UUC4uCAhZ0gywCyrpxFVFBWXDfGZ33HT+8/5l7z2/+c+bec8/5cAEgiINlwct7YlK6wNvJjhkYFMwE3yiMn5bC8fR0A9/VuxEArcR7ut/P+a4IEZFp/OW4uLxy+SmCdACg7GXWzEpPWeGjy0wPj//CZ1dYsFzgMt9Y4eh/eexLzr8s+pLj681dfhUKABwp+hsO/4b/c++KVDiC9NioyGymT3JUelaYIJKZttIJHpfL9BQkR8UmRH5T8P+V/B2lR2anr0RucsomQWx0TDrzfw41MjA0BF9n8cbrS48hRv9/z2dFX73kegDYcwAg+7564ZUAdO4CQPrRV09tua+UfAA67vAzBJn/eqiVDQ0IgALoQAYoAlWgCXSBETADlsAWOAAX4AF8QRDYAPggBiQCAcgCuWAHKABFYB84CKpALWgATaAVnAad4Dy4Aq6D2+AuGAaPgRBMgpdABN6BBQiCsBAZokEykBKkDulARhAbsoYcIDfIGwqCQqFoKAnKgHKhnVARVApVQXVQE/QLdA66At2EBqGH0Dg0A/0NfYQRmATTYQVYA9aH2TAHdoV94fVwNJwK58D58F64Aq6HT8Id8BX4NjwMC+GX8BwCECLCQJQRXYSNcBEPJBiJQgTIVqQQKUfqkVakG+lD7iFCZBb5gMKgaCgmShdliXJG+aH4qFTUVlQxqgp1AtWB6kXdQ42jRKjPaDJaHq2DtkDz0IHoaHQWugBdjm5Et6OvoYfRk+h3GAyGgWFhzDDOmCBMHGYzphhzGNOGuYwZxExg5rBYrAxWB2uF9cCGYdOxBdhK7EnsJewQdhL7HkfEKeGMcI64YFwSLg9XjmvGXcQN4aZwC3hxvDreAu+Bj8BvwpfgG/Dd+Dv4SfwCQYLAIlgRfAlxhB2ECkIr4RphjPCGSCSqEM2JXsRY4nZiBfEU8QZxnPiBRCVpk7ikEFIGaS/pOOky6SHpDZlM1iDbkoPJ6eS95CbyVfJT8nsxmpieGE8sQmybWLVYh9iQ2CsKnqJO4VA2UHIo5ZQzlDuUWXG8uIY4VzxMfKt4tfg58VHxOQmahKGEh0SiRLFEs8RNiWkqlqpBdaBGUPOpx6hXqRM0hKZK49L4tJ20Bto12iQdQ2fRefQ4ehH9Z/oAXSRJlTSW9JfMlqyWvCApZCAMDQaPkcAoYZxmjDA+SilIcaQipfZItUoNSc1Ly0nbSkdKF0q3SQ9Lf5RhyjjIxMvsl+mUeSKLktWW9ZLNkj0ie012Vo4uZynHlyuUOy33SB6W15b3lt8sf0y+X35OQVHBSSFFoVLhqsKsIkPRVjFOsUzxouKMEk3JWilWqUzpktILpiSTw0xgVjB7mSJleWVn5QzlOuUB5QUVloqfSp5Km8oTVYIqWzVKtUy1R1WkpqTmrpar1qL2SB2vzlaPUT+k3qc+r8HSCNDYrdGpMc2SZvFYOawW1pgmWdNGM1WzXvO+FkaLrRWvdVjrrjasbaIdo12tfUcH1jHVidU5rDO4Cr3KfFXSqvpVo7okXY5upm6L7rgeQ89NL0+vU++Vvpp+sP5+/T79zwYmBgkGDQaPDamGLoZ5ht2GfxtpG/GNqo3uryavdly9bXXX6tfGOsaRxkeMH5jQTNxNdpv0mHwyNTMVmLaazpipmYWa1ZiNsulsT3Yx+4Y52tzOfJv5efMPFqYW6RanLf6y1LWMt2y2nF7DWhO5pmHNhJWKVZhVnZXQmmkdan3UWmijbBNmU2/zzFbVNsK20XaKo8WJ45zkvLIzsBPYtdvNcy24W7iX7RF7J/tC+wEHqoOfQ5XDU0cVx2jHFkeRk4nTZqfLzmhnV+f9zqM8BR6f18QTuZi5bHHpdSW5+rhWuT5z03YTuHW7w+4u7gfcx9aqr01a2+kBPHgeBzyeeLI8Uz1/9cJ4eXpVez33NvTO9e7zofls9Gn2eedr51vi+9hP0y/Dr8ef4h/i3+Q/H2AfUBogDNQP3BJ4O0g2KDaoKxgb7B/cGDy3zmHdwXWTISYhBSEj61nrs9ff3CC7IWHDhY2UjWEbz4SiQwNCm0MXwzzC6sPmwnnhNeEiPpd/iP8ywjaiLGIm0iqyNHIqyiqqNGo62ir6QPRMjE1MecxsLDe2KvZ1nHNcbdx8vEf88filhICEtkRcYmjiuSRqUnxSb7JicnbyYIpOSkGKMNUi9WCqSOAqaEyD0tandaXTlz/F/gzNjF0Z45nWmdWZ77P8s85kS2QnZfdv0t60Z9NUjmPOT5tRm/mbe3KVc3fkjm/hbKnbCm0N39qzTXVb/rbJ7U7bT+wg7Ijf8VueQV5p3tudATu78xXyt+dP7HLa1VIgViAoGN1tubv2B9QPsT8M7Fm9p3LP58KIwltFBkXlRYvF/OJbPxr+WPHj0t6ovQMlpiVH9mH2Je0b2W+z/0SpRGlO6cQB9wMdZcyywrK3BzcevFluXF57iHAo45Cwwq2iq1Ktcl/lYlVM1XC1XXVbjXzNnpr5wxGHh47YHmmtVagtqv14NPbogzqnuo56jfryY5hjmceeN/g39P3E/qmpUbaxqPHT8aTjwhPeJ3qbzJqamuWbS1rgloyWmZMhJ+/+bP9zV6tua10bo63oFDiVcerFL6G/jJx2Pd1zhn2m9az62Zp2WnthB9SxqUPUGdMp7ArqGjzncq6n27K7/Ve9X4+fVz5ffUHyQslFwsX8i0uXci7NXU65PHsl+spEz8aex1cDr97v9eoduOZ67cZ1x+tX+zh9l25Y3Th/0+LmuVvsW523TW939Jv0t/9m8lv7gOlAxx2zO113ze92D64ZvDhkM3Tlnv296/d5928Prx0eHPEbeTAaMip8EPFg+mHCw9ePMh8tPN4+hh4rfCL+pPyp/NP637V+bxOaCi+M24/3P/N59niCP/Hyj7Q/Fifzn5Ofl08pTTVNG02fn3Gcufti3YvJlykvF2YL/pT4s+aV5quzf9n+1S8KFE2+Frxe+rv4jcyb42+N3/bMec49fZf4bmG+8L3M+xMf2B/6PgZ8nFrIWsQuVnzS+tT92fXz2FLi0tI/QiyQvpTNDAsAAAAJcEhZcwAACxMAAAsTAQCanBgAAAAfdEVYdFNvZnR3YXJlAEdQTCBHaG9zdHNjcmlwdCA5LjUzLjNvnKwnAAATiUlEQVR4nO3dv4sj6Z3A4ZJv4u3BYAdmagKDtwM1LA4maC0Hx+KgFRjj5kwbc+Bu6Jm0L+gODG5jbjAH1gbedDoZsJOd8zQ2B1Y2OBl1YjgMUtBjuGDKXODjltH+A7pAdq2s/iWpqlRvVT1PsEgatape/ejPfEsabWsymUQAULYvlb0DABBFggRAIAQJgCAIEgBByBqk8XicJEkuuwJAk93L+PMvXrx49+7dycnJ7IWPHj1qt9tRFLXb7bk/AoBrZQrS7u7uaDQ6PDycvTBJkna7/fz580z7BUDDZDpkd35+PlejKIqSJNnY2Dg9Pe31euPxOMvtA9Ac+X+oYTweP3jwoNvt3r9//+joKPfbB6CWsr6HdFW32+12u1EUdTqdfr9/7XU2NzffvHmTnvVtEQDkPyGdnZ0NBoM7rzaZkfs+AFA5eU5Ig8Hg4ODg5cuXR0dHOzs7o9Fob28vx9sHoMZaBQ0og8EgjuM4jq/9083NzcvLyyK2C0BF5f8e0lSn0ynolgGoJV8dBEAQBAmAIAgSAEEQJACCIEgABEGQAAiCIAEQBEECIAiCBEAQBAmAIAgSAEEQJACCIEgABEGQAAiCIAEQBEECIAiCBEAQBAmAIAgSAEEQJACCIEgABEGQAAiCIAEQBEECIAiCBEAQBAmAIAgSAEEQJABy0zp+1Tp+tdrP3st3VwBojqvtmXz80cq3JkgALCTf/FwlSABco+j8XCVIAETRlQIVnZ+rBAmgidY/AN1JkAAaofQB6E6CBFBbsxEKsEBzBAmgPsIfg24hSAAVVukCzREkgIqp1oG4xQkSQAXUNUKzBAkgUE2I0CxBAghI0yI0S5AAStbkCM0SJIBypB1qcoRmCRLA+hiGbiFIAIUzDC1CkACKokNLESSAPDkotzJBAsiBYSg7QQJYnQ7lSJAAlqZDRRAkgEXpUKEECeBu0xTpUKEECeBGRqJ1EiSAeTpUCkEC+IJDcyUqKkjj8fjzzz+P47ig2wfIkZEoBEUF6cWLF+/evTs5OSno9gFyYSQKRyFB2t3dHY1Gh4eHRdw4QC6kKDSFBOn8/LzX6xVxywAZOToXLB9qAJrCSBS40oLUarXS05PJpKzdAJpAiiqhtCCJELAGUlQhDtkB9SRFldMqZVLZ3Ny8vLxc/3aBJpCiijIhAfUhRZUmSEAdSFENCBJQbVJUG4IEVJUU1YwgAdUjRbUkSECVSFGNCRJQGa3jV1JUY4IEVIDBqAkECQiaFDWHIAHhcoyuUQQJCJHBqIEECQiLFDWWIAEBcYyuyQQJCILBCEECymcwIhIkoFwGI1KCBJTGYMQsQQJKYDDiKkEC1s1gxLW+VPYOAM2iRtzEhASsicN03E6QgHUwGHEnh+yAwqkRizAhAQVymI7FCRJQFIMRS3HIDiiEGrEsExKQM4fpWI0gAXkyGLEyh+yA3KgRWQgSkA81IiNBAnKgRmQnSEBWakQufKgBWJ0P1JEjQQJWZDAiXw7ZAatQI3InSMDS1IgiCBKwHDWiIIIELEGNKI4gAYtSIwolSMBC1IiiCRJwNzViDQQJuIMasR6CBNxGjVgbQQJupEaskyAB11Mj1kyQgGuoEesnSMA8NaIUggT8HTWiLIIEfEGNKJEgAX+lRpRLkIAoUiMCIEiAGhEEQYKmUyMCIUjQaGpEOAQJmkuNCIogARCErEEaDofj8TiXXQHWyXhEaO5l+eH9/f04jkej0fHxcafTSS9/9OhRu92Ooqjdbp+cnGTdRyBvakSAVg9Sv9+P4/jp06dJkpyenqZBSpKk3W4/f/48nx0E8qZGhGn1IA2Hw62trSiK4ji+uLhIL0+SZGNj4/T09L333nvy5MnGxkYOuwnkRI0IVqb3kOI4np7Y3t5OLxyPxw8ePOh2u/fv3z86Osq0d0Cu1IiQZXoPKUmS6YnZCanb7Xa73SiKOp1Ov9+/6WdbrVZ6ejKZZNkNYBFqROBWn5C2trbevn0b/e1No/Tys7OzwWBw549PZqy8DwDUxuoTUrfbPTs76/V6FxcXjx8/jqJoMBgcHBy8fPny6OhoZ2dnNBrt7e3lt6vA6oxHhK+VcUAZDAZxHKdvJt15+dTm5ubl5WWW7QKLUyMqIWuQViNIsDZqRFX46iCoMzWiQgQJgCAIEtSW8YhqESSoJzWicgQJakiNqCJBgrpRIypKkAAIgiBBrRiPqC5BgvpQIypNkKAm1IiqEyQAgiBIUAfGI2pAkKDy1Ih6ECSoNjWiNgQJgCAIElSY8Yg6ESSoKjWiZgQJKkmNqB9BAiAIggTVYzyilgQJKkaNqCtBAiAIggRVYjyixgQJKkONqDdBgmpQI2pPkAAIgiBBBRiPaAJBgtCpEQ0hSAAEQZAgaMYjmkOQIFxqRKMIEgBBECQIlPGIphEkCJEa0UCCBEAQBAmCYzyimQQJwqJGNJYgARAEQYKAGI9oMkGCUKgRDSdIAARBkCAIxiMQJCifGkEkSAAEQpCgZMYjmBIkKJMaQUqQAAiCIEFpjEcwS5CgHGoEcwQJgCAIEpTAeARXCRKsmxrBtQQJgCAIEqyV8QhuIkgABKGoIA2Hw/F4XNCNQ0UZj+AWhQRpf3//008/PTg4GAwGRdw+VJEawe3u5X6L/X4/juOnT58mSXJ6etrpdHLfBAD1k/+ENBwOt7a2oiiK4/ji4uLqFd5872uzZz/77dc/++3X07M/+eAXP/ngF+nZH/36mz/69Tdnr//t3382e/ZXX/lg9mzr+NXt25o9O7uhq9v69u8/m93Wr77ywey2WsevZrf15ntfm93W3KKu3VaOi1r8DsyyqGiBO3CpRS1+B2ZZVJT5WXH7oha8A1vHr/7vHw9XXlRUkaf63KKivJ/qc4sq6Kle9Ou3oKf63KKivJ/qc4ta6g5cUCGH7OI4np7Y3t6e+6N0p1e7p6b3UXpPTe+j9J6a3kHp3TTdRLqh6SbSDU03kW5oqQcjteDDf+22clxUasFn2Gq/FBa5A5da1NVNLLKoO1c3t6jsz4rbF5W6ZVHTGi2yupsWVdZTPd3Eag9Z7k/1uUWlFlzUav3L/fV7dRO3L2q1hyz3p/pqr9+lFBKkJEmmJ66dkFKtVqvVahWxAwBUTv5B2traevv2bRRFSZK02+25P33/P/4nPTGZTCaTyfTsl7/z37NX+7c//uvs2X//5/+anvjPf/py+t8oiv7lf/+Y/jeKouk7xun7xtNtpVucbiLd0HQT6YbSTcxuKJVuYs7ce9TptuYWde22clxU6qb7bW5Rt6/upkUtcgcutairm1hkUXeubm5R2Z8Vty8qddOipp9lSDex2kNW1lM93cRqD1nuT/W5RaUWXNSCD9nconJ//V7dxO2LWu0hy/2pvtrrdymtNAk52t3d3d7evri4ePz4cbfbvXqFzc3Ny8vL3LcLofHJOlhc/p+yi6Lo/Px8MBh8//vfT99MAoDbFRKkKIp82huMR7AUXx0EhVAjWJYgARAEQYL8GY9gBYIEOVMjWI0gARAEQYI8GY9gZYIEQBAECXJjPIIsBAnyoUaQkSABEARBghwYjyA7QYKs1AhyIUgABEGQIBPjEeRFkGB1agQ5EiQAgiBIsCLjEeRLkGAVagS5EyQAgiBIsDTjERRBkGA5agQFESQAgiBIsATjERRHkGBRagSFEiQAgiBIsBDjERRNkOBuagRrIEgABEGQ4A7GI1gPQYLbqBGsjSABEARBghsZj2CdBAmup0awZoIE11AjWD9BAiAIggTzjEdQCkGCv6NGUBZBAiAIggRfMB5BiQQJ/kqNoFyCBFGkRhAAQQIgCIIExiMIgiDRdGoEgRAkGk2NIByCBEAQBInmMh5BUASJhlIjCI0g0URqBAESJACCIEg0jvEIwiRINIsaQbAEiQZRIwiZINEUagSBEyQAgpA1SMPhcDwe57IrUBzjEYTvXpYf3t/fj+N4NBodHx93Op308kePHrXb7SiK2u32yclJ1n2EbNQIKmH1IPX7/TiOnz59miTJ6elpGqQkSdrt9vPnz/PZQchGjaAqVg/ScDjc2tqKoiiO44uLi/TyJEk2NjZOT0/fe++9J0+ebGxs5LCbsBI1ggrJ9B5SHMfTE9vb2+mF4/H4wYMH3W73/v37R0dHmfYOgMZYekIaDAavX79++PBhFEVJkkwvnJ2Qut1ut9uNoqjT6fT7/Ztup9Vqpacnk8myuwF3Mh5BtSwdpE6nM327qN/vD4fD6G9vGqVXODs7a7fbs59xuJYIUSg1gspZ/T2kbrd7dnbW6/UuLi4eP34cRdFgMDg4OHj58uXR0dHOzs5oNNrb28tvV2FRagRV1Mo4qQwGgziO0zeT7rx8anNz8/LyMst24SZqBBWVNUirESQKokZQXb46iPpQI6g0QQIgCIJETRiPoOoEiTpQI6gBQaLy1AjqQZCoNjWC2hAkKkyNoE4EiapSI6gZQaKS1AjqR5CoHjWCWhIkKkaNoK4EiSpRI6gxQaIy1AjqTZCoBjWC2hMkKkCNoAkEidCpETSEIBE0NYLmECTCpUbQKIJEoNQImkaQCJEaQQMJEsFRI2gmQSIsagSNJUgERI2gyQSJUKgRNNy9sncAotbxqyiK1AgaTpAomcEImHLIjjKpEZASJEqjRsAsQaIcagTM8R4S6+YjDMC1BIm1MhgBN3HIjvVRI+AWJiTWwWE64E6CROEMRsAiHLKjWGoELMiERFEcpgOWIkgUwmAELMshO/KnRsAKTEjkyWE6YGWCRG4MRkAWgkQODEZAdoJEVgYjIBeCxOoMRkCOBIkVGYyAfAkSSzMYAUUQJJZjMAIKIkgsymAEFEqQuJsUAWsgSNxGioC1ESRu5O0iYJ0EiWsYjID1EyT+jhQBZREk/kqKgHIJElIEBEGQGk2KgHAUFaTxePz555/HcVzQ7ZORFAGhKSpIL168ePfu3cnJSUG3z8qkCAhTIUHa3d0djUaHh4dF3DgrkyIgZIUE6fz8vNfrFXHLrEaKgPD5UEPNSRFQFbkFaTAYvH79+uHDh3t7e4tcv9Vqpacnk0leu0FKioBqyS1InU6n0+ksfn0RKsi0Q5EUAVXjkF19GImASmuVMqlsbm5eXl6uf7t1JUVADZiQKszROaBOBKmSjERA/QhSlRiJgBoTpArQIaAJBCloDs0BzSFIITISAQ0kSAHRIaDJBKl8OgQQCVKJdAhgliCtmw4BXEuQ1iGNUKRDADcQpAIZhgAWJ0g5MwwBrEaQ8mEYAshIkFZnGALIkSAtR4QACiJIdxMhgDUQpOuJEMCaCdIXRAigRI0O0myBIhECKFXjgmQMAghT/YNkDAKohBoGSYEAqqgOQVIggBqoXpDm8hMpEEAtVCBIBiCAJgguSAYggGYqOUjyA8BUaUGapkh+AJgqLUhSBMCsL5W9AwAQRYIEQCAECYAgCBIAQRAkAIIgSAAEQZAACIIgARAEQQIgCIIEQBAECYAgCBIAQRAkAIIgSAAEQZAACIIgARAEQQIgCIIEQBAECYAgCBIAQRAkAIIgSAAEQZAACIIgARAEQQIgCIIEQBCyBmk8HidJksuuNEGr1Sp7F0pj7c1k7Q208sLvZdzwixcv3r17d3JyMnvho0eP2u12FEXtdnvujwDgWpmCtLu7OxqNDg8PZy9MkqTdbj9//jzTfgHQMJkO2Z2fn8/VKIqiJEk2NjZOT097vd54PM5y+wA0R2symWT5+V6vF0XR7HG5fr8/HA4//PDD0Wj0+vXra0elzc3NLBsFIHCXl5fL/sjSh+wGg8Hr168fPny4t7d37RW63W63242iqNPp9Pv9a6/z5s2b2bMZo1ghrVbWvwFUl7WXvRflsPay96IEKy986SB1Op1Op3PLFc7Oztrt9u3XaeaDFDV44ZG1N5W1N9DKC8/6KbtZg8Hg4ODg5cuXR0dHOzs7o9HopikKAOYUNVEOBoM4juM4LuLGAaifhh7iBCA0pX110GAwaOyHwofDYWO/3qKZX+0xHA4b+2xv5iMeNftlvvKv93/46U9/mvfO3GE8Hv/gBz+YTCY/+9nPvvrVr37jG99Y8w6UaLr2v/zlL7/5zW/+9Kc/ffjhh2Xv0br98pe//MMf/tCohe/v7ydJcnZ21syD2A18xJv8Ms/6632yds+ePXv27NlkMnn79u0Pf/jD9e9AiZ49e/bzn/98evqjjz4qd2fW77vf/e7777+f3gNN8Lvf/e7HP/7xpJHP9kkjH/FJs1/mGX+95/kpuwU9fvx4emI4HDbtL4w7OzvTE808gHN+fj79l9TNMRwOt7a2oiiK4/ji4qLs3Vm3Bj7iUbNf5hl/vZf2HlKv1/v444+nr9XmmB60mX4+/smTJ2XvDuuQviy3t7fL3RPWw8t85V/v65uQ5r7i4eTk5MmTJ9/61rdq/2+V5hbe6/X+/Oc/f/LJJ02YDu/8Xo8mSN/ZbuCE1FiNeplftfKv9/UFKf2Kh9PT006n0+12NzY21rb1Es1+t8Wnn346fZqWu0trc+f3etTe1tbWcDiM/vYt+GXvDuvQtJf5rIy/3kt4D2lvb+/o6Gg4HI5Go6bNs9NPgu7v70/P+p901F632z07O+v1ehcXF+nhdeqtyS/zjL/ey/mHsePxeDQaNfNTsDSQLy6hObL8evdNDQAEobRP2QHALEECIAiCBEAQBAmAIAgSAEH4f7ddySccYP2tAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "clear a b x tolx tolf fx f\n",
    "close all\n",
    "syms x\n",
    "fx = atan(x);\n",
    "f = function_handle(fx);\n",
    "df = function_handle(diff(fx, x, 1));\n",
    "xc = linspace(-3,3);\n",
    "hold on\n",
    "plot(xc, feval(f,xc));\n",
    "\n",
    "plot(linspace(-3,3), 0);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Tangenti]: approssimazione: -7.599004e-12, iterazioni 5 \n",
      "Derivata nulla in x_0, uscita...\n",
      "[Tangenti]: approssimazione: -4.297215e+08, iterazioni 9 \n"
     ]
    }
   ],
   "source": [
    "x_0 = [1.2, 1.4];\n",
    "tolx = 1.e-6;\n",
    "tolf = 1.e-5;\n",
    "\n",
    "for i=1:length(x_0)\n",
    "    [sol, appr, nit] = newton(f, df, x_0(i), tolx, tolf, 1000);\n",
    "    fprintf(\"[Tangenti]: approssimazione: %e, iterazioni %i \\n\", sol, nit);\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il metodo di Newton in entrambi i casi non converge."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Esercizio 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "clear a b x tolx tolf fx f sol_newton appr_newton nit_newton\n",
    "close all\n",
    "syms x\n",
    "fx = x^3 + x^2 - 33 * x + 63;\n",
    "f = function_handle(fx);\n",
    "df = function_handle(diff(fx, x, 1));\n",
    "x_0 = 1;\n",
    "tolx = 1.e-12;\n",
    "tolf = 1.e-12;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Tangenti]: approssimazione: 3, iterazioni 23 \n",
      "[Newton modificato]: approssimazione: 3, iterazioni 4 \n"
     ]
    }
   ],
   "source": [
    "[sol_newton, appr_newton, nit_newton] = newton(f, df, x_0, tolx, ...\n",
    "    tolf,1000);\n",
    "[sol_mk2, appr_mk2, nit_mk2] = newton_mk2(f, df, x_0, tolx, ...\n",
    "    tolf, 1000, 2);\n",
    "\n",
    "fprintf(\"[Tangenti]: approssimazione: %g, iterazioni %i \\n\", ...\n",
    "    sol_newton, nit_newton);\n",
    "fprintf(\"[Newton modificato]: approssimazione: %g, iterazioni %i \\n\", ...\n",
    "    sol_mk2, nit_mk2);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ordine di convergenza del metodo di Newton: 1.000899\n",
      "Ordine di convergenza del metodo di Newton modificato: 1.996543\n"
     ]
    }
   ],
   "source": [
    "[p1] = stima_order(appr_newton, nit_newton);\n",
    "fprintf(\"Ordine di convergenza del metodo di Newton: %f\\n\", p1);\n",
    "\n",
    "[p2] = stima_order(appr_mk2, nit_mk2);\n",
    "fprintf(\"Ordine di convergenza del metodo di Newton modificato: %f\\n\", p2);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nel caso di radici multiple il metodo di Newton classico ha velocità di convergenza lineare mentre la versione modificata raggiunge ha convergenza quadratica."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Esercizio 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "% TODO"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Octave",
   "language": "octave",
   "name": "octave"
  },
  "language_info": {
   "file_extension": ".m",
   "help_links": [
    {
     "text": "GNU Octave",
     "url": "https://www.gnu.org/software/octave/support.html"
    },
    {
     "text": "Octave Kernel",
     "url": "https://github.com/Calysto/octave_kernel"
    },
    {
     "text": "MetaKernel Magics",
     "url": "https://metakernel.readthedocs.io/en/latest/source/README.html"
    }
   ],
   "mimetype": "text/x-octave",
   "name": "octave",
   "version": "5.2.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}