FinalProject_2021_2022.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 149,
   "id": "287dadb3",
   "metadata": {
    "id": "3fe94688"
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "from numpy import *\n",
    "from matplotlib.pyplot import *\n",
    "import time  # for testing\n",
    "import pandas as pd # for table"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "492d4ffc",
   "metadata": {
    "id": "8184faab"
   },
   "source": [
    "Consider the following one-dimensional PDE:\n",
    "$$\n",
    "-u_{xx}(x) = f(x)\\quad\\mathrm{ in }\\ \\Omega = (0, \\pi)\n",
    "$$\n",
    "$$\n",
    "u(x) = 0, \\quad\\mathrm{ on }\\ \\partial\\Omega = \\{0, \\pi\\}\n",
    "$$\n",
    "\n",
    "Given the following $4^{th}$ order finite difference approximation of the second order derivative:\n",
    "\n",
    "$$u_{xx}(x_i) = \\frac{-u_{i-2}+16u_{i-1}-30u_i+16u_{i+1}-u_{i+2}}{12h^2}$$\n",
    "\n",
    "Implement a function that given the domain interval, the forcing function, the number of discretization points, the boundary conditions, returns the matrix $A$ and the the right hand side $b$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "id": "326ea886",
   "metadata": {
    "id": "1c562f13"
   },
   "outputs": [],
   "source": [
    "def finDif(omega,f,n,bc):\n",
    "    \"\"\"\n",
    "    Function returning finite different matrix for fourth order difference approximation\n",
    "    of second order derivative. \n",
    "    \n",
    "    \n",
    "    info: Given a one dimensional PDE of the form:\n",
    "    \n",
    "                            -u''(x) = f(x) , insiede boundary \n",
    "                            u(x) = 0 , in boundary\n",
    "                            \n",
    "          The function returns a numpy 2d array A and \n",
    "          a numpy 1d array b such that:\n",
    "          \n",
    "                              A * u = b\n",
    "        \n",
    "          where u is the solution vector to the PDE\n",
    "          problem.\n",
    "          \n",
    "    additional: The function uses linear discretization points \n",
    "                in the domain of the PDE. \n",
    "                \n",
    "    example:    omega = [0,pi]         # domain interval\n",
    "                f = lambda x : sin(x)\n",
    "                n=400                  # discretization points\n",
    "                bc = [0,0]             # boundary conditions\n",
    "                \n",
    "                A, b = finDif(omega, f, n, bc)  # apply function\n",
    "                u = numpy.linalg.solve(A, b)    # solving linear system\n",
    "                x = numpy.linspace(omega[0], omega[1], num = numpy.shape(u)[0]) # discretization points\n",
    "                plot(x, u)  # plotting the solution\n",
    "                \n",
    "    \"\"\"\n",
    "    \n",
    "    h = (omega[1] - omega[0]) / ( n - 1 )     # choosing the step size in the interval omega\n",
    "    x_i = array([i*h for i in range(0,n)])    # discretization points in the interval omega\n",
    "    b = array(f(x_i))                         # calculating the function at discretization points\n",
    "    b[0], b[n-1] = bc                         # setting boundary conditions         \n",
    "    A = diag([-1 for i in range(0,n-2)], -2)  \\\n",
    "    + diag([16 for i in range(0,n-1)], -1)    \\\n",
    "    + diag([-30 for i in range(0,n)])         \\\n",
    "    + diag([16 for i in range(0,n-1)], 1)     \\\n",
    "    + diag([-1 for i in range(0,n-2)], 2)     # creating the A matrix\n",
    "    return - A / (12*(h**2)), b"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29b8cc3a",
   "metadata": {
    "id": "c21bb21e"
   },
   "source": [
    "Call the function using:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "id": "53f24a94",
   "metadata": {
    "id": "23af8831"
   },
   "outputs": [],
   "source": [
    "omega = [0,pi]\n",
    "f = lambda x : sin(x)\n",
    "n=500\n",
    "bc = [0,0]\n",
    "A, b = finDif(omega, f, n, bc)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e9736b3",
   "metadata": {
    "id": "4f8a7c6f"
   },
   "source": [
    "Implement two functions that compute the LU and the Cholesky factorization of the system matrix $A$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "id": "cd143f63",
   "metadata": {
    "id": "47468a37"
   },
   "outputs": [],
   "source": [
    "def LU(A, pivoting = False):\n",
    "    \"\"\"\n",
    "    Operating LU factorization on matrix A\n",
    "    \n",
    "    info : The function works only for square matrices. By default pivoting is \n",
    "           omitted, an exeption is thrown in case pivoting is needed. \n",
    "           The function returns the lower triangular matrix (L) and the upper\n",
    "           triangular matrix (U) as a numpy 2D array. Optionally the permutation\n",
    "           matrix is return if `pivoting` is set to True.\n",
    "           \n",
    "    input : A => numpy 2D array as square matrix \n",
    "    \n",
    "    param : pivoting => boolean :  True => Gauss (partial) pivoting algorithm is performed. \n",
    "                                   False => Gauss algorithm is performed.\n",
    "    \n",
    "    return: L => numpy 2D array as square matrix representing the lower triangular matrix.\n",
    "            U => numpy 2D array as square matrix representing the upper triangular matrix.\n",
    "            \n",
    "    optional:\n",
    "            P  => numpy 2D array as square matrix representing the permutation matrix \n",
    "                  only if `pivoting` is set to True.\n",
    "    \"\"\"\n",
    "    \n",
    "    assert(shape(A)[0] == shape(A)[1]), \"Invalid Operation, check 'info' by typing  ?LU\"\n",
    "    \n",
    "    A = array(A, dtype = 'float64')        # convertig to a numpy array\n",
    "    n = shape(A)[0]                        # number of rows and columns\n",
    "    P = identity(n)     # permutation matrix\n",
    "    L = zeros((n, n))  # lower triangular matrix\n",
    "    \n",
    "    for k in range(n - 1):\n",
    "        if(pivoting):                        # pivoting done only if asked by user\n",
    "            assert( A[k, k] != 0 ), \"Division by zero, matrix A not full rank, Gauss decomposition invalid\"\n",
    "            r = k + abs(A[k:, k]).argmax()   # looking at best pivot\n",
    "            A[[k, r]] = A[[r, k]]            # exchanging rows and columns\n",
    "            L[[k, r]] = L[[r, k]]            # exchanging rows and columns\n",
    "            P_now = identity(n)              # inizialization new permutation matrix in step k\n",
    "            P_now[[k, r]] = P_now[[r, k]]    # exchanging rows and columns\n",
    "            P = dot(P, P_now)                # updating total permutation matrix\n",
    "        assert( A[k, k] != 0 ), \"Division by zero, use `pivoting = True`\"\n",
    "        L[(k+1):,k] = A[(k+1):,k] / A[k,k]   # taking the L coefficients\n",
    "        A[k+1:] -= L[k+1:,k][:,None]*A[k,:]  # gauss k-step update of matrix A\n",
    "        \n",
    "    fill_diagonal(L, 1) # adding 1 to L matrix diagonal\n",
    "    \n",
    "    if(pivoting):\n",
    "        return L, A, P\n",
    "    \n",
    "    return L, A\n",
    "\n",
    "L, U = LU(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "id": "3367087b",
   "metadata": {
    "id": "193ebfed"
   },
   "outputs": [],
   "source": [
    "def cholesky(A, assumption = True):\n",
    "    \"\"\"\n",
    "    Operating cholesky factorization on matrix A\n",
    "    \n",
    "    info : The function works only for symmetric positive definite matrices. \n",
    "           The assumptions are checked before performing the operations, \n",
    "           optionally by setting `assumption = False` the assumption are \n",
    "           not checked, which could result in a gain in performance but \n",
    "           results could be wrong (nan or inf numbers).\n",
    "           \n",
    "    input : A => numpy 2D array as square matrix \n",
    "    \n",
    "    param : pivoting => boolean :  True => Assumptions for Cholesky factorization are checked. \n",
    "                                   False => Assumptions for Cholesky factorization are not checked.\n",
    "                                   \n",
    "    return: L => numpy 2D array as square matrix representing the lower cholesky matrix.\n",
    "            L.tranpose() => numpy 2D array as square matrix representing the upper cholesky matrix.\n",
    "    \"\"\"\n",
    "    \n",
    "    if(assumption):\n",
    "        assert( shape(A)[0] == shape(A)[1] ), \"Invalid Operation, check 'info' by typing  ?cholesky\"\n",
    "        assert( allclose( A, A.transpose() ) ), \"Matrix not symmetric, Cholesky factorization aborted\"\n",
    "        _, U = LU(A, pivoting=False)\n",
    "        assert(all(diag(U) > 0)), \"Matrix not positive definite, Cholesky factorization aborted\"\n",
    "     \n",
    "    A = array(A, dtype = 'float64')           # converting to numpy array\n",
    "    L = zeros_like(A)      # initialization L matrix\n",
    "    \n",
    "    L[0, 0] = np.sqrt(A[0, 0])\n",
    "    \n",
    "    for i in range(1, shape(A)[0]):\n",
    "        for j in range(i):\n",
    "            L[j, i] = ( A[i, j] - dot( L[:j, i], L[:j, j] ) ) / L[j, j]\n",
    "        L[i, i] = sqrt( A[i, i] - dot( L[:i, i], L[:i, i] ) )\n",
    "    \n",
    "    return L, L.transpose()\n",
    "\n",
    "HT, H = cholesky(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a0483b5",
   "metadata": {
    "id": "41eb8436"
   },
   "source": [
    "Implement forward and backward substitution functions to exploit the developed factorization methods to solve the derived linear system of equations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "id": "b0ac1cce",
   "metadata": {
    "id": "019cf0df"
   },
   "outputs": [],
   "source": [
    "def L_solve(L,rhs):\n",
    "    \"\"\"\n",
    "    Operating a forward substitutions algorithm to solve a system of linear equation\n",
    "    for lower triagular matrix.\n",
    "    \n",
    "    info : The function works only for lower triangular square matrices. The\n",
    "           assumption that L is lower triangular is not checked, but checks\n",
    "           on not null diagonal elements for L are enable.\n",
    "           \n",
    "    input : L => numpy 2D array as square lower triangular matrix \n",
    "            rhs => numpy 1D array as right hand side of the system\n",
    "                                   \n",
    "    return: x => numpy 1D array as solution of the system.\n",
    "    \"\"\"\n",
    "    \n",
    "    assert(shape(L)[0] == shape(L)[1]), \"Invalid Operation: not square matrix, check 'info' by typing  ?L_solve\"\n",
    "    \n",
    "    L = array(L, dtype = 'float64')          # definition of L\n",
    "    rhs = array(rhs, dtype = 'float64')      # definition of rhs\n",
    "    x = zeros_like(rhs, dtype = 'float64')   # definition of x\n",
    "    \n",
    "    x[0] = rhs[0] / L[0, 0]\n",
    "    for i in range(1, L.shape[0]):\n",
    "        assert(L[i, i] != 0), \"Invalid operation, check L is a lower triangular matrix with not null diagonal\"\n",
    "        x[i] = ( rhs[i] - dot(L[i, :i], x[:i] ) ) / L[i, i]\n",
    "        \n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "id": "78c10209",
   "metadata": {
    "id": "26ce17c4"
   },
   "outputs": [],
   "source": [
    "def U_solve(U,rhs):\n",
    "    \"\"\"\n",
    "    Operating a backward substitutions algorithm to solve a system of linear equation\n",
    "    for upper triagular matrix.\n",
    "    \n",
    "    info : The function works only for upper triangular square matrices. The\n",
    "           assumption that U is upper triangular is not checked, but checks\n",
    "           on not null diagonal elements for U are enable.\n",
    "           \n",
    "    input : U => numpy 2D array as square upper triangular matrix \n",
    "            rhs => numpy 1D array as right hand side of the system\n",
    "                                   \n",
    "    return: x => numpy 1D array as solution of the system.\n",
    "    \"\"\"\n",
    "    \n",
    "    assert(shape(U)[0] == shape(U)[1]), \"Invalid Operation: not square matrix, check 'info' by typing  ?U_solve\"\n",
    "    \n",
    "    U = array(U, dtype = 'float64')         # definition of U\n",
    "    rhs = array(rhs, dtype = 'float64')     # definition of rhs\n",
    "    x = zeros_like(rhs, dtype = 'float64')  # definition of x\n",
    "    \n",
    "    x[U.shape[0] - 1] = rhs[U.shape[0] - 1] / U[U.shape[0] - 1, U.shape[0] - 1]\n",
    "    for i in range(U.shape[0] -1 , -1, -1):\n",
    "        assert(U[i, i] != 0), \"Invalid operation, check U is a upper triangular matrix with not null diagonal\"\n",
    "        x[i] = ( rhs[i] - dot(U[i, i+1:], x[i+1:]) ) / U[i, i]   \n",
    "        \n",
    "    return x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e245e3d3",
   "metadata": {
    "id": "08ac9ba1"
   },
   "source": [
    "Solve the derived linear system using the implemented functions and plot the computed solution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "id": "bd4590f7",
   "metadata": {
    "id": "7c1de4f3"
   },
   "outputs": [],
   "source": [
    "def solve_system(A, b, pivoting = True):\n",
    "    \"\"\"\n",
    "    Function for solving linear system exploiting LU factorization\n",
    "    \n",
    "    info : The function works only for square matrices. The\n",
    "           assumption that A is square is checked, throwing an\n",
    "           error otherwise.\n",
    "           \n",
    "    input : A => numpy 2D array as square  matrix \n",
    "            b => numpy 1D array as right hand side of the system\n",
    "        \n",
    "    param : pivoting => boolean :  True => Gauss (partial) pivoting algorithm is performed. \n",
    "                                   False => Gauss algorithm is performed.\n",
    "                      \n",
    "    return: x => numpy 1D array as solution of the system.\n",
    "    \"\"\"\n",
    "    \n",
    "    assert(shape(A)[0] == shape(A)[1]), \"Invalid Operation, check 'info' by typing  ?solve_system\"\n",
    "    \n",
    "    if(pivoting):\n",
    "        L, U, P = LU(A, pivoting)\n",
    "    else:\n",
    "        L, U = LU(A, pivoting)\n",
    "        P = identity(shape(A)[0])\n",
    "       \n",
    "    y = L_solve(L, matmul(b,P))\n",
    "    x = U_solve(U, y)\n",
    "    \n",
    "    return x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d6d679c",
   "metadata": {
    "scrolled": false
   },
   "source": [
    "### Additional\n",
    "\n",
    "Before continuing let's check if all of the functions previusly implemented work correctly. In function `my_test()` implemented below it is possible to find different tests for the previous functions. The tests are:\n",
    "* LU factorization without pivoting - function: `LU(*,pivoting = False)`\n",
    "* LU factorization with pivoting - function: `LU(*,pivoting = True)`\n",
    "* Cholesky factorization - function `cholesky()`\n",
    "* Forward  implementation for lower triangular matrix system of equations - function `L_solve()`\n",
    "* Backward implementation for upper triangular matrix system of equations - function `U_solve()`\n",
    "* Solving system of linear equation - function `solve_system()`\n",
    "\n",
    "The test starts by passing at `my_test()` a matrix with the following characteristcs:\n",
    "\n",
    "* numpy 2D array\n",
    "* square matrix\n",
    "* symmetric and positive definite (only for cholesky)\n",
    "\n",
    "Note that if cholesky assumptions are not fullfilled the test will not be performed and a warning will be throw. Finally, the function can be called by simply typing `my_test()` for launching the default tests. Otherwise, if one wants to check for a specific matrix, simply type:\n",
    "\n",
    "``` python\n",
    "A =  np.array([[2, 5, 8], [5, 2, 2], [7, 5, 6]])\n",
    "my_test(A)\n",
    "```\n",
    "Note, this will throw a warning since Cholesky factorization is not possible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "id": "010b5629",
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_test(A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])):   \n",
    "    \"\"\"\n",
    "    something to write...\n",
    "    \"\"\"\n",
    "    error = 0\n",
    "    note = \"nada\"\n",
    "    tot = 5\n",
    "    a = np.random.rand(shape(A)[0])\n",
    "    \n",
    "    # Checking if the matrix is square\n",
    "    assert(shape(A)[0] == shape(A)[1]), \"Invalid matrix, use square matrix\"\n",
    "    \n",
    "    # Checking if the matrix is singular\n",
    "    L, U, P = LU(A, pivoting=True)\n",
    "    assert(abs(L.diagonal().prod() * U.diagonal().prod() ) != 0), \"Invalid matrix, use not singular matrix\"\n",
    "        \n",
    "    print(\"\\033[1;30m=========== TEST STARTING ===========\\033\")\n",
    "    start_time = time.time()\n",
    "    # FIRST TEST: LU WITHOUT PIVOTING - function: LU(*,pivoting = False)\n",
    "    L, U = LU(A, pivoting=False)\n",
    "    \n",
    "    try:\n",
    "        assert(np.allclose(A - L @ U, np.zeros_like(A))), \"LU factorization without pivoting failed\"\n",
    "    except AssertionError as e:\n",
    "        error += 1\n",
    "        print(\"FAILED:\", e)\n",
    "    \n",
    "        \n",
    "    # SECOND TEST: LU WITH PIVOTING - function: LU(*,pivoting = True)\n",
    "    L, U, P = LU(A, pivoting=True)\n",
    "    try:\n",
    "        assert(np.allclose(A - P @ L @ U, np.zeros_like(A))), \"LU factorization with pivoting failed\"\n",
    "    except AssertionError as e:\n",
    "        error += 1\n",
    "        print(\"FAILED:\", e)\n",
    "\n",
    "        \n",
    "    # THIRD TEST: CHOLESKY FACTORIZATION - function: cholesky()\n",
    "    if(allclose( A, A.transpose())):\n",
    "        _, U = LU(A, pivoting=False)\n",
    "        if(all(diag(U) > 0)):\n",
    "            HT, H = cholesky(A)\n",
    "            try:\n",
    "                assert(np.allclose(A - H @ HT, np.zeros_like(A))), \"Cholesky factorization failed\"\n",
    "            except AssertionError as e:\n",
    "                error += 1\n",
    "                print(\"FAILED:\", e)\n",
    "            note = \"not\"\n",
    "            tot = 6\n",
    "             \n",
    "    # FOURTH TEST: LOWER MATRIX SOLVER - function: L_solve()\n",
    "    L, U = LU(A, pivoting=False)\n",
    "    a_L = L_solve(L, a)\n",
    "    try:\n",
    "        assert(np.allclose(a - matmul(L, a_L), np.zeros_like(a))), \"L_solve() failed in solving linear system\"\n",
    "    except AssertionError as e:\n",
    "        error += 1\n",
    "        print(\"FAILED:\", e)\n",
    "             \n",
    "    # FIFTH TEST: UPPER MATRIX SOLVER - function: U_solve()\n",
    "    L, U = LU(A, pivoting=False)\n",
    "    a_U = U_solve(U, a)\n",
    "    try:\n",
    "        assert(np.allclose(a - matmul(U, a_U), np.zeros_like(a))), \"U_solve() failed in solving linear system\"\n",
    "    except AssertionError as e:\n",
    "        error += 1\n",
    "        print(\"FAILED:\", e)\n",
    "\n",
    "    # SIXTH TEST: SOLVER LINEAR SYSTEM - function solve_system()\n",
    "    a_solve = solve_system(A, a)\n",
    "    try:\n",
    "        assert(np.allclose(a - matmul(A, a_solve), np.zeros_like(a))), \"solve_system() failed in solving linear system\"\n",
    "    except AssertionError as e:\n",
    "        error += 1\n",
    "        print(\"FAILED:\", e)\n",
    "        \n",
    "    print(\"\")\n",
    "    print(\"\\033[1;34m TOTAL TIME: %0.3f ms\\033\" %((time.time()-start_time)* 1000))\n",
    "    print(\"\\033[1;33m PASSED: %.0f \\033[0m\" %(tot - error))\n",
    "    print(\"\\033[1;31m FAILED: %.0f \\033[0m\" % error)\n",
    "    if(note == \"nada\"):\n",
    "        print(\"\")\n",
    "        print(\"\\033[1;34m WARNING Cholesky factorization not performed, matrix not symmetric\")\n",
    "    print(\"\")\n",
    "    print(\"\\033[1;30m============= TEST END ==============\\033 \\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "id": "f127b50f",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1;30m=========== TEST STARTING ===========\u001b\n",
      "\n",
      "\u001b[1;34m TOTAL TIME: 3.719 ms\u001b\n",
      "\u001b[1;33m PASSED: 5 \u001b[0m\n",
      "\u001b[1;31m FAILED: 0 \u001b[0m\n",
      "\n",
      "\u001b[1;34m WARNING Cholesky factorization not performed, matrix not symmetric\n",
      "\n",
      "\u001b[1;30m============= TEST END ==============\u001b \n",
      "\n",
      "\u001b[1;30m=========== TEST STARTING ===========\u001b\n",
      "\n",
      "\u001b[1;34m TOTAL TIME: 2.115 ms\u001b\n",
      "\u001b[1;33m PASSED: 6 \u001b[0m\n",
      "\u001b[1;31m FAILED: 0 \u001b[0m\n",
      "\n",
      "\u001b[1;30m============= TEST END ==============\u001b \n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Here few examples:\n",
    "\n",
    "# Default test (Warning for cholesky)\n",
    "my_test()\n",
    "              \n",
    "# All tests\n",
    "A =  np.array([[2, 0], [0, 1]])\n",
    "my_test(A)\n",
    "\n",
    "\n",
    "# Singular matrix error\n",
    "#print(\"Second test\")\n",
    "#A =  np.array([[2, 1], [2, 1]])\n",
    "#my_test(A) # error\n",
    "\n",
    "# Not square matrix error\n",
    "#print(\"Second test\")\n",
    "#A =  np.array([[2, 1], [3, 1], [4, 0]])\n",
    "#my_test(A) # error"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a37ca17",
   "metadata": {},
   "source": [
    "Nice, no errors! Now thats everything works, let's solve the initial problem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "id": "ad3f62e2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def solve_and_plot(omega,f,n,bc, plotty = True):\n",
    "    \"\"\"\n",
    "    Function for solving and plotting the solution of a finite\n",
    "    difference problem.\n",
    "    \n",
    "    info: Given a one dimensional PDE of the form:\n",
    "    \n",
    "                            -u''(x) = f(x) , insiede boundary \n",
    "                            u(x) = 0 , in boundary\n",
    "                            \n",
    "          The function solves the problem and plot the solution\n",
    "          \n",
    "    param: plotty => boolean :  True => Plot of the solution is performed. \n",
    "                                False => Plot of the solution is performed.\n",
    "    \n",
    "    return: x => numpy 1D array representing discretization points\n",
    "            f_solve => numpy 1D array representing u(x)\n",
    "    \"\"\"\n",
    "    A, b = finDif(omega, f, n, bc)\n",
    "    f_solve = solve_system(A, b, pivoting = True)\n",
    "    x = linspace(omega[0], omega[1], num = shape(f_solve)[0]) # discretization points\n",
    "    if(plotty):\n",
    "        plot(x, f_solve)\n",
    "        xticks(arange(0, 1.1*pi, step=(pi/4)), ['0','π/4', 'π/2','3π/4','π'])\n",
    "        xlabel(\"$\\Omega$\", fontsize=15)\n",
    "    return x, f_solve\n",
    "\n",
    "omega = [0,pi]\n",
    "f = lambda x : sin(x)\n",
    "n=400\n",
    "bc = [0,0]\n",
    "x, f_solve = solve_and_plot(omega,f,n,bc)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e799712c",
   "metadata": {
    "id": "62cdfe65"
   },
   "source": [
    "Considering the new domain $\\Omega = (0,1)$ and the forcing term $f(x) = x(1-x)$ with B.C. $u(x) = 0$, on $\\partial \\Omega = {0,1}$ produce a plot and a table where you show the decay of the error w.r.t. the number of grid points.\n",
    "(The analytical solution for the above problems is $u_{an} = \\frac{x^4}{12} - \\frac{x^3}{6} + \\frac{x}{12}$)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "id": "37c6abee",
   "metadata": {
    "id": "91212afb"
   },
   "outputs": [],
   "source": [
    "def error(omega, f, bc, f_real, plotty=True, max_N = 1200, step = 200):\n",
    "    \"\"\"\n",
    "    Function for plotting the error in resolution of PDE problem\n",
    "    as a function of discretization point.\n",
    "    \n",
    "    info: Given a one dimensional PDE of the form:\n",
    "    \n",
    "                            -u''(x) = f(x) , insiede boundary \n",
    "                            u(x) = 0 , in boundary\n",
    "                            \n",
    "          The function solves the problem using `solve_and_plot()`\n",
    "          \n",
    "    param: plotty => boolean :  True => Plot of the solution is performed. \n",
    "                                False => Plot of the solution is not performed.\n",
    "    \n",
    "    return: pandas dataframe with errors and iterations\n",
    "    \"\"\"\n",
    "    N = np.arange(50,max_N, step)\n",
    "    error_linf = zeros(shape(N)[0])\n",
    "    i = 0\n",
    "    for n in N:\n",
    "        x, f_solve = solve_and_plot(omega,f,n,bc,plotty=False)\n",
    "        error_linf[i] = max(abs(f_solve - f_real(x)))\n",
    "        i+=1\n",
    "    if(plotty):\n",
    "        plot(N, error_linf, label = \"${\\\\Vert \\\\cdot \\\\Vert}_{\\\\infty}$\")\n",
    "        xlabel(\"Iteration\", fontsize=15)\n",
    "        ylabel(\"Error\", fontsize=15, rotation=0, labelpad=20)\n",
    "        legend()\n",
    "        yscale('log')\n",
    "        title(\"Error vs number of iteartions\", fontsize=18)\n",
    "        grid()\n",
    "    return pd.DataFrame({'Iteration':N, 'Error l infinity':error_linf})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "e555f5c8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Iteration</th>\n",
       "      <th>Error l infinity</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>50</td>\n",
       "      <td>0.001578</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>250</td>\n",
       "      <td>0.000311</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>450</td>\n",
       "      <td>0.000172</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>650</td>\n",
       "      <td>0.000119</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>850</td>\n",
       "      <td>0.000091</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>1050</td>\n",
       "      <td>0.000074</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Iteration  Error l infinity\n",
       "0         50          0.001578\n",
       "1        250          0.000311\n",
       "2        450          0.000172\n",
       "3        650          0.000119\n",
       "4        850          0.000091\n",
       "5       1050          0.000074"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Time to run ~ 2 mins\n",
    "omega = [0,1]\n",
    "bc = [0,0]\n",
    "f = lambda x : x*(1-x)\n",
    "f_real = lambda x: np.power(x,4) / 12 - np.power(x,3) / 6 + x / 12\n",
    "Table = error(omega, f, bc, f_real)\n",
    "Table"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c1a9ebb",
   "metadata": {},
   "source": [
    "Compute the inverse of the matrix A exploiting the derived LU factorization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "id": "a1ad886c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def inverse(A):\n",
    "    \"\"\"\n",
    "    Operating the inverse of a square non singular matrix eploiting LU factorization.\n",
    "    \n",
    "    input : A => numpy 2D array as square  matrix \n",
    "\n",
    "    return: inv_A => numpy 2D array as inverse of matrix A\n",
    "    \"\"\"\n",
    "    A = array(A, dtype = 'float64')   # defining A matrix \n",
    "    inv_A = zeros_like(A)             # defining inverse matrix\n",
    "    I = identity(shape(A)[0])         # defining identiry matrix\n",
    "    L, U, P = LU(A, pivoting=True)    # we just do one time LU factorization\n",
    "    \n",
    "    for k in range(shape(A)[0]):\n",
    "        # --- start solving the system using LU --- #\n",
    "        tmp = L_solve(L, matmul(I[:, k],P))\n",
    "        inv_A[:, k] = U_solve(U, tmp)\n",
    "        # --- end solving system using LU --- #\n",
    "    return inv_A\n",
    "\n",
    "omega = [0,pi]\n",
    "f = lambda x : sin(x)\n",
    "n=200\n",
    "bc = [0,0]\n",
    "A, b = finDif(omega, f, n, bc)\n",
    "A_inv = inverse(A)\n",
    "\n",
    "# Plotting the results\n",
    "figure, axes = subplots(nrows=1, ncols=3)\n",
    "_ = axes[0].matshow(A)\n",
    "axes[0].title.set_text('$A$')\n",
    "_ = axes[1].matshow(A_inv)\n",
    "axes[1].title.set_text('$A^{-1}$')\n",
    "_ = axes[2].matshow(A.dot(A_inv))\n",
    "axes[2].title.set_text('$AA^{-1}$')\n",
    "figure.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56e6b20e",
   "metadata": {
    "id": "c8d5002f"
   },
   "source": [
    "Exploit the derived LU factorizations to compute the condition number of the system's matrix $A$ using the original problem formulation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "id": "f4c46575",
   "metadata": {
    "id": "c25fc1fe"
   },
   "outputs": [],
   "source": [
    "def condNumb(A):\n",
    "    \"\"\"\n",
    "    Compute the condition number of a matrix.\n",
    "\n",
    "    Additional: This function is capable of returning the condition number using \n",
    "                the l infinity norm,\n",
    "    \n",
    "    input : A => numpy 2D array as square  matrix \n",
    "\n",
    "    return: condNu => condition number of matrix A\n",
    "    \"\"\"\n",
    "    A = array(A)\n",
    "    A_inv = inverse(A)\n",
    "    condNu = max(sum(abs(A), axis=1))*max(sum(abs(A_inv), axis=1))\n",
    "    return condNu"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2aa31587",
   "metadata": {
    "id": "2728b49a"
   },
   "source": [
    "Implement a preconditioned Conjugant Gradient method to solve the original linear system of equations using an iterative method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "id": "e0bccd85",
   "metadata": {
    "id": "62b83aee"
   },
   "outputs": [],
   "source": [
    "def conjugate_gradient(A, b, P = None, nmax=len(A), eps=1e-10, assumption = True):\n",
    "    \"\"\"\n",
    "    Operating conjugate gradient method on a symmetric positive\n",
    "    definite matrix A.\n",
    "    \n",
    "    info : The function works only for symmetric positive definite matrices. \n",
    "           The assumptions are checked before performing the operations, \n",
    "           optionally by setting `assumption = False` the assumption are \n",
    "           not checked, which could result in a gain in performance but \n",
    "           results could be wrong (nan or inf numbers).\n",
    "           \n",
    "    input : A => numpy 2D array as square matrix \n",
    "            b => numpy 1D array as right hand side of the system\n",
    "            nmax => number of iterations (default = len(A))\n",
    "            eps => error on each iteration (default 1e-10)\n",
    "    \n",
    "    param : asssumption => boolean :  True => Assumptions are checked. \n",
    "                                   False => Assumptions are not checked.\n",
    "                                   \n",
    "    return: x => numpy 1D array as solver of the system\n",
    "    \"\"\"\n",
    "    \n",
    "    if(assumption):\n",
    "        assert( shape(A)[0] == shape(A)[1] ), \"Invalid Operation, check 'info' by typing ?conjugate_gradient\"\n",
    "        assert( allclose( A, A.transpose() ) ), \"Matrix not symmetric, Conjugate Gradient algorithm aborted\"\n",
    "        _, U = LU(A, pivoting=False)\n",
    "        assert(all(diag(U) > 0)), \"Matrix not positive definite, Conjugate Gradient algorithm aborted\"\n",
    "        \n",
    "    if P is None:\n",
    "        P = identity(shape(A)[0])\n",
    "        \n",
    "    A = array(A, dtype = 'float64')\n",
    "    b = array(b, dtype = 'float64')\n",
    "    \n",
    "    x = zeros_like(A[0])\n",
    "    r = b - A.dot(x)\n",
    "    z = solve_system(P, r)\n",
    "    p = z\n",
    "    for k in range(1, nmax):\n",
    "        if linalg.norm(r) < eps:\n",
    "            break\n",
    "            \n",
    "        alpha = p.dot(r) / A.dot(p).dot(p)\n",
    "        x += alpha*p\n",
    "        r -= alpha*A.dot(p)\n",
    "        z = solve_system(P, r)\n",
    "        beta = A.dot(p).dot(z) / A.dot(p).dot(p)\n",
    "        p = z - beta*p\n",
    "        \n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "id": "ebdad006",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Small test on conjugate gradient: if everything works correctly no assertion is thrown \n",
    "omega = [0,pi]\n",
    "f = lambda x : sin(x)\n",
    "n=100\n",
    "bc = [0,0]\n",
    "A, b = finDif(omega, f, n, bc)\n",
    "\n",
    "assert(np.allclose(conjugate_gradient(A, b) - solve_system(A, b), np.zeros_like(b))), \"It doesn't work!!!\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbcd2fb7",
   "metadata": {
    "id": "8a4cfc02"
   },
   "source": [
    "Consider the following time dependent variation of the PDE starting from the orginal problem formulation:\n",
    "$$\n",
    "u'(t)-u_{xx} = \\alpha(t)f(x)\n",
    "$$\n",
    "\n",
    "for $t\\in [0,T]$, with $\\alpha(t) = \\cos(t)$ and $T = 6\\pi$\n",
    "\n",
    "Use the same finite difference scheme to derive the semi-discrete formulation and solve it using a forward Euler's method.\n",
    "\n",
    "Plot the time dependent solution solution at $x = \\pi/2$, $x=1$, \n",
    "$x=\\pi$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dcf198c9",
   "metadata": {},
   "source": [
    "#### Solution\n",
    "We will now solve the time dependent PDE. In general, given a PDE as follow:\n",
    "\n",
    "$$u'(x,t)=u_{xx}(x,t)+g(x,t) \\qquad x \\in \\Omega = [0, \\pi] \\;, t \\in [0,T],$$\n",
    "\n",
    "we assume homogeneous Dirichlet boundary conditions $u(x = 0,t) = u(x = \\pi,t) = 0$ for any $t > 0$ and initial condition $u(x, t = 0) = u(x)$ for $x \\in \\Omega$. The function $u(x)$ is the one solving the original problem at $t=0$:\n",
    "$$\n",
    "-u_{xx}(x) = f(x)\\quad\\mathrm{ in }\\ \\Omega = (0, \\pi)\n",
    "$$\n",
    "\n",
    "$$\n",
    "u(x) = 0, \\quad\\mathrm{ on }\\ \\partial\\Omega = \\{0, \\pi\\}\n",
    "$$\n",
    "Hence, we discretize the problem as follow:\n",
    "\n",
    "$$u'(x,t) = \\frac{u(x_{n+1}, t_{n+1}) -  u(x_{n}, t_{n})}{h_t} = \\frac{-u(x_{n-2}, t_{n})+16u(x_{n-1}, t_{n})-30u(x_{n}, t_{n})+16u(x_{n+1}, t_{n})-u(x_{n+2}, t_{n})}{12h^2} + \\alpha(t_n)f(x_n)$$\n",
    "\n",
    "For what previusly said, it follows:\n",
    "\n",
    "$$\\mathbf{u}(t_{n+1}) = (I - h_tA)\\,\\mathbf{u}(t_{n}) + h_t\\,\\alpha(t_n)\\,\\mathbf{f},$$\n",
    "\n",
    "where $A$ is the matrix previusly defined above and $I$ is the identity matrix with same dimension as $A$, and $\\mathbf{u}(t) = (u(x_1, t), . . . , u(x_N, t))^{T}$, $\\mathbf{f} = (f(x_1), . . . , f(x_N))^{T}$\n",
    "\n",
    "Hence, the problem becomes:\n",
    "$$\n",
    "\\mathbf{u}(t_{n+1}) = (I - h_tA)\\,\\mathbf{u}(t_{n}) + h_t\\,\\alpha(t_n)\\,\\mathbf{f} \\quad t > 0\n",
    "$$\n",
    "\n",
    "$$\n",
    "\\mathbf{u}(t_0) = \\mathbf{u}(x)\n",
    "$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "id": "855d8d82",
   "metadata": {
    "id": "3ffe0689"
   },
   "outputs": [],
   "source": [
    "def Forward_Euler(f, alpha, omega, time_omega, Nx, Nt, bc):\n",
    "    \n",
    "    h = ( time_omega[1] - time_omega[0] ) / Nt\n",
    "    t = linspace(time_omega[0], time_omega[1], num = Nt+1, dtype='float64')\n",
    "    \n",
    "    u = zeros((Nx, Nt+1))  # first index space, second index time\n",
    "    \n",
    "    A, b = finDif(omega, f, Nx, bc)\n",
    "    x = linspace(omega[0], omega[1], num = shape(b)[0]) # discretization points\n",
    "    I = identity(shape(A)[0])\n",
    "    u[:, 0] = solve_system(A, b)\n",
    "    for k in range(Nt):\n",
    "        u[:,k+1] = (I - h*A).dot(u[:, k]) + h*alpha(t[k])*b\n",
    "    \n",
    "    return u, t, x \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a70237ae",
   "metadata": {},
   "source": [
    "Let's see the results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "id": "6ecd633a",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def find_idx(x, s):\n",
    "    \"\"\"\n",
    "    Find the best value in x to approximate the value of s.\n",
    "    \"\"\"\n",
    "    return np.argmin(np.abs(x - s))\n",
    "\n",
    "time_omega = [0, 6*pi]\n",
    "omega = [0,pi]\n",
    "f = lambda x : sin(x)\n",
    "alpha = lambda x : cos(x)\n",
    "Nx =300\n",
    "Nt = 1000000\n",
    "bc = [0,0]\n",
    "\n",
    "u, t, x = Forward_Euler(f, alpha, omega, time_omega, Nx, Nt, bc)\n",
    "\n",
    "# Let's plot\n",
    "plot(t, u[find_idx(x, pi/2),:], \"--\", label = \"x = π/2\")\n",
    "plot(t, u[find_idx(x, 1),:], \"-.\", label = \"x = 1\")\n",
    "plot(t, u[find_idx(x, pi),:], label = \"x = π\")\n",
    "xlabel(\"t\", fontsize=13)\n",
    "ylabel(\"u(x, t)\", fontsize=13, rotation=0, labelpad=20)\n",
    "legend()\n",
    "show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "id": "34d4b403",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Very close to zero, as expected\n",
    "plot(t, u[find_idx(x, pi),:], label = \"x = π\")\n",
    "legend()\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c604a7bf",
   "metadata": {
    "id": "36936121"
   },
   "source": [
    "Given the original $Au = b$ system, implement an algorithm to compute the eigenvalues and eigenvectors of the matrix $A$. Exploit the computed LU factorization"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "605a99a9",
   "metadata": {},
   "source": [
    "We first write the general power method, then we implement the search of eigenvalues (and eigenvectors) by looking at possible shifts in the Gershgorin circles. In what follows the are three functions:\n",
    "* `power_method()` => function implmenting the classic power method\n",
    "* `Build_Gershgorin_circles()` => function for building Gershgorin circles\n",
    "* `points_in_circles()` => function for finding normally distributed points in a circle\n",
    "* `Find_eig()` => function for finding eigenvalues and eigenvectors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "id": "98f14f62",
   "metadata": {},
   "outputs": [],
   "source": [
    "def power_method(A, shift = 0, tol = 1e-10, MAX_CYCLES = 6000):\n",
    "    \"\"\"\n",
    "    Operating inverse power method\n",
    "    \"\"\"\n",
    "    A = array(A, dtype = 'float64') - shift*identity(shape(A)[0])\n",
    "    A_inv = inverse(A)\n",
    "    L, U, P = LU(A, pivoting=True) # we just do one time LU factorization\n",
    "    x = random.rand(shape(A)[0])\n",
    "    y = x / linalg.norm(x)\n",
    "    eigval = 0.\n",
    "    cycle = 0;\n",
    "    while(cycle < MAX_CYCLES):\n",
    "        # --- start solving the system --- #\n",
    "        tmp = L_solve(L, matmul(y,P))\n",
    "        x = U_solve(U, tmp)\n",
    "        # --- end solving system --- #\n",
    "        y = x / linalg.norm(x) \n",
    "        eigval_tmp = 1. / dot(y, matmul( A_inv, y) )  + shift\n",
    "        if( abs( eigval_tmp - eigval ) < tol ):\n",
    "            return eigval_tmp, x\n",
    "                    \n",
    "        eigval = eigval_tmp\n",
    "        cycle += 1           \n",
    "    return eigval, x\n",
    "\n",
    "def Build_Gershgorin_circles(A):\n",
    "    \"\"\"\n",
    "    Function to calculate Gershgorin circles\n",
    "    \"\"\"\n",
    "    A = array(A, dtype = 'float64')\n",
    "    circles = []\n",
    "    circle_centers = diag(A)\n",
    "    row_radius = sum(A, axis = 1) - diag(A)\n",
    "    column_radius = sum(A, axis = 0) - diag(A)\n",
    "    circles = list(zip(circle_centers, row_radius)) + list(zip(circle_centers, column_radius))\n",
    "    return circles\n",
    "\n",
    "def points_in_circles(circle, N = 100):\n",
    "    \"\"\"\n",
    "    Operating random uniform points in a 1D circle\n",
    "    \"\"\"\n",
    "    center, radius = circle\n",
    "    x = random.uniform(center - radius, center + radius, N)\n",
    "    return x\n",
    "\n",
    "def Find_eig(A, N = 100, equal_tol = 1e-10):\n",
    "    \"\"\"\n",
    "    Opearting eigenvalue and eigenvector search using power method\n",
    "    \n",
    "    info: The following function searches for eigenvalues and eigenvectors\n",
    "          by using the generalized power method. The shift is computed by \n",
    "          looking at random points in the Gershgorin circles.\n",
    "          \n",
    "    input: A => numpy 2D array as input matrix\n",
    "    \n",
    "    param: N => number of points in Gershgorin circles.\n",
    "           equal_tol => tolerance for equality in eigenvalues\n",
    "    \n",
    "    return: The function returns a tuple. First tuple element `eigval` is a\n",
    "            numpy 1D array representing all eigenvalues. Second tuple \n",
    "            element `eigvect` is a numpy 2D array with eigenvectors as column elements\n",
    "            ordered with respect to eigenvalues. For istance the column \n",
    "            eigvect[:,i] is the eigenvector corresponding to the eigenvalue eigval[i].\n",
    "    \"\"\"\n",
    "    circles = Build_Gershgorin_circles(A)\n",
    "    eigval = []\n",
    "    eigvect = []\n",
    "    for circle in circles:\n",
    "        for shift in points_in_circles(circle, N):\n",
    "            eigvalue, eigvector = power_method(A, shift, tol = equal_tol)\n",
    "            if(len(eigval)== 0):\n",
    "                eigval.append(eigvalue)\n",
    "                eigvect.append(eigvector)\n",
    "            if not any(isclose(eigval, eigvalue, atol=equal_tol*1000, rtol = 0)):\n",
    "                eigval.append(eigvalue)\n",
    "                eigvect.append(eigvector)\n",
    "                \n",
    "    if len(eigval) > A.shape[0]:\n",
    "        print(\"WARNING: Number of found eigenvalues greater than the dimension \"\n",
    "                      \"of the matrix, check spurious eigenvalues that \"\n",
    "                      \"should be discarded. \\n\")\n",
    "        \n",
    "    if len(eigval) < A.shape[0]:\n",
    "        print(\"WARNING: Number of found eigenvalues smaller than the dimension \"\n",
    "                      \"of the matrix, some eigenvalues are missing.\")\n",
    "        \n",
    "    return eigval, eigvect"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "485a550d",
   "metadata": {},
   "source": [
    "Here a small test, it takes approximately 42.16 s to run"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "id": "9e3320b7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING: Number of found eigenvalues smaller than the dimension of the matrix, some eigenvalues are missing.\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAD4CAYAAADhNOGaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAYJ0lEQVR4nO3dfZRU9X3H8fd3H9jFSHcRgQCL3TUSFUKUMD4QrSFFnpKItI0WqqcgMaatnpgm2kJpkZg0YrTGtCZamhBNogajSDi2HhTMw6GnAXaFiAi4G0N0V5Qn0ayAYeHbP+a3OLsOsLMzuzOT3+d1zp659/f7zp3vXHbms/feYdfcHRERiVdJvhsQEZH8UhCIiEROQSAiEjkFgYhI5BQEIiKRK8t3A91x6qmnem1tbb7bEBEpKg0NDbvdfWDn8aIMgtraWurr6/PdhohIUTGz36Yb16khEZHIKQhERCKnIBARiVxRXiMQEQE4dOgQzc3NHDx4MN+tFJTKykpqamooLy/vUr2CQESKVnNzM/369aO2thYzy3c7BcHd2bNnD83NzdTV1XXpPjo1JCJF6+DBgwwYMEAhkMLMGDBgQEZHSQoCESlqCoH3ynSfKAhERCKnIBAR6WErVqxg0aJF+W7jmHSxWESisXxDC3es3Mar+w4wtLovN08+k+ljhvX4406bNo1p06b1+ON0l44IRCQKyze0MG/ZJlr2HcCBln0HmLdsE8s3tGS13e3bt3PWWWcxe/ZsPvjBD3LVVVexatUqLrroIkaMGMG6deu4//77ueGGGwCYPXs2n//85/noRz/K6aefzqOPPnp0W3fccQfnnXceH/7wh7nllluy6isTCgIRicIdK7dx4NDhDmMHDh3mjpXbst52U1MTX/rSl9i6dStbt27loYceYs2aNdx555187Wtfe0/9jh07WLNmDU888QRz584F4KmnnqKxsZF169axceNGGhoa+MUvfpF1b12hU0MiEoVX9x3IaDwTdXV1jB49GoBRo0YxYcIEzIzRo0ezffv299RPnz6dkpISRo4cyeuvvw4kg+Cpp55izJgxALS2ttLY2Mgll1ySdX8noiAQkSgMre5LS5o3/aHVfbPedkVFxdHlkpKSo+slJSW0tbUdt97dj97OmzePz33uc1n3kymdGhKRKNw8+Uz6lpd2GOtbXsrNk8/MU0cdTZ48mSVLltDa2gpAS0sLO3fu7JXH1hGBiESh/dNB+fjUUFdMmjSJLVu2MG7cOABOPvlkfvjDHzJo0KAef2xrPywpJolEwvWHaURky5YtnH322fluoyCl2zdm1uDuic61OjUkIhI5BYGISOQUBCIikVMQiIhETkEgIhI5BYGISOQUBCIikVMQiEhcfvcafG8q/O71fHdSMHISBGY2xcy2mVmTmc1NM19hZkvD/Fozq+00f5qZtZrZTbnoR0TkmH7+dXj5l/Dz23Oyue3bt3P22Wfz2c9+llGjRjFp0iQOHDjA+PHjaf+Pr7t376a2thaA+++/n+nTpzNx4kRqa2u55557uOuuuxgzZgwXXnghe/fuBWD8+PHceOONnHvuuXzoQx9i3bp1HDlyhBEjRrBr1y4Ajhw5whlnnHF0vbuyDgIzKwW+BUwFRgIzzWxkp7LPAG+4+xnAN4DO/wJ3AU9m24uIyDF9dRAsrIL674IfSd4urEqOZ6mxsZHrr7+ezZs3U11dzWOPPXbc+ueff55ly5axfv165s+fz0knncSGDRsYN24c3//+94/W7d+/n40bN/Ltb3+bOXPmUFJSwtVXX82DDz4IwKpVqzjnnHMYOHBgVv3n4ojgfKDJ3V9y998DPwIu71RzOfBAWH4UmGDhryub2XTgN8DmHPQiIpLejc/Bh66AsvDbRsv6wugr4MZNWW+6rq6Oc889F4CxY8em/dXTqT7+8Y/Tr18/Bg4cSFVVFZdddhnAe35t9cyZMwG45JJLeOutt9i3bx9z5sw5GhZLlizhmmuuybr/XATBMOCVlPXmMJa2xt3bgDeBAWZ2MvCPwJdP9CBmdp2Z1ZtZfbaHQSISoX7vh4p+cPgdKKtM3lb8EfQbnPWmU3+tdGlpKW1tbZSVlXHkyBEADh48eMz64/3a6vDzcof14cOHM3jwYJ555hnWrVvH1KlTs+4/3xeLFwLfcPfWExW6+2J3T7h7ItvDIBGJ1Ns7Yew1cO2q5G1rz10wrq2tpaGhAaDDn6PMxNKlSwFYs2YNVVVVVFVVAXDttddy9dVXc8UVV1BaWnq8TXRJLn4NdQswPGW9Joylq2k2szKgCtgDXAB82sy+DlQDR8zsoLvfk4O+REQ6mvHgu8ufuqtHH+qmm27iyiuvZPHixXzyk5/s1jYqKysZM2YMhw4dYsmSJUfHp02bxjXXXJOT00JA8q/iZPNFMkxeAuqAPsCvgFGdaq4H7gvLM4BH0mxnIXBTVx5z7NixLiLywgsv5LuFHvOxj33M169fn3Zu/fr1fvHFFx/3/un2DVDvad5Tsz4icPc2M7sBWAmUAkvcfbOZ3RoedAXwXeAHZtYE7A1hICIiGVq0aBH33nvv0U8O5YL+MI2IFC39YZpj0x+mEZFoFOMPsz0t032iIBCRolVZWcmePXsUBincnT179lBZWdnl++iP14tI0aqpqaG5uTnrX7Hwh6ayspKampou1ysIRKRolZeXU1dXl+82ip5ODYmIRE5BICISOQWBiEjkFAQiIpFTEIiIRE5BICISOQWBiEjkFAQiIpFTEIiIRE5BICISOQWBiEjkFAQiIpFTEIiIRE5BICISOQWBiEjkFAQiIpFTEIiIRE5BICISOQWBiEjkFAQiIpFTEIiIRE5BICISOQWBiEjkFAQiIpFTEIiIRE5BICISuZwEgZlNMbNtZtZkZnPTzFeY2dIwv9bMasP4RDNrMLNN4fZPc9GPiIh0XdZBYGalwLeAqcBIYKaZjexU9hngDXc/A/gGcHsY3w1c5u6jgVnAD7LtR0REMpOLI4LzgSZ3f8ndfw/8CLi8U83lwANh+VFggpmZu29w91fD+Gagr5lV5KAnERHpolwEwTDglZT15jCWtsbd24A3gQGdav4CeNbd38lBTyIi0kVl+W4AwMxGkTxdNOk4NdcB1wGcdtppvdSZiMgfvlwcEbQAw1PWa8JY2hozKwOqgD1hvQZ4HPhrd//1sR7E3Re7e8LdEwMHDsxB2yIiArkJgvXACDOrM7M+wAxgRaeaFSQvBgN8GnjG3d3MqoH/Bua6+//moBcREclQ1kEQzvnfAKwEtgCPuPtmM7vVzKaFsu8CA8ysCfgi0P4R0xuAM4AFZrYxfA3KticREek6c/d895CxRCLh9fX1+W5DRKSomFmDuyc6j+t/FouIRE5BICISOQWBiEjkFAQiIpFTEIiIRE5BICISOQWBiEjkFAQiIpFTEIiIRE5BICISOQWBiEjkFAQiIpFTEIiIRE5BICISOQWBiEjkFAQiIpFTEIiIRE5BICISOQWBiEjkFAQiIpFTEIiIRE5BICISOQWBiEjkFAQiIpFTEIiIRE5BICISOQWBiEjkFAQiIpFTEIiIRE5BICISOQWBiEjkchIEZjbFzLaZWZOZzU0zX2FmS8P8WjOrTZmbF8a3mdnkXPSTzvINLVy6cCnPLhjLcwvO4bkF5/DsgrFMmftt1i64gAkLlzLxy0tZu+ACPjHvXtYuuIDLbnuMf16+iWm3Pfqems5zl932GMs3tLB8Q0u3x9r7zGS8p+Z6Y75Ya/KxrULtv5BqeuJ7PdNtZvX6/91r8L2p8LvX313esend2/+aAN+5NDmfY2XZbsDMSoFvAROBZmC9ma1w9xdSyj4DvOHuZ5jZDOB24C/NbCQwAxgFDAVWmdkH3f1wtn2lWr6hhZt//CsWlDzCmNKmDnPf7HMPI+xVZrc9AsB5pdv4Rvl/MMJe5cq3H+JffjmHr5Q9zHml2zrUdJ678u2HuPnHfcFggWU+Nm/Z+6j/7V4ea2jhn7xr4+3mLduU07npY4axfENLj863/7sUW00+tlWo/RdSzfHmoXvf65m+7rJ9/X/4A49z+su/hJ/fnnyAl38Jy66F3S8mb3dtTY7//Hb41F3kkrl7dhswGwcsdPfJYX0egLvfllKzMtT8n5mVAa8BA4G5qbWpdcd7zEQi4fX19V3u8Z2Fp1LBoYyeVz64g1nXx9+hHCDtc8tmrmLh7mPus1zNw7H/XQq5Jh/bKtT+C6nmePPQve/17rzuelVZBfzzzozuYmYN7p7oPJ6LU0PDgFdS1pvDWNoad28D3gQGdPG+AJjZdWZWb2b1u3btyqjBPzl4N0+2JWhLk3ntOdjmRptbh7EDXsYrR07lgJen1JSEufIOcwe8D//Tdh5PtiU44H0yHnu87SKmvnMby9s+2uXxiw9+kz85eHfO59r3WU/OF2tNPrZVqP0XUk1PfK9n+rrr/uu/43sJVspx35qtFM66DG7cdOyaDGV9aqi3uPtiYDEkjwgyuW959VD2tFZRyrtv8qnavIRSjoRloxSnzUuo4DD7qaCCNg56efgJwMNy23vm9lCF4VRwKOOxVvrSaLW00rfL432qhwDQ2pr7ufLqoT06X6w1+dhWofZfSDUnmu/OfTN93XX/9R/eS6wNyiqh7WDySVsppDtL7ofh5EHQb/B757opF0HQAgxPWa8JY+lqmsOpoSpgTxfvm7WbJ59J32Vv8bIPpA9t/JG9jQOlOIcoZdORD1BjyUOsZh/EANvHHq/m1z6ESSX1/PDwBB4+PIH7ypPn5f7m0BeZWbq6w9zM0tUMtjfB6NbY+0veZGZiOIOefavL4zdPPhOAkx7P/dzNk8/s0flircnHtgq1/0KqOdF8d+6b6esum9f/5NJ6ttf+JadPuQF+dFXySVf/Mby9E1p3weF3oE8/OO0CeHUDtOb2gnEurhGUAS8CE0i+ia8H/srdN6fUXA+Mdve/CReL/9zdrzSzUcBDwPkkLxavBkac6GJxptcIIHmxaeGKzew7kP68XnXfcszgjf2HKDXjsDvDqvvy8bMG8tOtu3h13wGqQs2+/YcY2mluaHXfo98gd6zc1q2x9gtXmYy3P7dcz/XGfLHW5GNbhdp/IdX0xPd6ptuE7F7/Pe1Y1wiyDoKw8U8AdwOlwBJ3/1czuxWod/cVZlYJ/AAYA+wFZrj7S+G+84E5QBvwBXd/8kSP150gEBGJXY8GQW9TEIiIZK4nPzUkIiJFTEEgIhI5BYGISOQUBCIikVMQiIhETkEgIhI5BYGISOQUBCIikVMQiIhETkEgIhI5BYGISOQUBCIikVMQiIhETkEgIhI5BYGISOQUBCIikVMQiIhETkEgIhI5BYGISOQUBCIikVMQiIhETkEgIhI5BYGISOQUBCIikVMQiIhETkEgIhI5BYGISOQUBCIikVMQiIhETkEgIhK5rILAzE4xs6fNrDHc9j9G3axQ02hms8LYSWb232a21cw2m9mibHoREZHuyfaIYC6w2t1HAKvDegdmdgpwC3ABcD5wS0pg3OnuZwFjgIvMbGqW/YiISIayDYLLgQfC8gPA9DQ1k4Gn3X2vu78BPA1Mcff97v5TAHf/PfAsUJNlPyIikqFsg2Cwu+8Iy68Bg9PUDANeSVlvDmNHmVk1cBnJowoREelFZScqMLNVwPvTTM1PXXF3NzPPtAEzKwMeBv7d3V86Tt11wHUAp512WqYPIyIix3DCIHD3S481Z2avm9kQd99hZkOAnWnKWoDxKes1wM9S1hcDje5+9wn6WBxqSSQSGQeOiIikl+2poRXArLA8C/hJmpqVwCQz6x8uEk8KY5jZV4Eq4AtZ9iEiIt2UbRAsAiaaWSNwaVjHzBJm9h0Ad98LfAVYH75udfe9ZlZD8vTSSOBZM9toZtdm2Y+IiGTI3IvvLEsikfD6+vp8tyEiUlTMrMHdE53H9T+LRUQipyAQEYmcgkBEJHIKAhGRyCkIREQipyAQEYmcgkBEJHIKAhGRyCkIREQipyAQEYmcgkBEJHIKAhGRyCkIREQipyAQEYmcgkBEJHIKAhGRyCkIREQipyAQEYmcgkBEJHIKAhGRyCkIREQipyAQEYmcgkBEJHIKAhGRyCkIREQipyAQEYmcgkBEJHIKAhGRyCkIREQipyAQEYmcgkBEJHJZBYGZnWJmT5tZY7jtf4y6WaGm0cxmpZlfYWbPZ9OLiIh0T7ZHBHOB1e4+Algd1jsws1OAW4ALgPOBW1IDw8z+HGjNsg8REemmbIPgcuCBsPwAMD1NzWTgaXff6+5vAE8DUwDM7GTgi8BXs+xDRES6KdsgGOzuO8Lya8DgNDXDgFdS1pvDGMBXgH8D9p/ogczsOjOrN7P6Xbt2ZdGyiIikKjtRgZmtAt6fZmp+6oq7u5l5Vx/YzM4FPuDuf29mtSeqd/fFwGKARCLR5ccREZHjO2EQuPulx5ozs9fNbIi77zCzIcDONGUtwPiU9RrgZ8A4IGFm20Mfg8zsZ+4+HhER6TXZnhpaAbR/CmgW8JM0NSuBSWbWP1wkngSsdPd73X2ou9cCFwMvKgRERHpftkGwCJhoZo3ApWEdM0uY2XcA3H0vyWsB68PXrWFMREQKgLkX3+n2RCLh9fX1+W5DRKSomFmDuyc6j+t/FouIRE5BICISOQWBiEjkFAQiIpFTEIiIRE5BICISOQWBiEjkFAQiIpFTEIiIRE5BICISOQWBiEjkFAQiIpFTEIiIRE5BICISOQWBiEjkFAQiIpFTEIiIRE5BICISOQWBiEjkFAQiIpFTEIiIRE5BICISOQWBiEjkFAQiIpEzd893Dxkzs13Ab7t591OB3Tlspzep9/xQ7/mh3nPvj919YOfBogyCbJhZvbsn8t1Hd6j3/FDv+aHee49ODYmIRE5BICISuRiDYHG+G8iCes8P9Z4f6r2XRHeNQEREOorxiEBERFIoCEREIhdNEJjZFDPbZmZNZjY33/10ZmbDzeynZvaCmW02sxvD+Clm9rSZNYbb/mHczOzfw/N5zsw+kt9nAGZWamYbzOyJsF5nZmtDj0vNrE8YrwjrTWG+Ns99V5vZo2a21cy2mNm4YtnvZvb34fvleTN72MwqC3W/m9kSM9tpZs+njGW8n81sVqhvNLNZeez9jvA985yZPW5m1Slz80Lv28xscsp4Yb4Pufsf/BdQCvwaOB3oA/wKGJnvvjr1OAT4SFjuB7wIjAS+DswN43OB28PyJ4AnAQMuBNYWwHP4IvAQ8ERYfwSYEZbvA/42LP8dcF9YngEszXPfDwDXhuU+QHUx7HdgGPAboG/K/p5dqPsduAT4CPB8ylhG+xk4BXgp3PYPy/3z1PskoCws357S+8jwHlMB1IX3ntJCfh/KewO99A04DliZsj4PmJfvvk7Q80+AicA2YEgYGwJsC8v/CcxMqT9al6d+a4DVwJ8CT4QX8O6UF8rRfwNgJTAuLJeFOstT31XhzdQ6jRf8fg9B8Ep4UywL+31yIe93oLbTm2lG+xmYCfxnyniHut7svdPcnwEPhuUO7y/t+72Q34diOTXU/oJp1xzGClI4ZB8DrAUGu/uOMPUaMDgsF9pzuhv4B+BIWB8A7HP3trCe2t/R3sP8m6E+H+qAXcD3wmmt75jZ+yiC/e7uLcCdwMvADpL7sYHi2O/tMt3PBbP/O5lD8ggGiq/3aIKgaJjZycBjwBfc/a3UOU/+GFFwn/c1s08BO929Id+9dEMZyUP+e919DPA2yVMURxXwfu8PXE4yzIYC7wOm5LWpLBTqfj4RM5sPtAEP5ruX7oolCFqA4SnrNWGsoJhZOckQeNDdl4Xh181sSJgfAuwM44X0nC4CppnZduBHJE8PfROoNrOyUJPa39Hew3wVsKc3G07RDDS7+9qw/ijJYCiG/X4p8Bt33+Xuh4BlJP8timG/t8t0PxfS/sfMZgOfAq4KQQZF0nuqWIJgPTAifJqiD8kLZSvy3FMHZmbAd4Et7n5XytQKoP2TEbNIXjtoH//r8OmKC4E3Uw6xe5W7z3P3GnevJblvn3H3q4CfAp8OZZ17b39Onw71eflJ0N1fA14xszPD0ATgBYpgv5M8JXShmZ0Uvn/aey/4/Z4i0/28EphkZv3DEdGkMNbrzGwKydOh09x9f8rUCmBG+JRWHTACWEchvw/l+yJFb32R/BTCiySv2s/Pdz9p+ruY5GHxc8DG8PUJkudwVwONwCrglFBvwLfC89kEJPL9HEJf43n3U0Onk3wBNAE/BirCeGVYbwrzp+e553OB+rDvl5P8NEpR7Hfgy8BW4HngByQ/qVKQ+x14mOS1jEMkj8Q+0539TPJ8fFP4uiaPvTeRPOff/nq9L6V+fuh9GzA1Zbwg34f0KyZERCIXy6khERE5BgWBiEjkFAQiIpFTEIiIRE5BICISOQWBiEjkFAQiIpH7f9jh09MIHeX/AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "omega = [0,pi]\n",
    "f = lambda x : sin(x)\n",
    "n=50\n",
    "bc = [0,0]\n",
    "A, b = finDif(omega, f, n, bc)\n",
    "\n",
    "random.seed(0) \n",
    "eigval, eigvect = Find_eig(A, N = 15, equal_tol=1e-12)\n",
    "\n",
    "# lets's check if everything is correct\n",
    "eig, _ = linalg.eig(A)\n",
    "\n",
    "# let's make a plot\n",
    "plot(sort(unique(eigval)), zeros_like(eigval), 'o', label= \"mine\")\n",
    "plot(sort(eig), zeros_like(eig), '*', label= \"numpy\")\n",
    "_=legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5de35ef",
   "metadata": {},
   "source": [
    "### Additional\n",
    "\n",
    "It is clear that the power method works correctly and very efficiently, however not all the eigenvalues/ eigenvectors are found. In particular the biggest eigenvalues are not found. One possible solution would be to include more random points in Gershgorin circles, however this can increment extremely the computational cost. Alternatively, for finding the biggest eigenvalue, one could use the directive power method to find the biggest eigenvalue. Another solution is now proposed.\n",
    "\n",
    "Since A is a symmetric, real and positive definite matrix the QR factorization can be exploit to calculate eigenvalues and eigenvector, as also stated in Chapter 6 of *Alfio Quarteroni, Fausto Saleri, and Paola Gervasio. 2016. Scientific Computing with MATLAB and Octave. Springer Publishing Company, Incorporated\" for details*. \n",
    "\n",
    "The QR factorization consits in finding a matrix Q orthogonal and R upper triangular matrix. If A is invertible, then the factorization is unique if we require the diagonal elements of R to be positive. The factorization is performed in `QR()` function using the Grand-Shmidt algorithm."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "id": "556d6f5c",
   "metadata": {
    "id": "622aadf4"
   },
   "outputs": [],
   "source": [
    "def QR(A):\n",
    "    \"\"\"\n",
    "    Implementing QR factorization\n",
    "    \n",
    "    info: The following function implement the QR factorization\n",
    "          see \"Alfio Quarteroni, Fausto Saleri, and Paola Gervasio. 2016. \n",
    "               Scientific Computing with MATLAB and Octave. Springer Publishing \n",
    "               Company, Incorporated\" for details\".\n",
    "               \n",
    "    input: A => numpy 2D array as input matrix\n",
    "    \n",
    "    return: Q => numpy 2D array as orthogonal matrix (QT*Q = 1) \n",
    "            R => numpy 2D array as square upper triangular matrix\n",
    "    \"\"\"\n",
    "    A = array(A, dtype = 'float64')\n",
    "    R = zeros_like(A)\n",
    "    for j in range(shape(A)[0]):\n",
    "        R[j, j] = linalg.norm(A[:,j])\n",
    "        A[:, j] = A[:, j] / R[j, j]\n",
    "        for k in range(j+1, shape(A)[0]):\n",
    "            R[j, k] = dot(A[:,j], A[:,k])\n",
    "            A[:, k] -= A[:,j]*R[j, k]\n",
    "    return A, R\n",
    "\n",
    "def eigen(A, MAX_CYCLES = 5000):\n",
    "    \"\"\"\n",
    "    Calculating eigenvalue and eigenvector for symmetric real\n",
    "    positive definite matrices exploiting QR factorization.\n",
    "    \n",
    "    input: A => numpy 2D array as input matrix\n",
    "    \n",
    "    param: MAX_CYCLES => max number of iterations before stopping\n",
    "    \n",
    "    return: The function returns a tuple. First tuple element `w` is a\n",
    "            numpy 1D array representing all eigenvalues. Second tuple \n",
    "            element `v` is a numpy 2D array with eigenvectors as column elements\n",
    "            ordered with respect to eigenvalues. For istance the column \n",
    "            v[:,i] is the eigenvector corresponding to the eigenvalue w[i].\n",
    "    \"\"\"\n",
    "    Q, R = QR(A)\n",
    "    S = Q\n",
    "    A = matmul(R, Q)\n",
    "    eig = diag(A)\n",
    "    for _ in range(MAX_CYCLES):\n",
    "        Q, R = QR(A)\n",
    "        S = matmul(S, Q)\n",
    "        A = matmul(R, Q)\n",
    "            \n",
    "    return diag(A), S"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ff43d7a",
   "metadata": {},
   "source": [
    "Here a small test, it takes approximately 33.07 s to run"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "7be92202",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0686562745831907e-11"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Original problem\n",
    "omega = [0,pi]\n",
    "f = lambda x : sin(x)\n",
    "n = 50\n",
    "# n=100 # more points increase the time to 137.38 s and max difference 0.0022\n",
    "bc = [0,0]\n",
    "A, b = finDif(omega, f, n, bc)\n",
    "\n",
    "eigval, eigvect = eigen(A)\n",
    "\n",
    "# lets's check if everything is correct\n",
    "eig, _ = linalg.eig(A)\n",
    "\n",
    "# let's make a plot\n",
    "plot(sort(unique(eigval)), zeros_like(eigval), 'o', label= \"mine\")\n",
    "plot(sort(eig), zeros_like(eig), '*', label= \"numpy\")\n",
    "_=legend()\n",
    "\n",
    "max(sort(eigval) - sort(eig)) # maximum difference between eigenvalues"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fdd9096",
   "metadata": {},
   "source": [
    "As we can seen not only all the eigenvalues are found, but the computational time is on the same order as the LU factorization. Finally a remark, this method does not always converge since the matrix has to be symmetric. However, in case of the proposed finite element problem, it provides and efficient solution.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01247f32",
   "metadata": {
    "id": "cb22566e"
   },
   "source": [
    "Consider the following Cauchy problem\n",
    "$$\n",
    "\\begin{cases}\n",
    "y'= -ty^2 \\quad 0\\le t \\le 2\\\\\n",
    "y(0) = 1\n",
    "\\end{cases}\n",
    "$$\n",
    "Implement a Backward Euler's method in a suitable function and solve the resulting non-linear equation using a Newton's method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "id": "92bb1444",
   "metadata": {
    "id": "3184e358"
   },
   "outputs": [],
   "source": [
    "def Newton(f, Df, x, tol = 1e-10, MAX_ITER = 1000):\n",
    "    \"\"\"\n",
    "    Implementing newton method for zeros search.\n",
    "    \n",
    "    info: The following function implement the Newton method\n",
    "          to search zeros of a function.\n",
    "               \n",
    "    input: f => a function for searching its zeros\n",
    "           Df => a function representing derivative of f\n",
    "           x => initial poin to search\n",
    "    \n",
    "    param: tol => tolerance for stopping criteria\n",
    "           MAX_ITER => max number of iterations before stopping\n",
    "           \n",
    "    return: x => zero of f \n",
    "            \n",
    "    additional: The stop criteria ensures a good approximation\n",
    "                only if |Df(x)| ~ 1 for every x.\n",
    "    \"\"\"\n",
    "    for _ in range(MAX_ITER):\n",
    "        x = x - f(x) / Df(x)\n",
    "        if( abs(f(x)) < tol ):\n",
    "            return x\n",
    "    return x\n",
    "\n",
    "def Backward_Euler(y0, omega, N = 100):\n",
    "    \"\"\"\n",
    "    Solve ordinary differential equation using Backward Euler\n",
    "    \n",
    "    info: The program solve ODE of the form:\n",
    "                        y'(t) = -t*y^2, t in omega\n",
    "                        y(t = 0) = y0\n",
    "    \n",
    "    input: y0 => a function for searching its zeros\n",
    "           omega => list or numpy 1D array of dimension 2 representing boundary conditions\n",
    "    \n",
    "    param: N => number of nodes for Backward Euler\n",
    "\n",
    "    return: t => time discretization as numpy 1D array\n",
    "            y => solution of ODE as numpy 1D array\n",
    "    \"\"\"\n",
    "    h = ( omega[1] - omega[0] ) / N\n",
    "    t = linspace(omega[0], omega[1], num = N+1, dtype='float64')\n",
    "    y = zeros_like(t)\n",
    "    y[0] = y0\n",
    "    \n",
    "    for k in range(1, N+1):\n",
    "        f = lambda x : x - y[k-1] + h*t[k]*power(x, 2)\n",
    "        Df = lambda x : 1 + 2*h*t[k]*x\n",
    "        y[k] = Newton(f, Df, y[k-1])\n",
    "        \n",
    "    return t, y"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "406394db",
   "metadata": {},
   "source": [
    "Since the Cauchy problem is easily solvable by hand, let's plot for 50 nodes the solution we obtain versus the exact solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "id": "33d65727",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "y0=1\n",
    "omega = [0, 2]\n",
    "t, y = Backward_Euler(y0, omega, N = 50)\n",
    "exact = lambda x: 2 / ( power(x, 2) + 2 )\n",
    "\n",
    "plot(t, y, 'o', label = 'numerical')\n",
    "plot(t, exact(t), label = 'exact')\n",
    "legend()\n",
    "xlabel(\"t\", fontsize=12)\n",
    "ylabel(\"y(t)\", fontsize=12, rotation=0, labelpad=20)\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa27d13c",
   "metadata": {},
   "source": [
    "Here a graph on the max absolute error between numerical and exact solution as the number of nodes increases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "id": "c639c14d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "y0=1\n",
    "omega = [0, 2]\n",
    "N = [i for i in range(10, 1000, 10)]\n",
    "err = []\n",
    "exact = lambda x: 2 / ( power(x, 2) + 2 )\n",
    "for n in N:\n",
    "    t, y = Backward_Euler(y0, omega, n)\n",
    "    err.append(max(abs(exact(t) - y)))\n",
    "    \n",
    "plot(N, err)\n",
    "xlabel(\"Number of nodes\", fontsize=15)\n",
    "ylabel(\"Error\", fontsize=15, rotation=0, labelpad=20)\n",
    "yscale('log')\n",
    "show()"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "name": "FinalProject-2021-2022.ipynb",
   "provenance": []
  },
  "interpreter": {
   "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}