{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Parte 5\n",
    "\n",
    "Preparazione dei codici relativi all'applicazione del metodo di eliminaziona gaussiana e sua equivalente fattorizzazione con/senza pivoting."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduzione"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A =\n",
      "\n",
      "  -1.916873   0.226273   0.817641  -0.095036  -1.012522\n",
      "   0.526588  -2.179062  -0.429756   0.230489  -0.241151\n",
      "   0.433757  -0.531894  -0.983162   1.003970  -0.203830\n",
      "  -0.739108   0.107111   0.848587   0.811920  -0.847591\n",
      "   0.652750   0.427549   0.274736  -0.088849   0.846899\n",
      "\n"
     ]
    }
   ],
   "source": [
    "A = randn(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L =\n",
      "\n",
      "  -1.91687   0.00000   0.00000   0.00000   0.00000\n",
      "   0.52659  -2.17906   0.00000   0.00000   0.00000\n",
      "   0.43376  -0.53189  -0.98316   0.00000   0.00000\n",
      "  -0.73911   0.10711   0.84859   0.81192   0.00000\n",
      "   0.65275   0.42755   0.27474  -0.08885   0.84690\n",
      "\n"
     ]
    }
   ],
   "source": [
    "L = tril(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L_2 =\n",
      "\n",
      "   1.00000   0.00000   0.00000   0.00000   0.00000\n",
      "   0.52659   1.00000   0.00000   0.00000   0.00000\n",
      "   0.43376  -0.53189   1.00000   0.00000   0.00000\n",
      "  -0.73911   0.10711   0.84859   1.00000   0.00000\n",
      "   0.65275   0.42755   0.27474  -0.08885   1.00000\n",
      "\n"
     ]
    }
   ],
   "source": [
    "L_2 = tril(A, -1) + eye(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "U =\n",
      "\n",
      "  -1.91687   0.22627   0.81764  -0.09504  -1.01252\n",
      "   0.00000  -2.17906  -0.42976   0.23049  -0.24115\n",
      "   0.00000   0.00000  -0.98316   1.00397  -0.20383\n",
      "   0.00000   0.00000   0.00000   0.81192  -0.84759\n",
      "   0.00000   0.00000   0.00000   0.00000   0.84690\n",
      "\n"
     ]
    }
   ],
   "source": [
    "U = triu(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dato il sistema lineare:\n",
    "\n",
    "\n",
    "$$\\begin{cases} 2x = 2 \\\\ 3x + 5y = 8 \\end{cases}$$\n",
    "\n",
    "Verificare che la sua soluzione è: $[1, 1]$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A =\n",
      "\n",
      "   2   0\n",
      "   3   5\n",
      "\n",
      "b =\n",
      "\n",
      "   2\n",
      "   8\n",
      "\n",
      "x =\n",
      "\n",
      "   1\n",
      "   1\n",
      "\n"
     ]
    }
   ],
   "source": [
    "A =  [2 0; 3 5] % matrice dei coefficienti\n",
    "b = [2; 8] % vettore dei termini noti\n",
    "\n",
    "[x] = linsolve(A, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Algoritmi per il metodo di eliminazione gaussiana"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Gauss semplice\n",
    "Calcola la fattorizzazione LU usando l'algoritmo di Gauss senza strategie di pivoting.\n",
    "\n",
    "    [L, U, err] = gauss_simple(A)\n",
    "\n",
    "Input:\n",
    "- `A`: matrice da fattorizzare.\n",
    "\n",
    "Output:\n",
    "- `L`, `U`: matrici risultanti dalla fattorizzazione LU,\n",
    "- `err`: flag che comunica se si sono verificati degli errori."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "function [L, U, err] = gauss_simple(A)\n",
    "\n",
    "    [n,m] = size(A);\n",
    "    err = 0;\n",
    "\n",
    "    if n ~= m, \n",
    "        disp(\"A must be a square matrix!\"), \n",
    "        L = []; \n",
    "        U = []; \n",
    "        P = []; \n",
    "        err = 1; \n",
    "        return, \n",
    "    end\n",
    "\n",
    "    U = A;\n",
    "\n",
    "    for k = 1:n-1\n",
    "\n",
    "        if U(k,k) ==  0,\n",
    "            disp(\"There is a null diagonal element!\"), \n",
    "            L = []; \n",
    "            e = 1; \n",
    "            return, \n",
    "        end\n",
    "\n",
    "        % Eliminazione gaussiana\n",
    "\n",
    "        % crea i moltiplicatori\n",
    "        U(k+1:n, k) = U(k+1:n, k) / U(k, k);\n",
    "        % calcola la sottomatrice n-esima\n",
    "        U(k+1:n, k+1:n) = U(k+1:n, k+1:n) - U(k+1:n, k) * U(k, k+1:n);\n",
    "    end\n",
    "\n",
    "    L = tril(U, -1) + eye(n); % Estrae i moltiplicatori \n",
    "    U = triu(U);           % Estrae la parte triangolare superiore + diagonale\n",
    "end  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A =\n",
      "\n",
      "   -5    2    1    8\n",
      "   20   -5   -3  -28\n",
      "  -30   18    7   54\n",
      "  -15   27    5   51\n",
      "\n",
      "ans =\n",
      "\n",
      "  -4\n",
      "   6\n",
      "   3\n",
      "\n",
      "A =\n",
      "\n",
      "   -5    2    1    8\n",
      "   -4    3    1    4\n",
      "    6    6    1    6\n",
      "    3   21    2   27\n",
      "\n"
     ]
    }
   ],
   "source": [
    "A = [-5 2 1 8; 20 -5 -3 -28; -30 18 7 54; -15 27 5 51]\n",
    "A(2:4, 1);\n",
    "A(2:4, 1) = A(2:4, 1) / A(1,1);\n",
    "A(2:4, 1)\n",
    "\n",
    "A(2:4, 2:4) = A(2:4, 2:4) - A(2:4, 1) * A(1, 2:4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Gauss parziale\n",
    "\n",
    "Calcola la fattorizzazione LU usando l'algoritmo di Gauss con strategia di pivoting parziale.\n",
    "\n",
    "    [L, U, P, err] = gauss_simple(A)\n",
    "\n",
    "Input:\n",
    "- `A`: matrice da fattorizzare.\n",
    "\n",
    "Output:\n",
    "- `L`, `U`: matrici risultanti dalla fattorizzazione LU,\n",
    "- `P`: matrice di permutazione delle righe,\n",
    "- `err`: flag che comunica se si sono verificati degli errori."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "function [L, U, P, err] = gauss_partial(A)\n",
    "\n",
    "    [n,m] = size(A);\n",
    "    err = 0;\n",
    "    \n",
    "    if n ~= m, \n",
    "        disp('errore: matrice non quadrata'),  \n",
    "        L = []; \n",
    "        U = []; \n",
    "        P = []; \n",
    "        err = 1;\n",
    "        return,\n",
    "    end\n",
    "\n",
    "    U = A; \n",
    "    P = eye(n);\n",
    "    \n",
    "    for k = 1:n-1\n",
    "    \n",
    "    % Scelta pivot parziale + scambi su U e P\n",
    "    [pivot, ir_pivot] = max(abs(U(k:n, k))); \n",
    "    ir_pivot = ir_pivot + (k-1); \n",
    "    \n",
    "    if pivot == 0, \n",
    "        disp('pivot nullo'),\n",
    "        L = []; \n",
    "        err = 1;\n",
    "        return, \n",
    "    end\n",
    "    \n",
    "    if ir_pivot  ~= k\n",
    "        temp = U(k,:);\n",
    "        U(k,:) = U(ir_pivot,:);\n",
    "        U(ir_pivot,:) = temp;\n",
    "        \n",
    "        temp = P(k,:); \n",
    "        P(k,:) = P(ir_pivot,:); \n",
    "        P(ir_pivot,:) = temp;\n",
    "    end\n",
    "\n",
    "    % Eliminazione gaussiana\n",
    "    U(k+1:n, k) = U(k+1:n, k) / U(k, k); % Memorizza i moltiplicatori\n",
    "    U(k+1:n, k+1:n) = U(k+1:n, k+1:n) - U(k+1:n, k) * U(k, k+1:n);\n",
    "    end\n",
    "\n",
    "    L = tril(U,-1) + eye(n); % Estrae i moltiplicatori \n",
    "    U = triu(U);           % Estrae la parte triangolare superiore+diagonale\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Gauss totale\n",
    "\n",
    "Calcola la fattorizzazione LU usando l'algoritmo di Gauss con strategia di pivoting totale.\n",
    "\n",
    "    [L, U, P, Q, err] = gauss_simple(A)\n",
    "\n",
    "Input:\n",
    "- `A`: matrice da fattorizzare.\n",
    "\n",
    "Output:\n",
    "- `L`, `U`: matrici risultanti dalla fattorizzazione LU,\n",
    "- `P`: matrice di permutazione delle righe,\n",
    "- `Q`: matrice di permutazione delle colonne,\n",
    "- `err`: flag che comunica se si sono verificati degli errori."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "function [L, U, P, Q, err] = gauss_total(A)\n",
    "\n",
    "    [n, m]=size(A);\n",
    "    err = 0;\n",
    "\n",
    "    if n ~= m, \n",
    "        disp('errore: matrice non quadrata'),  \n",
    "        L = []; \n",
    "        U = []; \n",
    "        P = []; \n",
    "        Q = []; \n",
    "        err = 1;\n",
    "        return,\n",
    "    end\n",
    "\n",
    "    U = A;\n",
    "    P = eye(n);\n",
    "    Q = eye(n);\n",
    "    for k = 1:n-1\n",
    "\n",
    "        % Scelta pivot totale + scambi su U, P e Q \n",
    "        [temp_pivot, temp_ir_pivot] = max(abs(U(k:n, k:n)));\n",
    "        [pivot, ic_pivot] = max(temp_pivot);\n",
    "        ir_pivot = temp_ir_pivot(ic_pivot) + k - 1;\n",
    "        ic_pivot = ic_pivot + k - 1;\n",
    "        \n",
    "        if pivot == 0,\n",
    "            disp('pivot nullo'),\n",
    "            L = [];\n",
    "            err = 1;\n",
    "            return,\n",
    "        end\n",
    "        \n",
    "        if ir_pivot ~= k\n",
    "            temp = U(k,:); \n",
    "            U(k,:) = U(ir_pivot,:); \n",
    "            U(ir_pivot,:) = temp;\n",
    "            \n",
    "            temp = P(k,:); \n",
    "            P(k,:) = P(ir_pivot,:); \n",
    "            P(ir_pivot,:) = temp; \n",
    "        end\n",
    "        \n",
    "        if ic_pivot ~= k\n",
    "            temp = U(:,k); \n",
    "            U(:, k) = U(:, ic_pivot);\n",
    "            U(:, ic_pivot) = temp;\n",
    "            \n",
    "            temp = Q(:, k); \n",
    "            Q(:, k) = Q(:, ic_pivot);\n",
    "            Q(:, ic_pivot) = temp;\n",
    "        end\n",
    "        \n",
    "        U(k+1:n, k) = U(k+1:n, k) / U(k,k);\n",
    "        U(k+1:n, k+1:n) = U(k+1:n, k+1:n) - U(k+1:n, k) * U(k, k+1:n);\n",
    "    end\n",
    "\n",
    "    L = tril(U,-1) + eye(n); % Estrae i moltiplicatori\n",
    "    U = triu(U);           % Estrae la parte triangolare superiore+diagonale\n",
    "\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### L solve\n",
    "Applicazione del **metodo di sostituzione in avanti** nell'ambito della fattorizzazione LU. Restituisce il vettore delle soluzioni `x` risolvendo il sistema lineare `Lx = b`.\n",
    "\n",
    "    [x, err] = lsolve(L, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "function [x, err] = lsolve(L, b)\n",
    "\n",
    "err = 0;\n",
    "[n, m] = size(L);\n",
    "\n",
    "if n ~= m\n",
    "    printf('La matrice L non è quadrata!');\n",
    "    x = [];\n",
    "    err = 1;\n",
    "    return\n",
    "end\n",
    "\n",
    "% se almeno un elemento è nullo allora il risultato è false\n",
    "if ~all(diag(L))\n",
    "    printf('La matrice non è singolare');\n",
    "    x = [];\n",
    "    err = 1;\n",
    "    return\n",
    "end\n",
    "\n",
    "x = zeros(n,1); % preallocazione\n",
    "\n",
    "% risoluzione forward\n",
    "for i= 1:n\n",
    "    s = L(i, 1:i - 1) * x(1:i - 1);\n",
    "    x(i) = (b(i) - s) / L(i, i);\n",
    "end\n",
    "\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### U solve\n",
    "\n",
    "Applicazione del **metodo di sostituzione all'indietro** nell'ambito della fattorizzazione LU. Restituisce il vettore delle soluzioni `x` risolvendo il sistema lineare `Ux = b`.\n",
    "\n",
    "    [x, err] = usolve(U, b)\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "function [x, err] = usolve(U, b)\n",
    "\n",
    "err = 0;\n",
    "[n, m] = size(U);\n",
    "\n",
    "if n ~= m\n",
    "    printf('La matrice U non è quadrata!');\n",
    "    x = [];\n",
    "    err = 1;\n",
    "    return;\n",
    "end\n",
    "\n",
    "% se almeno un elemento è nullo allora il risultato è false\n",
    "if ~all(diag(U))\n",
    "    disp('La matrice non è singolare');\n",
    "    x = [];\n",
    "    err = 1;\n",
    "    return;\n",
    "end\n",
    "\n",
    "x = zeros(n,1); % preallocazione\n",
    "\n",
    "% risoluzione backward (si specifica il passo -1)\n",
    "for i = n:-1:1\n",
    "    s = U(i, i + 1:n) * x(i + 1:n);\n",
    "    x(i) = (b(i) - s) / U(i, i);\n",
    "end\n",
    "\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LU solve\n",
    "\n",
    "Risolve un sistema lineare tramite matrici ottenute a partire dalla fattorizzazione LU.\n",
    "\n",
    "    [x, err] = lusolve(L, U, P, Q, b) \n",
    "\n",
    "Restituisce il vettore delle soluzioni x a partire dal vettore dei termini noti b e dalla matrice dei coefficienti A fattorizzata.\n",
    "\n",
    "P e Q, ottenute con la fattorizzazione parziale o totale, sono opzionali."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "function [x, err] = lusolve(L, U, P, Q, b)\n",
    "\n",
    "if isempty(P) && isempty(Q)\n",
    "    [y, err] = lsolve(L, b);\n",
    "    if ~err\n",
    "        [x, err] = usolve(U, y);\n",
    "    else\n",
    "        return\n",
    "    end\n",
    "elseif isempty(Q)\n",
    "    Pb = P * b;\n",
    "    [y, err] = lsolve(L, Pb);\n",
    "    if ~err\n",
    "        [x, err] = usolve(U, y);\n",
    "    else\n",
    "        return\n",
    "    end\n",
    "else\n",
    "    Pb = P * b;\n",
    "    [z, err] = lsolve(L, Pb);\n",
    "    if ~err\n",
    "        [y, err] = usolve(U, z);\n",
    "        x = Q * y;\n",
    "    else\n",
    "        return\n",
    "    end\n",
    "end\n",
    "\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Esercizio\n",
    "\n",
    "Tramite verifica dell'accuratezza e dei tempi di esecuzione si vuole definire il grado di stabilità del metodo di eliminazione gaussiana con e senza pivoting e sia in caso di pivoting parziale che totale. Inoltre si vogliono confrontare le prestazioni di questi metodi rispetto alla funzione di libreria built-in `\\`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "nmin = 100;\n",
    "nmax = 200;\n",
    "P = [];\n",
    "Q = [];\n",
    "\n",
    "x_n = (nmin : nmax); % campionamento di x\n",
    "\n",
    "% gli errori relativi per ciascuna iterazione, per ciascun metodo,\n",
    "% sono memorizzati in appositi vettori tramite preallocazione\n",
    "err_rel_1 = zeros(1,length(x_n));\n",
    "err_rel_2 = zeros(1,length(x_n));\n",
    "err_rel_3 = zeros(1,length(x_n));\n",
    "err_rel_4 = zeros(1,length(x_n));\n",
    "\n",
    "% i tempi di calcolo per ciascuna iterazione, per ciascun metodo,\n",
    "% sono memorizzati in appositi vettori tramite preallocazione\n",
    "toc_1 = zeros(1,length(x_n));\n",
    "toc_2 = zeros(1,length(x_n));\n",
    "toc_3 = zeros(1,length(x_n));\n",
    "toc_4 = zeros(1,length(x_n));\n",
    "\n",
    "for n = nmin:nmax\n",
    "    \n",
    "    A = gallery('orthog', n, 1); % matrice di test\n",
    "    xesatta = (1 : n)'; % calcolo soluzione esatta\n",
    "    b = A * xesatta; % calcolo termine noto\n",
    "    \n",
    "    % 1. calcolo soluzione con gauss semplice\n",
    "    tic\n",
    "    [L_1, U_1, err_1] = gauss_simple(A);\n",
    "    \n",
    "    if ~err_1\n",
    "        [x_1, err_11] = lusolve(L_1, U_1, P, Q, b);\n",
    "        toc_1(n - nmin + 1) = toc;\n",
    "        if ~err_11\n",
    "            err_rel_1(n - nmin + 1) = norm(xesatta - x_1) / norm(xesatta);\n",
    "        end\n",
    "    end\n",
    "    \n",
    "    % 2. calcolo soluzione con gauss con pivoting parziale\n",
    "    tic\n",
    "    [L_2, U_2, P_2] = gauss_partial(A);\n",
    "    [x_2] = lusolve(L_2, U_2, P_2, Q, b);\n",
    "    toc_2(n - nmin + 1) = toc;\n",
    "    \n",
    "    err_rel_2(n - nmin + 1) = norm(xesatta - x_2) / norm(xesatta);\n",
    "    \n",
    "    % 3. calcolo soluzione con gauss con pivoting totale\n",
    "    tic\n",
    "    [L_3, U_3, P_3, Q_3] = gauss_total(A);\n",
    "    [x_3] = lusolve(L_3, U_3, P_3, Q_3, b);\n",
    "    toc_3(n - nmin + 1) = toc;\n",
    "    \n",
    "    err_rel_3(n - nmin + 1) = norm(xesatta - x_3) / norm(xesatta);\n",
    "    \n",
    "    % 4. calcolo soluzione con funzione built-in\n",
    "    tic\n",
    "    x_4 = A \\ b;\n",
    "    toc_4(n - nmin + 1) = toc;\n",
    "\n",
    "    err_rel_4(n - nmin + 1) = norm(xesatta - x_4) / norm(xesatta);\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Rappresentazione grafica dei risultati"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "figure(1)\n",
    "semilogy(x_n, err_rel_1, 'r--', ...\n",
    "        x_n, err_rel_2, 'ro--', ...\n",
    "        x_n, err_rel_3, 'g.-', ...\n",
    "        x_n, err_rel_4, 'b.-');\n",
    "\n",
    "title(\"Metodo di eliminazione di Gauss\");\n",
    "legend(\"nopivot\",\"pivot-parziale\",\"pivot-totale\", \"built-in\", ...\n",
    "    'location','eastoutside');\n",
    "xlabel('ordine n'); \n",
    "ylabel('errore relativo');\n",
    "box off;\n",
    "warning (\"off\", \"Octave:negative-data-log-axis\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "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/QiyQvpTNDAsAAAAJcEhZcwAACxMAAAsTAQCanBgAAAAfdEVYdFNvZnR3YXJlAEdQTCBHaG9zdHNjcmlwdCA5LjUzLjNvnKwnAAAgAElEQVR4nO3dMWgj6f3/8ce/f4pUtrVl8BiihdtCgsBpm7W7OxksUoSYWF7SxIZbLSkS/+Bvn1zcHmG3sVYu4iaw48AupFnJIC5NtKC5dJYhsYofSMXeYR1YS4oQTit3v8q/4slN5kYjaSyNRs/MvF/FIo3Goxl7rY+/z/PM88zd3NwIAABm7b9mfQIAAAhBIAEAFEEgAQCUQCABAJRAIAEAlEAgAQCUQCABAJRAIAEAlEAgAQCUQCABAJRAIMED6XR67vvy+fzkhzUMY25uzjAMx1fz+fzc3NzI3cY7+OT7A7itH8z6BBAGhUKh2+2Wy+WTk5PDw8NUKhWPxyc/bCqVqtVqqVTKk90AKI4KCR5IpVLpdDoWi5mPZSDJIsYsmGSRIcupWCxWKBRisZh8Vb60ubkpX9J1XQjRaDTW1tYajYb1veQxY7FYu92WW4bsJt+u2+12u12zjJNbhuwst8hzi8fjtiOPfBXAeAgkTEuhUHj+/Hm5XC6Xy8+fPy8UCnJ7PB4vl8vv378/PDzUdf0Xv/jF8+fP5UvtdrtWq8Xj8Xw+b8sMSdf158+ff/rpp7quD2k9Oz09lbuVy+VGoyHf6Msvv5Qn8+WXX56eng7Z2TCM58+fb25u1mq1WCyWTqetBx/+KoCx0WSHaanVaj/+8Y8vLi6EEIuLi2arWjablR/iqVRqc3NT7iAVCoV0On1wcJDNZh0rj4uLi8XFRZlttVrt5OTE8a3lMeVuslaTdZuMHCHE5eWl2ajYv3O5XBZCyCpNnow1/Gq1Wv+rxBIwOSok+CGXy2WzWZc7y6Y/R91u13x1yG5WqVQqlUoVCoX79+8LIR4/fjxyZ5fnCcBbBBKmJZVKdbvdg4ODg4ODdrvt2ARnI0uTFy9eyC/v3+H+/fvffPPN6elpu922NrvZ3LlzRwhhGEa3243H47lcTpZr8kxG7nz37l3xXQ1ULpcXFxetJzP8VQBjo8kO03JwcGAYhvy4//DDD3VdH9n/32g05EjuFy9eOBZAuVyuXC7LYuvDDz/85ptvHI8jE2htbU0IIXOo0Whks9k7d+58/PHHI3eOx+MXFxePHz+W5ZTtZHK53JBXAYxtjiXMMVWGYcRisZE1hGEYa2trsnsmHo8PHzVuGMbIfYQQjUZDDq6TT2WVNuhMbDubW1KplGPeDH8VwBgIJCjBDCRGBwCRRR8SlBCPxz/99FNPbqcFEFBUSAAAJVAhAQCU4F8gDbqHEQAA4U8gdTqdjY2Ns7MzH94LABBQfgSSpmmVSsWHNwIABNekgdTr9Tqdjvm02Wz2ej35uFQqFYtF66sAAAwy6UwNctrm/f19IcT29ramaa1Wa29vb2VlZWtry4szBABEwkQV0sbGxtHRkXxcrVY1TXv27Nnx8bGc5gsAAPcmCqRKpfLJJ5/Ix81mM5lMCiE0TTs/P+/f+dWrV5O8FwAg3Lwc1KBpmnzw4MED91917969OQsPzwcAECBezvZtjl9wrJCGYLYIAIBnFVIymby6uhJCdDqdRCLh1WEBABHhWYWUyWROTk6KxeL5+fmjR4+8OiwAICI8nly1Xq9rmmZ2Jrlx7969t2/fengOAIAg8njF2JWVFW8PCACICGb7BgAogUACACiBQAIAKIFAAgAogUACACiBQAIAKIFAAgAogUACACiBQAIAKIFAAgAogUACACiBQAIAKIFAAgAogUACACiBQAIAKIFAAgAogUACACiBQAIAKIFAAgAogUACACiBQAIAKIFAAgAogUACACiBQAIAKIFAAhB13/45/u2f47M+C4gfzPoEAGDqhufNnZ+1fTsTDEEgAZgKmQH+f9Y7Zg+REwgEEoBbGxk23/45Ll+1xoMnqTCybY3sCS4CCYCXbFlljQfrS26CilonaggkALdjrX5s8dC/xcoaRf1BNWh/RMfczc3NbM/g3r17b9++ne05AHDJFjm2pjkiBJOgQgIwvjs/axNF8AqBBGAgW0+PY4scUQSvEEhAdPWPLLB15zi2zgFTQiAB4TdoHMHwLTakEaaNQAKUM6gW6R+NNjIk+kda0/IGZRFIgIps9cqg8sWMqEGjqK3bB43VBhTBsG9ALdbAcMybQV9lPiZvEFAEEqAQyhdEGctPAKogjRBx9CEBXrrVXaJDxlgDEUQgAf82YYEyaObQIUggwIpAAr43Hlr0jW0TQ4e3mfrHswG4FQIJUWctjGz1jeOoa6ZuA6aEUXaInLF7bogiYKqokBAYI28CFe66cMZOFKIImCoCCcFgu110yAJxguQAgokmO6jOMWMIHoznq80fCSE+OP3HrE8EDqiQoKjhs+YQRbgtaxTJxzak1MwRSFAFd4mGwFebPxrvY31k4eIyQhx369+Z7FETgQQ/DJ/6k/a3MHGfSdbwsBUutiMMOmZ//JA0gUYfEqZr0EJwVkRROJix0Z8ft20is+1PzEQEgYSpcL9uAsLBFkLWcBIkCtyhyQ63Nqj9jSV5YPrg9B9EEW6LQMK/uZwPVBBCkTS8DW1QHw9phFuhyQ5CsBIPBhgyysD6lOCBJ6iQPDaTT3Y3HTaOJ0ZPT1C4HM3suP+gtOgPFfeD1kggTAOB5D0/M2nQcgn9zLUVbBund27wxOQ36AwKM5fNboBvaLLzkowifwKJe3dCj0EBiBoqJO95mEn9kxfQyBYR1CuIIALJM54sgG3TP6MoORQyLtvTgCggkKbCfZF0q4qHNAoHNyMOgAgikHwyaAYdMiYc3IxPGzSEGoBEIHmjvx6yjWrrX8mUKAoi9y1szPsJ3BaBNEX9kUMIzcSQm3huy32oED/AbRFIroycVoek8cdtR0IzchoIEALpP4bfVernmaDfyOU+HRFFsJnb+6v5+OboI9vTWZwR/oNAEoLxBcqz3ZRDzITS3N5fpxoJMnusbzHtd8RtRTSQWC07KGhziwIzKoYkhLWUcWlkAUQaqSZygUQx5LPh99wMmTSaKIoIawiZESK3TNieRgEUOCGfy47pRGfF8Z4ba8ubY95wx2jo9Rc6jpnR37yGKAhJIHHbqTqGVzbcHBoCYxQu5peQMRhCiSa7IbPsjCxxrMHDbadTMnxUm23k2/CkIYeCyFbW2MYFOH6JuQ+1DtxTpUIatHzckDXlJILHWyMX1xn0JSRNmAxJoNsegSiCe0pUSP2GNLiRQFMydq4QRcEyJCo8TBFyCGNQJZDM6bEj2/fjeeeK+wNS4kRBf9i4HF8A+EaVQJIivt6P2RkzSTb059DIeQ2IonAb1ItD/EA1qvQhzfYcZs4WQkNKlv6R0zakSygNGtg2fMAbAwoQLGpVSJAcSyUzpRg5HR2OnTpuwqn/VUB9VEizN6SNjhtFo8Nx/DSJgkihQpoBW7PbkKQhhMJn5I07QGQRSGNyMzJt0PgCa7MbFOdhNww9OsBwBNI4zLJmUHeOLa76d6P0CQRzds5BM35aDZmTbcgOAEz0If3HJMu+DZm1GkHkWM0ML3HoBAImRCD924R3/0BlLudbc3wJgG9osmOegjBzWdMQP4AKQhJIt6pvaF4LqPHWDB37VQA+C0MgyTRymUk0zQUR49OAKAhYIPU3r5kBY46ldhxUbX3Vv9PFxIgiIDoUDaRB61vb5tSxlTtDJielMJo5W4eNm/4bc9Q1gChQcZSdY964n34UqrFVOY5PhdNdPqQREClKVEjup9IxMdnBVHk7PYHtOIOe0joHRJwqFdKQKQ/cD1iAJ2zTE/Qb3shm3Y02NwDuqRJIQ3YgjfzkJkKGDL+2rYZAGgFwLwCBhJE8aeyixQzAbCnRh4RJWFvY3MRJf/AQRQBUQCAFmzWEhvTZ9A9dYzAbANXQZBdgjvEzfIw1ACiLCikwXM5I7f62UwBQCoGkFpcD2EYihwAEDoE0Re6byyhoAIBAGtPIsHFc/br/CBI5BAAE0jiGj7S2JdCgWQ8IIQCwYpTdrdlCyPqUIW0AMDYqpBFGVjby7h/HlwAA7hFI/+E4ws1NxpBDADA5PwKp1+sdHR0JIVZWVjKZjA/veFs0tQHAzPkRSOVyWUbR9va2CoHEEgkAoCA/Aml9fV3TNCHE9fW1D283hOO8oqQRAKhg0kDq9XrX19cyb4QQzWZT07SFhQUhRKlUurq6evjwoaZp9Xpd1/WnT586HmTaqTBk0AFpBACKmDSQyuXy+/fv9/f3hRDb29uaprVarb29vZWVla2tLblPtVqt1+uvXr2a8L1c4o4fAAiiiQJpY2Oj1Wp98sknQohqtapp2rNnzzqdzpMnT1ZWVszd3rx50+v1tre3hRCOseRy3QSXiB8ACKKJAqlSqRSLRfm42Wwmk0khhKZp5+fn1t2Oj49HHsqaScypAwAR5OWgBrMn6cGDB7f6wrm5OSGE+P9fMvwaACLLy0DqdDryga1CGmnm0xcBAGbuv7w6UDKZvLq6EkJ0Op1EIuHVYQEAEeFZhZTJZE5OTorF4vn5+aNHj7w6LAAgIjye7bter2uaZnYmuRG42b4BANPg8UwN1tHeAAC451kfEgAAkyCQAABKIJAAAEogkAAASiCQAABKIJAAAEogkAAASiCQAABKIJAAAEogkAAASiCQAABKIJAAAEogkAAASvB4tm8ACKu5ublZn0Ko9C9+NDCQ6vX62dmZEGJxcTGbzS4sLEz31ABAed4uIBdljunu3GRXLBaPjo4WFxflwuQ7OztTPjcAQNQ5V0jlctkwDFkVZTKZ3d3dZrOZTCb9PTcAQIQ4V0jz8/M+nwcAIOKcK6T19fWdnZ1MJjM/P99sNjudDuURAGCq5gb10ZmDGpaXl9fX16c3qOHevXtv376d0sEBwCtzcwM/MGfLMIx4PB6Px2d9Irfg+M20b9re3nb84levXk3nrAgkAMGgbCC12+1YLBaLxYbsYxhGrVYrFAq+ndVwjt9Me5NdLpfz63wAAM4ajUaj0bi8vGy327quCyHy+bwQIhaLFQoFXdcvLy+73a4QolAoGIaRSqXK5fLBwYHcIZ1Ox+Nx65fIoWrZbDaVSs320oawD2pY+Y4Q4uzs7OzsrNVqJRKJWZwbAERUt9u9uLgoFApra2u6ruu6fvfuXZlMMo3kg7t37x4eHspwunPnzunpqRCiVqulUinbl2Sz2c3NTZXTSAwa1FAsFs/PzzOZzNLSUr1e39nZqVQqPp8ZAChubu+vXh3q5ugj2xbZBBePx2u1WqPRkNGytrZWq9XkAyFEPp9Pp9MyZjY3N/P5fCqVkk9rtZr1SwLRw8R9SAAwpv4UmZJUKtVoNOLxuGymE0K0220hhNwot8Tj8Xa7fXh4KDuK+r9Efc6BxH1IAKCOx48fb25uXlxcnJ6eGobx4sWLFy9eXF5eGoah63q5XJa7ZbNZsxiyfUm32200Gu12W+VSyXnQiNlkJ+9DarVa02uyY5QdgECY+Sg7wzDS6bQQIp/Pr62txWKxeDw+cnCd/BLxXTk1fH/fuBr2beI+JACwmnkgmWQgmUkTRLcLpF6vJ4RYWFiYdu8RgQQgENQJpBBw/GY6z2VXKpXS6XSn0xFCfP7550+ePJn62QEAos05kHRdNwxDFkaVSqXT6TSbTX9PDAAQLc6BdH19bX2qaZptCwAA3nIe9p3NZnd3dzOZjKZpcrKGZ8+e+XxmAIBIGTHK7t27d8lkcqpLmDOoAUAgMKjBQ8z2DQDjI5A8xGzfAAB12QNJzvMNAIDPnAc1CCGazaY5sq5arWYyGbIKADA9w5af6PV65liGvb09H88KABA5zvchlcvlSqWSy+W2trYqlQqTfwPADBmGIdebmMkb+fbuzoEkaZp2dXUlhEgkEq1Wy4ezAQD0czNLt2EYcs1yz9+oVqv5E0gDb4zd2Nh4+fKlnMWuXC4/fPjQh7MBAIjv1imXa+sVCgXDMFKpVLlcPjg4iMVihUIhnU7H43GZQHKLXFg1m83KFWNtRxBC5HI5uYifruvtdrvRaJTL5Ww2ay6nZBiGfKN4PG7d2TyrfD5vHnAay1g4V0j7+/u//vWvhRDHx8f/+te/jo+PNU3z/L0BAI4uLy+FELqu37179/DwUEbLnTt3Tk9PhRC1Wi2VSslXZWDoup7NZjc3N2Ua9R9BZlWhUIjH441Go9vt1mo1wzByuZw1xuQb2XaWB9R1/c6dO9Y39ZxzhVQqlY6Ojl6+fJlMJr/++utqtcoQOwCw+WrzR14d6oPTf9i2rK2tCSHy+Xw6nZZpsbm5mc/nU6mUfFqr1WQwrK2tmQvFGoZRq9Xk11qPcHBwcHh4WC6X2+223G4uHdtoNGq1mow6KZ1O23YWQlxcXMg9u93ulJZicg4kOdu3HGJXqVS2t7envSoSAAROf4p4SHbbyGVe5RbZhnZ4eCib4FKplHxVNqNJ6XRapoXZ8SP3OTw8vH//fqFQsPUztdvtfD5vTSMhhOPOZlNhu92eUpeScyAx2zcAzNaLFy8uLy8Nw9B13ezmyWazZjH0+PHjzc3Ni4uL09NTwzC63W6j0Wi322aAWY9gGEa5XJZVjviueBLfdQttbm4KIQzDkBvv3Llj3VmSb5dOpxuNxpSa7JynZioWi61Wy5zt+/z8vFKpTOPtBXPZAQgIP+eyk4uUx2KxkePrDMMwG9BkMST37z9Co9GQTxuNhtnVNMigna1vN4nbLWHObN8AYOV/IE3y0T/5EabqdoHkGwIJQCAw27eHHL+Zw26MBQDANwQSAEAJBBIAQAn2Yd/b29t7e3vVatU2ed30VowFAEA4rhiraVomk1ldXZ3JCQEAoskeSGdnZ2dnZ/37MXUQAGCqnPuQ3r179+bNG/m41WoxTQMAYNrsFdL+/r4QYmNjo1KpmDfDbmxsdDodJvwGAEyPc4XU6XSsTzVNs20BAMBbAxfo293d3draWlhYODs763Q69CEBAKZq4EwYpVKpXq/3er3V1VXmsgMApg7yEHPZAcD4ZhhIhmHE43FzXYnAHb8fc9kBQCCNXIRCCGEYhnU9PdvT4dvN1fxmy7kPCQAwQ7quX15eyqVgC4WCYRipVKpcLh8cHJgrt8bjcRktcku5XDYMI5vNyuWLzKeOu62vr//hD3+QS9BaV9uT6/XJNx0ZgZ4bsR6SEGJxcZE+JADob2X69s+etXHd+dn3ChQZIYVCoVAofPvtt0KItbU1uWheLpdLp9OGYciFzPP5fD6fv3v3bjwer9VqcqMQwjAM+dRxt/v37wshNjc35bJJtVptbW2t3W53u918Pm9+iVdX18+xyc65QioWi+fn55lMZmlpqV6v7+zsTG/FWAAIKFuKeEuuMp7P59PptCx6ZH6kUin5tFaryeJGJorsAZI5ZK5QPmi3dDp9eHhYLpfb7ba5s1yzvFardbvdmazs5xxIsqaTVVEmk9nd3W02m8lk0t9zA4Dokp06clVyuUW2sB0eHsoKJpVKyVdlI5uUTqdllhiGIbc47nZ4eHj//v1CoWAtg8zGwHa7PZMuJedAmp+f9/k8AABWL168uLy8NAxD1/VyuSw3ZrNZs8p5/Pjx5ubmxcXF6empYRjdbrfRaLTbbflqLBaTTx13kz1SsiQy31HumU6nG42GtWPJN859SGaT3fz8fLPZbLVa02uyow8JQCD4Oexbdu3EYrGR4+sMwzCb12QlZO5vfdq/W7vdlseX+eR4wOm53X1I5qCG5eXl9fV1BjUAiDj/A2kmHTn+uMWgBiFEq9WyrdEHAPCHOVguUpxvjC0Wi81mM5fL5XI5IcTGxoa/ZwUAiJyBo+z+/ve/y8crKyvv3r2r1+vMrwoAmB7nCimRSFjXm2AxJADAtDlXSIlEYmNjI5vNCiHOz8+FEK9fvxZCrK6uUicBAKbBOZCWl5dlGgkhHjx44OP5AAAiyjmQ1tfX37x5c3V1ZW6RS5sDADAlzoG0u7u7sLCwtLTk89kAACLLOZBarZY5yg4AAB84j7LLZrMnJyc+nwoAIMoGztRwdHR0dHRkPmV2HwDAVDlXSH/84x//9re/vbXw+bSgjs9/8vtZnwIQOYZhDFkAQr46aJ/hX6sy50BiqDcAzFCtVhsSKnIOb7mPYRi2pV1HThCuLOcmO03T0ul0IpEwt7x69cqnMwIACFEul8vlcrfb1XX99PRULhSr67pccM9cMEKup5rNZs0thmHIx41G4/Lyst1u67oeiIhyDqStra1MJuPzqQBAsHjYoP30f/7btkWu31ooFA4PD4UQctm9y8vLeDwu/5W7ZbPZWCxmXdDIfPXi4kL/jq2KUpNzICWTyVKpdHV1tby8PD8/z3RBmKHPf/L7/t9VQAVT/Z+5trYmhMjn8+l02po3gxiGUavV5FdJsiqKx+O1Wm165+mhgctPVKtVIcTV1dW7d+92dnb8PSsAiDrZhyRXd3WzfzqdLhQKgV7Tb+DyE4ZhtFqts7OzR48eXV1dsfwEAPjp8PDw8vLSMAxd17vdriyVGo2GtQYSQsRisUaj0W63XeaWypwDaX5+3vq00+nYtgAApkf2HhmGcXBwIFveTk9Pu92uXElWlkFmMVQoFKxjFszVZs3dglI2OQdSLpfb2dmRqyLt7u4KIZLJpL8nBgBRZw2SIQWQmx6mQHDuQ9ra2nr69On8/HwikVhZWWHMd8TN8N5YbssFosO5QioWi/v7+2ZVVCqVEokERRJm4un//DcD7YAosAdSs9k8OjpqtVqtVsvc2Gq1KpWKvycGAIgWeyAlk8lXr17JCmkmJwQAiCbnPiTSCNNDtxAARwOXn4g4Oi0A9Jubm5v1KYQZgYRhZDBT0wBCiJubm1mfQsg5N9kBAOAzAgkzQMkFoB+BBABQAoGEAKAfC4gCAgkAoAQCCQCgBAIJAKAEAgm+4o5jAIMQSAAAJRBIDhjQBQD+82PqoF6vd3R0dH19/ejRIxZVAgA48qNC0nV9a2vr+Pj45OTEh7cDAASRH4G0v7+vaVq1Wl1aWvLh7TzBnZiq4ScChN6kgdTr9Tqdjvm02Wz2ej35uFQqFYtF89Xr6+vr6+sJ3w4AEFaTBlK5XH79+rV8vL29XSqVdnZ26vW6EGJra0vWRsVicWFhYWtryxpdwEiMEQciZaJA2tjYODo6ko+r1aqmac+ePTs+PtZ13bpbMpnc3d0tFouapk3ydpgVmssA+GCiUXaVSqVYLMrHzWZTjqDTNO38/Ny6WyaTSSaTvV6PIXYAgEG8HPZtFkAPHjzof2lIeWRdFZg1GQEgmrwcZWd2EdkqpJFuLDw8HyiLNkAA/TwLpGQyeXV1JYTodDqJRMKrwwIAIsKzJrtMJnNyclIsFs/Pzx89euTVYQEAETFpIO3v75uPK5VKvV5/+PAho+ngaMJh3LKhj4HgQFh5PFPDysoKaQRg2uiDDCVm+wagls9/8nvyJpoIJAxE+xgAPxFIAAKJKip8CCQAgBIIJAABQ2NyWBFIAAAlEEgAACUQSIDf6I0fQjbHMdthNBFIgK/4nPUKoRU+BBKChM8gIMQIJODfiDpgtpQIJKU+CMwRpfwx7i2G6sIT/EcKMSUCKcoim3kj897nz53I/iAAdRBIAFRh/SuEJooIIpAAAEogkOAKf65CQfy3DBkCCfAPd30CQxBIs8SnEgCYCCTg3yhc1MeY73AjkAAASiCQZoy/ym9rGt8x/u6+rc9/8nsffgo+/HbIC5nG5WAMP5j1CQDA+GRojfH3hEwg/hBRChUSgHEEq7i3nao53HFW5wNHVEgAbidALZxmDtniMyjnHzUEEuATbz/HA5QKPhhUq1m/RXy71EcgwQ98etqM3fMh+dDV7+bcJrwK69tNclb81woNAgnOiBDFeRUG/eRhBx3cwze1tqcN2idYPVWYEIEEBMxU/1bw6uCOKWIe+VYj3PjDKDoIJERd/5IHfAIK198K227Dix43JRGijEDCzPDpPyHPv4G2o/Uff8jbuSl6+FljOO5DCjMa38NHzQjnth54ggppZsxPltAXCuG+utBw/DG5GVPADxdeIZDCwPGjJMTlURQifNBLjrO9Df9WDOm5cXOvaIi/z1CNEoGk7OeLsieGwLntf6RJ/tfZ8qx/xIEn7wJ4TolAwpQEN1ADetqeGPvaR45hi+y3FEFBIIVElD/BA8rxz4Uxfo5mNw//ARB0BNL38LEeNeH4iYfgEgDBsO8QUPwjVfHT6zfDuWoC970CvEUgwS1mFRuJhUeBSdBkF078re0zay/O2AuY8iNDxBFIwETcDChwc6sQaQTQZBcSg9rTFG9n8+T0Ztjl4zhlju2iSCPAJSokJQT3hqHhpn1RZnUy3of+bU9v0A2nkwjlzx0YD4EUbFH+OHN57d7WT+6X8Bm+zB2AfgQSAsnNlG623h33Kyk4GiNaRn4JWQVY0YcUQsH6q3yqvVz9q/uMd5zxJlAI0E8BUAGBNBuKZEaI75sZ/h0e/qriI0GAsCKQwiOgA+36jZfW1sscdAT33wq5p9xZkb8egNAjkKLLHLI8pYHXyn6Ouzwx85uj5lUA4UMgBZhXn5W3yiTbnua9ONbWP3PjNE5g5HFGNsfd9pgTnxcAVxhlF1HjdbGYU+PYtthemnBxuWlnABkDqClsgcTCMJN0wLi/yWaMl/wx8xMAMDaa7ELF5cexY/aoMPaBDhsgyggkVUz7dhxzwNiQd1EhkwBEVtia7ER454WbnJtvy6wyiZ8agFBVSNP4RLvtB7Rvt5oOH3fguJ2PewAqUyWQwtRYNPa1OA6e9n8yhVnlFnkJRFwIm+xUMHYDlOPgaf+jmmwA4D9VKqRwsIbQJDWfrXmt/1B0twAIn/AEkldh4CFbE9zkh5KPSSMAoUST3XR5NX+BsGQSaQQglAikW3OcOGc4M5ZsD8ZAGgEIKwLpP4bkhGMI+d+vQxoBCLGQBFJ/GHh4oyUxAAA+CM+gBv/dduiEIkMtAEBNUQwkUgEAFBSGQHLZNGfOeuBhpWKdtNTlIqTEIQA4UroPyfzsHmMpObcexdQAAAd7SURBVNH36e94qyn9QwCgCEUDqX/unP7kcJMoI5eSm3zgAz1JAOAJdZvs3MydM3l9M5N4oCwDgH4qBtLI9Uy9vePHk0wiYwBgQoo22TmaXsfPhJlEGgHA5JSrkEZWP1P69CdUAGC2lAuk4aYaG2QSAMyQWoHEwgoAEFlqBRIAILLmbm5uZnsG9+7de/v27WzPAQAwc1RIAAAlEEgAACUQSAAAJRBIAAAlEEgAACUQSAAAJRBIAAAlEEgAACUQSAAAJRBIAAAlEEgAACUQSAAAJRBIAAAlEEgAACUQSAAAJRBIAAAlEEgAACUQSAAAJRBIAAAlEEgAACUQSAAAJRBIAAAlEEgAACUQSAAAJRBIAAAlEEgAACUQSAAAJRBIAAAlEEgAACX4F0ilUqnZbPr2dgCAYPEpkDqdjq7r19fX/rwdACBwfAokXdfX19f9eS81zc3NzfoUfBKRK43IZYrIXGlELlNxkwZSr9frdDrm02az2ev15ONSqVQsFjudTrFY3NramvCNAADh9oMJv75cLr9//35/f18Isb29rWlaq9Xa29tbWVkxQ2h5eblarbZarevr65WVlUlPGQAQRhMF0sbGRqvV+uSTT4QQ1WpV07Rnz551Op0nT55Yg0cmU7FYXF1dnfB0AQBhNXdzczPJ1xeLRSHE/v5+sVhcXl6W2XPv3r23b9+6PMK9e/cmOQEA8IT7Ty1MyaRNdlaapskHDx48cP9VX331lfXphAGprLm5SbM/KCJypRG5TBGZK2VQgwq8DCRzdMP5+bn7r4rC/3URmcsUkbnSiFymiMyVRuQyFefZsO9kMnl1dSWE6HQ6iUTCq8MCACLCswopk8mcnJwUi8Xz8/NHjx55dVgAQER43Dpcr9c1TTM7kwAAcMnjmRpWVlaGp9GQG2kHbQki22UKIZrN5vALD6j+K+10OtZLC8eVOl5mFH6gYf0Ntf0+ivBeabD8v9/97nd+vt+f/vSni4sLeUPS9vZ2p9M5OTkxi6r+LQFlvcxer/fLX/7yn//85xdffPH111+vrq6G5jLF969UCNHr9X7605/+5je/kU9Dc6W2y3zy5Emj0fjiiy/+93//N5lMhuYyheVKzf+3R0dHP/zhD5PJpAjFD7T/91GE+rMoYG589POf//yDDz54/vz5zc3NX/7yl88+++zm5ubq6upXv/qV45aAsl7mzc2Nruvm448++ig0l3nTd6U3NzefffbZRx999P79+5vw/kDPzs7kdb1///63v/1taC7z5vtX+vr1a/ng/fv3YfoNtf0+3oT6syhwvBz2PVKlUpE30gohms2m/JtL0zQ5TLx/S0BZL1MIYc4qK8v/0Fym6LvSk5OT5eXlTqezsLAgQnSltss8OztbXl4ulUpCiOPj42KxGI7LFN+/0kQiUSqV6vV6q9WS42bD8QO1/T6KUH8WBc4sF+jrv5F2vFtrFSdL/nq9vrOzk8vlREgvs9lsNptN2wDLUF6pEOL169dCiKurq+3tbRHSy9Q0bX5+vlqtVqvV5eVlc6N8ENwr7f99FJH5LFKfrxWSTf+NtOPdWqu+YrH47t274+NjTdPkDOhye5gu8+TkZGlpSV7dkydP5K96KK9UCLG+vi5nydrY2BAhvUxd1zOZjLzMjz/+WD4Ix5Vafx/lluh8FiluZhVS/420Yb21tlQqWf/3h/UyHz16tLq6urq6urCwkMlk5ufnw3qlZrkghOj1emG9zH7huFLb76OI0meR+mZWIfXfSBvWW2vlAFPZtiOEePXqVSgvU7a5CyHm5+flXO9h/YFubW1tbGwUi8VWq5XL5cJ6mQ8fPtze3r66umq1WrLfJRxX2v/7GJ3PIvXNeNrE/htpI3JrbUQuU4T3Sm3XFZHLdNwSDtG5UpVFYh5fAID6ZjnKDgAAE4EEAFACgQQAUAKBBABQAoEEAFACgQQAUMIspw4CxiMnAF1dXdV1/dWrV7M+HQDeoEJCUCUSib29vVmfBQDPUCFBIcVi8c2bN0KI9fX1/f39ZrPZarWq1Woikdjf3y8Wi+VyWd48v7S01Ol0qtWqEEKuBFEul9fX158+fbqwsFAqlXRdv76+zmaz+/v71rdoNpv9+8/iWgHYUSFBFfV6/fz8vFKpVCqV8/Pzer1+fX19dHSUy+X29/dLpVKr1TIM4+XLl81mUwhxfX3darWur6/fvHmztbX19u1bIUSr1ZKRU6lUDMNotVoyfkz9+8/kYgH0o0KCKs7OzjKZjKxXMpnM2dnZ6upqIpGQU7XW6/WtrS35qrnGmpRIJOTUrktLS0IIWVHJpEkkEnLa5iH7A1AEgQSFzM/PywdLS0vv37+3vtTr9dy3rXU6nbOzM/nYuloEAJXRZAdVLC8vy7Y4IUS9Xl9cXLS+urq6ambM8Ha25eXlhYWF/f39/f39xcVFM+QAKI4KCapYX18vlUrb29sLCwudTmdvb88aPNlsdmdnZ3d3d+SaaVtbW9VqdXt7W9O0Vqv18uXL6Z87AA+w/ATUIoskc7k/G/dL1DSbzevra9n/BCAQCCQAgBLoQwIAKOH/AK+ytM3E/O8NAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "figure(2);\n",
    "semilogy(x_n, toc_1, x_n, toc_2, x_n, toc_3, x_n, toc_4);\n",
    "title(\"Tempi di calcolo\");\n",
    "legend('nopivot', \"pivot-parziale\", \"pivot-totale\", \"built-in\", ...\n",
    "    'location','eastoutside');\n",
    "xlabel('ordine n'); ylabel('tempo di calcolo');\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
}