{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Parte 10\n",
    "\n",
    "Sviluppo dei codici relativi alle formule di quadratura di Newton-Cotes, con $n = 1$ e $n=2$,nella versione composita e automatica.\n",
    "Sperimentazione numerica relativa alle formule di quadratura implementate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "pkg load symbolic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Formula dei trapezi composita\n",
    "\n",
    "Definita su $N$ sottointervalli individuati da nodi equispaziati, a partire da:\n",
    "\n",
    "$$ \n",
    "I(f) := \\frac{b - a}{2N} \\left( f(a) + 2 \\sum_{k = 1}^{N - 1} f(z_{k}) + f(b) \\right)\n",
    "$$\n",
    "\n",
    "    I = trap_comp(f, a, b, N)\n",
    "    \n",
    "Input:\n",
    "- `f`: funzione integranda (anonymous function);\n",
    "- `a`, `b`: estremo inferiore e superiore di integrazione;\n",
    "- `N`: tolleranza.\n",
    "\n",
    "Output:\n",
    "- `I`: funzione approssimata risultante dall'integrazione."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "function I = trap_comp(f, a, b, N)\n",
    "% passo di campionamento, effettua un'interpolazione lineare, sfruttando una retta\n",
    "h = (b - a) / N; \n",
    "x = (a:h:b); % nodi equispaziati\n",
    "\n",
    "y = f(x); % vettore contenente le valutazioni della funzione\n",
    "\n",
    "I = (y(1) + 2 * sum(y(2:N)) + y(N + 1)) * h / 2;\n",
    "% formula dei trapezi di quadratura composita\n",
    "% a = 1\n",
    "% b = N + 2\n",
    "% da 2 a N come da 1 a N - 1\n",
    "\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Formula di Simpson composita\n",
    "\n",
    "Definita su $N$ sottointervalli individuati da nodi equispaziati, a partire da:\n",
    "\n",
    "$$ \n",
    "I(f) := \\frac{b - a}{6N} \\left( f(a) + 2 \\sum_{k = 1}^{N - 1} f(z_{k}) + 4 \\sum_{k = 0}^{N - 1} f \\left(\\frac{z_{k} + z_{k + 1}}{2} \\right) + f(b) \\right)\n",
    "$$\n",
    "\n",
    "    I = simp_comp(f, a, b, N)\n",
    "    \n",
    "Input:\n",
    "- `f`: funzione integranda (anonymous function);\n",
    "- `a`, `b`: estremo inferiore e superiore di integrazione;\n",
    "- `N`: tolleranza.\n",
    "\n",
    "Output:\n",
    "- `I`: funzione approssimata risultante dall'integrazione."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "function I = simp_comp(f, a, b, N)\n",
    "\n",
    "% passo di campionamento (doppio rispetto ai trapezi), dato che effettua\n",
    "% un'interpolazione quadratica, sfruttando una parabola\n",
    "h = (b - a) / (2 * N); \n",
    "x = (a:h:b); % nodi equispaziati\n",
    "\n",
    "y = f(x); % vettore contenente le valutazioni della funzione\n",
    "\n",
    "I = (y(1) + 2 * sum(y(3:2:2*N-1)) + 4 * sum(y(2:2:2*N)) ...\n",
    "    + y(2 * N + 1)) * h/3; % passo 2 per iterare sui nodi dispari\n",
    "% formula di Simpson composita\n",
    "% a = 1\n",
    "% b = 2*N + 1\n",
    "% 2 -> N come 3 -> N - 1\n",
    "\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Formula del trapezio composita con quadratura automatica\n",
    "\n",
    "    [I, N] = trap_tol(fun, a, b, tol)\n",
    "    \n",
    "Input:\n",
    "- `f`: funzione integranda (anonymous function);\n",
    "- `a`, `b`: estremo inferiore e superiore di integrazione;\n",
    "- `tol`: tolleranza.\n",
    "\n",
    "Output:\n",
    "- `I` indica la migliore approssimazione dell'integrale restituita dalla funzione;\n",
    "- `N` indica il numero di sottointervalli in cui si applica la formula di quadratura del trapezio.\n",
    "\n",
    "Fino a quando non si raggiunge la tolleranza desiderata o il numero massimo di sottointervalli creati si ricalcola l'approssimazione dell'integrale con un numero di sottointervalli progressivamente crescente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "function [I, N] = trap_tol(fun, a, b, tol)\n",
    "\n",
    "N_max = 2048; % si impone comunque un limite superiore\n",
    "err = 1;\n",
    "\n",
    "N = 1;\n",
    "I = trap_comp(fun, a, b, N);\n",
    "\n",
    "while N <= N_max && err > tol\n",
    "    N = 2 * N; % strategia di raddoppio del numero di sottointervalli\n",
    "    Ik = trap_comp(fun, a, b, N);\n",
    "    err = abs(I - Ik) / 3; % formula stima del resto con s = 2\n",
    "    I = Ik;\n",
    "end\n",
    "\n",
    "if N > N_max\n",
    "    disp(\"Maximum number of intervals reached!\");\n",
    "    I = [];\n",
    "    N = [];\n",
    "    return;\n",
    "end\n",
    "\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Formula di Simpson composita con quadratura automatica\n",
    "\n",
    "    [I, N] = simp_tol(fun, a, b, tol)\n",
    "\n",
    "Input:\n",
    "- `f`: funzione integranda (anonymous function);\n",
    "- `a`, `b`: estremo inferiore e superiore di integrazione;\n",
    "- `tol`: tolleranza.\n",
    "\n",
    "Output:\n",
    "- `I` indica la migliore approssimazione dell'integrale restituita dalla funzione;\n",
    "- `N` indica il numero di sottointervalli in cui si applica la formula di quadratura di Simpson.\n",
    "\n",
    "Fino a quando non si raggiunge la tolleranza desiderata o il numero massimo di sottointervalli creati si ricalcola l'approssimazione dell'integrale con un numero di sottointervalli progressivamente crescente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "function [I, N] = simp_tol(fun, a, b, tol)\n",
    "\n",
    "N_max = 2048;\n",
    "err = 1;\n",
    "\n",
    "N = 1;\n",
    "I = simp_comp(fun, a, b, N);\n",
    "\n",
    "while N <= N_max && err > tol\n",
    "    N = 2 * N; % strategia di raddoppio del numero di sottointervalli\n",
    "    Ik = simp_comp(fun, a, b, N);\n",
    "    err = abs(I - Ik) / 15; % formula stima del resto con s = 4\n",
    "    I = Ik;\n",
    "end\n",
    "\n",
    "if N > N_max\n",
    "    disp(\"Maximum number of intervals reached!\");\n",
    "    I = [];\n",
    "    N = [];\n",
    "    return;\n",
    "end\n",
    "\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TODO - Esercizio 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Symbolic pkg v2.9.0: Python communication link active, SymPy v1.5.\n"
     ]
    }
   ],
   "source": [
    "syms x\n",
    "%----------------------\n",
    "f = 1./(1 + x);\n",
    "% f = x * sin(pi * x);\n",
    "% f = x^2 * exp(x);\n",
    "% f = log(1 + x);\n",
    "%----------------------\n",
    "f = function_handle(f);\n",
    "\n",
    "a = 0;\n",
    "b = 1;\n",
    "\n",
    "% calcolo dell'integrale esatto con la built-in function |int(expr,var,a,b)|\n",
    "% a partire dall'integrale calcolato in forma simbolica si vuole ottenere un double\n",
    "I_es = double(int(f,x,a,b)); \n",
    "\n",
    "tol = 0.5e-3; % il resto deve avere modulo minore di tol\n",
    "\n",
    "xx = linspace(a, b, 300);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "% Stima dell'errore commesso nell'integrazione tramite la formula dei trapezi\n",
    "\n",
    "% Si calcola il massimo valor assunto dalla funzione in [a,b] tramite\n",
    "% il calcolo della derivata seconda in formato simbolico\n",
    "df2_trap = diff(f, x, 2);\n",
    "df2_trap = function_handle(df2_trap);\n",
    "yy_trap = feval(df2_trap, xx);\n",
    "max_trap = max(abs(yy_trap));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Per determinare il numero di iterazioni necessarie per applicare la formula dei trapezi composita si impiega la formula seguente:\n",
    "\n",
    "$$\n",
    "N \\geq \\sqrt[2]{\\frac{(b-a)^{3} M}{12 \\cdot tol}}\n",
    "$$\n",
    "\n",
    "Questa espressione del numero di iterazioni richiesto dalla formula dei trapezi composita si ottiene a partire dalla formula del resto:\n",
    "\n",
    "$$\n",
    "|r_{1}^{N}(f)| = \\frac{(b - a)^{3}}{12 N^{2}} |f^{2} (x)| \\le \\frac{(b - a)^{3}}{12 N^{2}} M\n",
    "$$\n",
    "\n",
    "\n",
    "$$\n",
    "\\frac{(b - a)^{3}}{12 N^{2}}M \\le tol \\implies N \\geq \\sqrt[2]{\\frac{(b-a)^{3} M}{12 \\cdot t o l}}\n",
    "$$\n",
    "\n",
    "Dove $M = \\max_{x \\in [a,b]} | f^{(2)}(x)|$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "% 2. Formula del resto dei trapezi per il numero di iterazioni\n",
    "N_trap = (((b - a)^3 * max_trap) / (12 * tol))^(1/2);\n",
    "N_trap = ceil(N_trap);\n",
    "\n",
    "% 3. Calcolo integrale approssimato con formula dei trapezi composita\n",
    "I_trap = trap_comp(f, a, b, N_trap);\n",
    "\n",
    "% 4. Calcolo errore relativo\n",
    "err_rel = abs(I_es - I_trap) / abs(I_es);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "% Stima dell'errore commesso nell'integrazione tramite la formula di Simpson\n",
    "\n",
    "% Si calcola il massimo valor assunto dalla funzione in [a,b] tramite\n",
    "% il calcolo della derivata quarta in formato simbolico\n",
    "df4_simp = diff(f, x, 4);\n",
    "df4_simp = function_handle(df4_simp);\n",
    "yy_simp = feval(df4_simp, xx);\n",
    "max_simp = max(abs(yy_simp));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Per determinare il numero di iterazioni necessarie per applicare la formula dei trapezi composita si impiega la formula seguente:\n",
    "\n",
    "$$\n",
    "N \\geq \\sqrt[4]{\\frac{(b-a)^{5} M}{2880 \\cdot tol}}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "% 2. Formula del resto di Simpson per il numero di iterazioni\n",
    "N_simp = (((b - a)^5 * max_simp) / (2880 * tol))^(1/4);\n",
    "N_simp = ceil(N_simp);\n",
    "\n",
    "% 3. Calcolo integrale approssimato con formula di Simpson composita\n",
    "I_simp = simp_comp(f, a, b, N_simp);\n",
    "\n",
    "% 4. Calcolo errore relativo\n",
    "err_rel_simp = abs(I_es - I_simp) / abs(I_es);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "N_simp =  3\n",
      "N_trap =  256\n",
      "trapezi composita: 2.496877e-04\n",
      "simpson composita: 8.404948e-01\n",
      "simpson composita: 1.249434e-01\n",
      "simpson composita: 9.930228e-03\n",
      "simpson composita: 6.583810e-04\n",
      "simpson composita: 4.175720e-05\n",
      "simpson composita: 2.619405e-06\n",
      "simpson composita: 1.638628e-07\n",
      "simpson composita: 1.024377e-08\n",
      "simpson composita: 6.402719e-10\n",
      "I_simp =  0.38629\n",
      "I_trap =  0.38629\n"
     ]
    }
   ],
   "source": [
    "N_simp\n",
    "N_trap\n",
    "fprintf(\"trapezi composita: %e\\n\", err_rel);\n",
    "fprintf(\"simpson composita: %e\\n\", err_rel_simp);\n",
    "I_simp\n",
    "I_trap"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Esercizio 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "syms x %real\n",
    "\n",
    "%---------------\n",
    "f = x^10;\n",
    "% f = log(x + 1);\n",
    "% f = arcsin(x);\n",
    "%---------------\n",
    "f = function_handle(f);\n",
    "\n",
    "a = 0; b = 1;\n",
    "xx = linspace(a, b, 300);\n",
    "I_es = double(int(f, x, a, b));\n",
    "abs_es = abs(I_es);\n",
    "\n",
    "% preallocazione\n",
    "err_rel_trap = zeros(9, 1);\n",
    "err_rel_simp = zeros(9, 1);\n",
    "\n",
    "i = 0;\n",
    "for N = [1 2 4 8 16 32 64 128 256] \n",
    "    i = i + 1;\n",
    "    I_trap = trap_comp(f, a, b, N);\n",
    "    I_simp = simp_comp(f, a, b, N);\n",
    "    err_rel_trap(i) = abs(I_es - I_trap) / abs_es;\n",
    "    err_rel_simp(i) = abs(I_es - I_simp) / abs_es;\n",
    "end\n",
    "\n",
    "figure\n",
    "semilogy([1 2 4 8 16 32 64 128 256], err_rel_trap, \"bo-\", ...\n",
    "    [1 2 4 8 16 32 64 128 256], err_rel_simp, \"ro-\");\n",
    "title(\"Confronto errore relativo approssimazione integrale\");\n",
    "legend(\"trap\",\"simp\")\n",
    "box off"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Esercizio 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I_trap =  0.38629\n",
      "N_trap =  256\n",
      "I_simp =  0.38629\n",
      "N_toll =  8\n"
     ]
    }
   ],
   "source": [
    "syms x real\n",
    "\n",
    "%------------\n",
    "f = log(x); a = 1; b = 2;\n",
    "% f = sqrt(x); a = 0; b = 1;\n",
    "% f = abs(x); a = -1; b = 1;\n",
    "%------------\n",
    "\n",
    "f = function_handle(f);\n",
    "tol = 1.e-6;\n",
    "\n",
    "[I_trap, N_trap] = trap_tol(f, a, b, tol)\n",
    "[I_simp, N_toll] = simp_tol(f, a, b, tol)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TODO - Esercizio 4\n",
    "\n",
    "Si nota che più è piccolo l'esponente più la formula dei trapezi diventa meno efficiente in relazione a quella di Simpson."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "syms x\n",
    "%{\n",
    "%------------\n",
    "% f = cos(x); a = 0; b = 2;\n",
    "% f = x * exp(x) * cos(x^2); a = -2; b = 0;\n",
    "alpha = 13/2;\n",
    "% alpha = 5/2;\n",
    "% alpha = 1/2;\n",
    "f = (sin(x))^alpha * cos(x); a = 0; b = pi/2;\n",
    "%------------\n",
    "\n",
    "f = function_handle(f);\n",
    "\n",
    "I_es = int(f, x, a, b);\n",
    "abs_es = abs(I_es);\n",
    "\n",
    "for k = 4:10\n",
    "    tol = 1 * 10^-k;   \n",
    "    [I_trap, N_trap(k - 3)] = trap_tol(f, a, b, tol);\n",
    "    err_rel_trap(k - 3) = abs(I_es - I_trap) / abs_es;\n",
    "    [I_simp, N_simp(k - 3)] = simp_tol(f, a, b, tol);\n",
    "    err_rel_simp(k - 3) = abs(I_es - I_simp) / abs_es;\n",
    "end\n",
    "\n",
    "N_val_trap = N_trap + 1;\n",
    "N_val_simp = N_simp.*2 + 1;\n",
    "%}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "error: __plt2vv__: vector lengths must match\n",
      "error: called from\n",
      "    __plt__>__plt2vv__ at line 482 column 5\n",
      "    __plt__>__plt2__ at line 242 column 14\n",
      "    __plt__ at line 107 column 18\n",
      "    semilogy at line 60 column 10\n",
      "warning: legend: plot data is empty; setting key labels has no effect\n",
      "warning: called from\n",
      "    legend at line 426 column 9\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "figure\n",
    "semilogy((4:10), err_rel_trap, \"bo-\", ...\n",
    "    (4:10), err_rel_simp, \"ro-\")\n",
    "xlabel(\"tolleranza 1 x 10^{-k}\")\n",
    "ylabel(\"errore relativo\");\n",
    "legend(\"trapezi\", \"simpson\");\n",
    "title(\"Confronto sull'accuratezza\")\n",
    "box off"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "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",
    "plot((4:10), N_trap, \"bo-\", (4:10), N_simp, \"ro-\")\n",
    "xlabel(\"tolleranza 1 x 10^{-k}\")\n",
    "ylabel(\"sottointervalli creati\");\n",
    "legend(\"trapezi\", \"simpson\");\n",
    "title(\"Confronto sul numero di sottointervalli richiesti\")\n",
    "box off"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "error: 'N_val_trap' undefined near line 1 column 14\n",
      "warning: legend: plot data is empty; setting key labels has no effect\n",
      "warning: called from\n",
      "    legend at line 426 column 9\n"
     ]
    },
    {
     "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/QiyQvpTNDAsAAAAJcEhZcwAACxMAAAsTAQCanBgAAAAfdEVYdFNvZnR3YXJlAEdQTCBHaG9zdHNjcmlwdCA5LjUzLjNvnKwnAAAb70lEQVR4nO3dP2zb+P3/8Y++vxs6yfZtBUIBcdF6oKY4N9jezg4golON2AK6VAIqZWq9WHGG+Ho4L8nRi9ApdoEz2iWSC+Om0oBVdBI1xL6JHNzicoCYqUNseeuk3/Dpl1+dRCmyoz9vW8/HEEgUP+RHHyl6+fMh+WGs2WwqAADG7X/GXQEAAJQikAAAQhBIAAARCCQAgAgEEgBABAIJACACgQQAEIFAAgCIQCABAEQgkNDu4uLi7Oxs3LUAMHEIJPyfs7OzlZWVTz/99OHDhzMzM3t7e9fdwtraWiwW29raulkFtra2KpXKzcq2qVQqsVhsUFsbhq2tLV3Dm9XzgwX7b8zr1uGD6/dYIfKl61ZggN8TiEIg4f+sra2dnZ29evXq5ORkdnb2yZMn1+0q/fWvf83lck+ePLlZBb7++uuTk5Oblb2l5ufnT05O5ufnB77l/hvzunX44PoD32CbCfyeTAgCCf91eHj4ww8/PHv2LJ/Pr6ysHB4eLi8v60Da2tqamZmJxWKzs7N6if6TNp/Px2KxWCym+1K6Y1SpVP74xz/qftLMzIzeeNsWehQ/PDzstlPt4uJiZWVFF1xZWbm4uFA//hNb9zw632DkTiML6oV6LzMzMy9fvtQ1CXt+es1wiV4/fL/dat5admZm5u3bt0qps7OzR48eta22trY2OzurH8/Ozq6trUW+69b31fYWwsb8xz/+0VYwrLzWVod+PuvOOre1QNsGO6tdLpdnZmbCXnjk+votdL7xzu9J6/q43ZpAs9lsNp8+faqUOjk5aVuu/xTN5XInJycPHjyYnp4OFz5+/Fgv1F+k09NTveaf//xnpdT9+/efPn0auYXexd+/fx+5U+3FixdKqXK5XC6XlVIvXrwId6ErH76RtrcTudPOgq0V1ruYnp4ul8uPHz/Wr3ZWQK+v32+PmjebzVevXimlnj59Wi6Xp6enI+sZrnZ6evr9998rpV69etW2U92L1QUj30LYmH/4wx/aCn7//fcnJyf66YMHD1oboc/Pulvbtn3i4V7C9xu2z/Ly8snJyf3791t3cXJy0tm2nUtavyeRXwbcXvSQ8AH6x2Jvb29lZeXZs2eXl5fh8P2TJ09WVlZWVlb0Uz3kMjMz89Of/lQp9fLly5cvX0Zu4bvvvutRfGZmpsdOw17I6elpuVy+7t/FbTvtYX19fW1tTVestcuif0lPT09PT0/DcA3fb4+aK6V0kZcvX66tremNR8rn8zoFddm1tTX9fk9PT3VW6aDqIWzML7/8sq3g7Ozs/Pz8ixcvpqenDw8PW0v1/1lHCj/x1verl6+trVUqlfX1db382bNnKysra2trl5eXbRVoa9vOj7vtexL5WeCWIpDwXw8fPlRK6XEk/WBlZeUG5zWEwvG6wcrn8ycnJ7pu6+vr4x2oyefz4Y9sP+/34uIiXK33+voX/OTk5PHjx3rYUH9A1z0+F1kwn89/9913lUolTNmB6P2O5ufnr3WoTLdt/x9362eBW4pAwn+trKxMT09vbW0dHh5WKpUXL178/e9/n52d/dnPfqaU0smkB16uewS+cws///nPr1sk3OnW1tarV69evnx5cXFx//79MEGVUmdnZ2/fvm37q78f1yo4Pz9/cXHx7NmzZ8+evX37tvVwTu+aK6UePnz4ww8/HB4efnB3jx490pnx6NEj9b9dB73Ha72FzoJbW1v63JOLi4tKpdJa/4//rNt8+umnSim9l9nZ2Xw+33v9zrbt8XFHrv8xtcX4jXvMEIKcnp7ev38//G68evVKL8/lcm0LI49bNJtNpVR4nKD1GEPbFroVDw+rRO40rKReTSmlR2mazeb79+/DhcvLy6r7cY62nXYWbFtTL28rog+lKKUePHgQHvEK99Wt5p1lI+sZ0hV7//59s9nUx0jCSrY2cuRbCIs/f/68raB+EGo7CtXPZ927bVufvn//Ptzd/fv39eGrzk+hdf22to38uMPvSef6H/6WQ7BYk1uY48fOzs4uLi7m5+dbR2AiF378Ztvoa3LDdXoU0cc2Wl/SZWdnZ687DHWzgpVKZWZmplsHoveb1WNl162n7gFE7jHyLYSNeXFx0a3gDSp/A3qD/Ry30zrbtu3jbvue9P4scIsQSAAAETiGBAAQgUACAIhAIAEARCCQAAAiEEgAABFGEUiNRiMIghHsCABwe40ikMrl8uvXr0ewIwDA7TX0QFpdXd3d3R32XgAAt93QA+no6Oi3v/3tsPcCALjtOKkBACDC+ANpbm6u7f6VAIAJ9Mm4K6CUUsynBwAYfw8JAAAlYbbvubm58/Pz8dYBADB29JAAACIQSAAAEQgkAIAIBBIAQAQCCQAgAoEEABCBQAIAiEAgAQBEIJAAACIQSAAAEQgkAIAIBBIAQAQCCQAgAoEEABCBQAIAiEAgAQBEIJAAACIQSAAAEQgkAIAIBBIAQAQCCQAgAoEEABCBQAIAiEAgAQBEIJAAACIQSAAAEQgkAIAIBBIAQAQCCQAgAoEEABCBQAIAiEAgAQBEIJAAACIQSAAAEQgkAIAIBBIAQAQCCQAgAoEEABCBQAIAiEAgAQBEIJAAACIQSAAAEQgkAIAIBBIAQAQCCQAgAoEEABCBQAIAiEAgAQBEIJAAACIQSAAAEQgkAIAIBBIAQAQCCQAgAoEEABCBQAIAiEAgAQBEIJAAACIQSAAAEQgkAIAIBBIAQAQCCQAgwiADyfO8RqPR/3IAAEIDC6RMJlMqlbLZrOu64cJGo7G6uloqlfS/g9oXAODuGUwgOY5jGMbOzk6xWNzb2wuXHx8fLyws7OzsHB0dOY4zkH0BAO6kTwayFc/zksmkUsowjFqtFi43TbNUKrmu6/u+aZoD2RcA4E4a2JCdYRj6wcLCQuvCeDzuOI7jOIlEolvZWItB1QcAcLsMpoeklAqCQD9o7SHt7e1ZlpVOp5VSy8vL+kGnZrM5qGoAAG6pwfSQkslkvV5XSgVBwNAcAOAGBtNDsixrf3/ftu1arZbL5ZRSrutms9lKpZLJZOr1uu/7qVRqIPsCANxJsQEOl7muaxhGeDDpg8u1ubm58/PzQdUBAHBLDTKQboZAAgAopg4CAAhBIAEARCCQAAAiEEgAABEIJACACAQSAEAEAgkAIAKBBAAQgUACAIhAIAEARCCQAAAiEEgAABEIJACACAQSAEAEAgkAIAKBBAAQgUACAIhAIAEARCCQAAAiEEgAABEIJACACAQSAEAEAgkAIAKBBAAQgUACAIhAIAEARCCQAAAiEEgAABEIJACACAQSAEAEAgkAIAKBBAAQgUACAIhAIAEARCCQAAAiEEgAABEIJACACAQSAEAEAgkAIAKBBAAQgUACAIhAIAEARCCQAAAiEEgAABEIJACACAQSAEAEAgkAIAKBBAAQ4ZNuL5RKpXq9nkgk4vH44uLi1NTUKKsFAJg00T0k27Ydx1FK1ev1d+/eZbPZ0dYKADBxogOpXC4Xi8WlpSWlVC6XM03Tdd3RVgwAMFmiAykej7c+DYKgbQkAAIMVfQwpn89ns1nTNIMg2NjYUEolk8nRVgwAMFlizWYz8gXP8/RhpEQikU6nh1eDubm58/Pz4W0fAHArRPeQbNsuFAphr6hUKpmmSScJADA87YHked7u7q7v+77vhwt93z86OhptxQAAkyV6yE73kEZTA4bsAACq9zGkq6sr/dhxHMuyFhcXh1EDAgkAoHocQ6rVao1GI5ygYXNzc4S1AgBMnOhAKpfLb968KZVKSql0Op3JZPrZlud5hmF0TjIUBIFSyjCMj6opAOBO6zqXnVLKMIxqtaqUMk3T9/3eQ3aZTMYwDN/3Nzc3W9fc3t5WSgVBYFnWUE8fBwDcatEzNayvr6+urpqmeXx8bNt2uVzu3b9xHMcwjJ2dnWKxuLe3Fy7XEw7p5Uw+BADooetJDa7rLi4u6stjl5aWenePbNsOr59tPUnBtu3p6Wk97VC37hEnNQAAVI/7IekESiaThUKhn/Prwi7UwsJC6/LXr18rper1eo8DUbEW/VUbAHDXRB9Daj3nW/tgJukzF5RStVqtdXkqldJ9o9XV1W5lu/XSAACTIzqQfN+v1+v6ca1W0/fo67GVZDLpeZ5SKggC0zTD5YlEItxOo9EYTJUBAHdRdCC1He/Z2NhovSapk2VZ+/v7+uqlXC6nlHJdN5vNnp+fr66u2rbt+34+nx9s1QEAd0nXkxpa2bb9wfMalFKu6xqG0Xk+XrflGic1AABUj7ns2iZXrVQqPXpIH4NAAgCobkN2lmXp+5drpmkOKY0AANCiA8lxnNbZvrkfEgBg2LgfEgBABO6HBAAQoetMDa1KpZK+zAgAgCFhyA4AIAJDdgAAEbpeGFsqler1eiKR0PMGDe+0bwIJAKC6HUOybdtxHKVUvV5/9+5dNpsdba0AABMnOpDK5XKxWNTXxuZyOdM0ub0eAGCoogNJ31IvFARB2xIAAAYreqaGfD6fzWZN0wyCYGNjQynFNA0AgKHqelKDvnm5Uiq8N/mQcFIDAEB19pD0Cd/6X3pFAICRaQ+kWq02NzenlPrTn/7UupxODABgqLgwFgAgQvtZdrZtj6UeAIAJx5AdAEAEhuwAACIwlx0AQATmsgMAiMBcdgAAEZjLDgAgAnPZAQBEYC47AIAIXQNpZAgkAIDqdgwJAIARI5AAACK0n9SQyWQ2Nzcdx/F9v3X5wcHB6CoFAJg87YGUz+cNw7AsS1+EBADAaLQH0uLiolJqeBMFAQAQKfo6pEaj0TZkp4MKAIAhiQ6kL774Qil17969cAmBBAAYquhAOj4+5togAMAoRZ/2vb6+7nneiKsCAJhk0T0kpZSeyy58ymnfAIChig6kdDptWdaIqwIAmGTRQ3Z6bu9qtVqtVn3fb+0qAQAwDF3vGLu7uzs9PZ1MJuv1OneMBQAMW/SQXblcrlQq+vJYy7I2NjY8z+OWSACA4enrjrEAAAxbdA8plUpls1nLsuLxuOd5QRDQPQIADFXXG/S5rlutVpVSiUQilUoNb3Y7btAHAFCdgTT6208QSAAAxe0nAABCcPsJAIAI0WfZZTIZ27Zbn46oOgCASRUdSEqpq6ur7e3tRqMxytoAACZW10Da2dlJJBLZbDYIglFWCAAwmbrO9q2UyuVypmkyXgcAGIHoHlI41ffi4mKxWOSqWADAsHW9/YTneVdXV/ppPB53XZe7mAMAhic6kGzbrtVqjUYjPP97c3NzhLUCAEycrrN9v3nzplQqKaXS6TSHkQAAw9b1LDullGEY9XpdKWWaZttMQgAADFZ0IK2vr6+urpqmeXx8bNt2uVw2DGPENQMATJRes30vLi56nuc4ztLS0vDOaGByVQCA6nELc51AyWSyUCgEQeB53mgrBgCYLO0nNXiet7u76/t+60Ej3/ePjo5GWzEAwGSJHrKzbbtQKIymBgzZAQBUt9O+LctyXbd1ST/HkDzPMwwj8tYVQRDE43HuagEA6CY6kHzf1yd8K6VqtVo8Hv9gIGUyGcMwfN/f3NxsW7nRaKyurr5582YgNQYA3Eldpw5qfbqxsdE6a0Mnx3EMw9jZ2QmCYHt7uy2Qdnd34/F47y0AACZcrwtjQ/fu3et9YazneXoCVsMwarVa60v7+/uJRKLbUB4AAFrXuezazrLL5/O9NxReObuwsBAu9DzP87xisVitVnuUjcVi4eNu10UBAO62ric1LC0thU9N0/xg/ya8j19rD2l/f//evXu2beuhvHw+HznjAyEEAGgPpG7zqB4cHPTYSjKZ1FfOBkFgmma4PJfL6XtY1Go1y7Li8fjH1RYAcGe1B9IHh+YiWZa1v7+vb1qRy+WUUq7rZrPZ8AKjfs7TAwBMsq5z2bXeoM9xHMuyPpgorusahnHdaVi5MBYAoAZ7gz76QACAG+MGfQAAEbhBHwBABG7QBwAQgRv0AQBEiA6kIAhG1iUikAAAqtuQ3d7e3vLy8v7+fjj/AgAAQ9V1yC4IguPjYz2N9+LiYtv83wNEDwkAoHoEkqbvaF6r1YaXGQQSAEB1uw5Jn8twfHycTCYtyyoWiyOuFgBg0kQHkuM409PTBwcHnO0NABiNDwzZjQBDdgAA1ecdYwEAGDYCCQAgAoEEABCBQAIAiEAgAQBEIJAAACIQSAAAEQgkAIAIBBIAQAQCCQAgAoEEABCBQAIAiEAgAQBEIJAAACIQSAAAEQgkAIAIBBIAQAQCCQAgAoEEABCBQAIAiEAgAQBEIJAAACIQSAAAEQgkAIAIBBIAQAQCCQAgAoEEABCBQAIAiEAgAQBEIJAAACIQSAAAEQgkAIAIBBIAQAQCCQAgAoEEABCBQAIAiEAgAQBEIJAAACIQSAAAEQgkAIAIBBIAQAQCCQAgAoEEABCBQAIAiEAgAQBEIJAAACIQSAAAEQgkAIAIgwwkz/MajUbk8iAIBrgjAMDd88mgNpTJZAzD8H1/c3NzcXFRL2w0Gtls1jTNIAhM0ywUCoPaHQDgjhlMD8lxHMMwdnZ2isXi3t5euLxcLi8sLOzs7BwcHBwfHw9kXwCAO2kwPSTP85LJpFLKMIxarRYuT6VS+kHkUB4AAKGBDdkZhqEfLCwstC10XXd3dzefz3crG4vFwsfNZnNQVQIA3CIDC6TwtIXWHpJSyrbtd+/eFYvFMLE6EUIAgMEEUjKZ9DxPKaVPXgiXl0olnUYD2QsA4A6LDap3srq6urCwUKvVcrmcZVmu62az2fX1dd/34/G4Xufg4KCz4Nzc3Pn5+UDqAAC4vQYWSEop13UNw+gxNBeJQAIAqAEeQ1JKhZcfAQBwXUwdBAAQgUACAIhAIAEARCCQAAAiEEgAABEIJACACAQSAEAEAgkAIAKBBAAQgUACAIhAIAEARCCQAAAiEEgAABEIJACACAQSAEAEAgkAIAKBBAAQgUACAIhAIAEARCCQAAAiEEgAABEIJACACAQSAEAEAgkAIAKBBAAQgUACAIhAIAEARCCQAAAiEEgAABEIJACACAQSAEAEAgkAIAKBBAAQgUACAIhAIAEARCCQAAAiEEgAABEIJACACAQSAEAEAgkAIAKBBAAQgUACAIhAIAEARCCQAAAiEEgAABEIJACACAQSAEAEAgkAIAKBBAAQgUACAIhAIAEARCCQAAAiEEgAABEIJACACAQSAEAEAgkAIAKBBAAQgUACAIhAIAEARBhFIHme12g0RrCjuy0Wi427CrcGbdU/2qp/tFWfbtxQQw+kTCZTKpWy2azrusPeFwDg9vpkqFt3HMcwjJ2dnSAItre3FxcXh7o7AMDtNdwekud5yWRSKWUYRq1WG+q+AAC3WqzZbA5v67ZtLy0t6Y5RJpM5ODjoXGdubm54FQAAjMX5+fl1iwx3yE4pFQSBftCth/TPf/6z9elQA/JWi8WG+9fDXUJb9Y+26h9t1acbN9Rwh+ySyWS9XldKBUFgmmbkOs0fG2p9bjUap3+0Vf9oq/7RVn26cUMNPfBXV1cXFhZqtVoul7Msa6j7AgDcXqPogbquaxiGYRjD3hEA4PZiSBQAIMKYpw5iEofeurWP53nh2SLQenyXgiDgaxbq3VB8r1r1aCt+u3poNBo3+yL9vy+//HLQlelXJpMJgmB/f58BvUiR7dNoNH7961//+9///vbbb//1r38tLS2Nt5JC9PguNRqNX/7yl7/73e/GVTdRejTU9vb22dnZt99++5///EdfPjjhurVV+H9wd3f3Jz/5CW3V6S9/+cvp6elNfp2aY/K3v/3t+fPnzWazXq//5je/GVc1xOrWPnt7e19//bV+/Pnnn4+lbtL0/i49f/78888/v7y8HEPNhOnRUNVqVb90eXn5+9//fizVE6VHW71+/Vr/H7y8vOS3q9OvfvWrX/ziF+HP1LUM/TqkbpjEobdu7ZNKpfQDhgtCPb5L+/v7iUQiCIKpqakx1U6QHg1VrVYTiUSpVFJKFYvF8dRPkh5tZZpmqVRyXdf3/W5Xs0yyo6Mj27ZvVnacx5DCXvDCwsIYqyFWZPvo0QPXdbPZbD6fH1PVxIlsK8/zPM/L5XJjqpREPf7TvX79WilVr9czmcyIayVTt7YyDCMejzuO4zhOIpEYR9XurLH1kFQfkzhMuG7tY9v2u3fvisUiB95CkW21v79/794927b13L75fJ4W6/GfLpVKpdNppdTq6uqoqyVSt7ba29uzLEu31fLysn6AgRhbD6mfSRwmWbf2KZVKpFGbbm2Vy+WWlpaWlpampqYsy4rH4+Orowg9/tO1/qXPaLDiB2pMxnkdEpM49NbaPlNTU9ls9vz8fHt72/f98Lc1cr7aCRTZVuGr3Sb2nUBt/+n02K9uK/2S7/vhn/8TrltbBUGQyWRSqZQ+hlQoFMZdU3H0MaQbtMyYL4xlEofeaJ/+0VZ96tFQtGEb2mrEmKkBACDCmGdqAABAI5AAACIQSMAd57ouM9ThViCQgDuuWq0SSLgVCCRgIjQaje3tba4xgmQEEnD3NRqNjY2NdDrNnH6QbJxTBwEYHtd1q9WqvgVAqVS6urriRgkQjh4SJoXned1ecl03k8nof0dYox/Z2Nj4yFKlUml5efmzzz7Tk3YvLi4WCoXFxUWlVD6ftyzrxnMwA6NBIGFS7O7ujrsK0UqlUiaTue7RnbZSQRDs7u4eHR1VKpW9vb3OsxhyuZzv+5zdAMkIJEwE27Z93w+7CLZtLy8vLy8vd+s0hL0NvYLneToAbNu2bfuzzz5rfWl7e3t7e3tubm5jY0MnhF5Z06u1lWplmmbkvTUdx9nf31dKBUHQ2X9qK+W6biqVmpqampqaSqVSx8fH4UthP+ng4ICpbiAZgYSJUCgUwnkwXdet1WpHR0dHR0e1Ws113baVdfzo3obv+/oAzO7ubj6fX1paqtVqb968efPmTa1W8zzv6urq+Pg4nU7rKUp931dKpdPpg4ODMAD0HltLte4umUxGzidtWZbjODrwOmc7bStVr9dbpzO/vLz8mOYCxoKTGjBxqtWqZVn6fDPLssIj/yHHcUzT1NFimma9XjcMwzRN3c/45ptv9KWmjUbj6upKr6PPF7h3717rdnT/RqdgZ6l+fPXVV9lsdn19Xe8auNvoIWEShZ2JtggJBUFQrVar1ar68b2CPM9bXV3Vy3ufQu26ruM4m5ub1yrVpv+Vp6en+98sIBOBhImTSCTCQTPXdTt/yhOJxNTUVKFQKBQK09PTrUNhjuOkUqlCodD7jkF6nK1YLOpE6bNUJ72RzlG+TvrOPfqxvqfRtXYESMCQHSaFPhqUTqdTqZQ+6WBqaioIgs3NTT06F0qn047jZDIZwzB83//mm2/CFZaWlvT5BXqJ4ziRP/16sG57e1s/zefzbaX6GYKzbVuPE3711VdffPHF0dFRj5X1ISW9F8MwuOQItxH3Q8Kk0Mdvwl9q3efo8cOtT1joTI4gCMLbWvu+3+fRnZuVuq4PvilAMgIJACACx5AAACIQSAAAEQgkAIAIBBIAQAQCCQAgAoEEABCBQAIAiEAgAQBEIJAAACIQSAAAEf4/fVRuZMaeFxEAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "figure\n",
    "plot((4:10), N_val_trap, \"bo-\", (4:10), N_val_simp, \"ro-\")\n",
    "xlabel(\"tolleranza 1 x 10^{-k}\")\n",
    "ylabel(\"valutazioni effettuate\");\n",
    "legend(\"trapezi\", \"simpson\");\n",
    "title(\"Confronto sul numero di valutazioni richieste\")\n",
    "box off"
   ]
  }
 ],
 "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
}