11 - Factorizations and other fun.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Factorizations and other fun\n",
    "Based on work by Andreas Noack\n",
    "\n",
    "## Outline\n",
    " - Factorizations\n",
    " - Special matrix structures\n",
    " - Generic linear algebra"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before we get started, let's set up a linear system and use `LinearAlgebra` to bring in the factorizations and special matrix structures."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Float64}:\n",
       " 0.7903232003508388\n",
       " 2.2080487943252667\n",
       " 2.046479072975802"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using LinearAlgebra\n",
    "A = rand(3, 3)\n",
    "x = fill(1, (3,))\n",
    "b = A * x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Factorizations\n",
    "\n",
    "#### LU factorizations\n",
    "In Julia we can perform an LU factorization\n",
    "```julia\n",
    "PA = LU\n",
    "``` \n",
    "where `P` is a permutation matrix, `L` is lower triangular unit diagonal and `U` is upper triangular, using `lufact`.\n",
    "\n",
    "Julia allows computing the LU factorization and defines a composite factorization type for storing it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LU{Float64, Matrix{Float64}, Vector{Int64}}\n",
       "L factor:\n",
       "3×3 Matrix{Float64}:\n",
       " 1.0        0.0       0.0\n",
       " 0.366062   1.0       0.0\n",
       " 0.586798  -0.913725  1.0\n",
       "U factor:\n",
       "3×3 Matrix{Float64}:\n",
       " 0.791473   0.999758  0.255248\n",
       " 0.0       -0.254289  0.295474\n",
       " 0.0        0.0       1.04481"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Alu = lu(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LU{Float64, Matrix{Float64}, Vector{Int64}}"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(Alu)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The different parts of the factorization can be extracted by accessing their special properties"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 Matrix{Float64}:\n",
       " 0.0  0.0  1.0\n",
       " 1.0  0.0  0.0\n",
       " 0.0  1.0  0.0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Alu.P"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 Matrix{Float64}:\n",
       " 1.0        0.0       0.0\n",
       " 0.366062   1.0       0.0\n",
       " 0.586798  -0.913725  1.0"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Alu.L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 Matrix{Float64}:\n",
       " 0.791473   0.999758  0.255248\n",
       " 0.0       -0.254289  0.295474\n",
       " 0.0        0.0       1.04481"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Alu.U"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Julia can dispatch methods on factorization objects.\n",
    "\n",
    "For example, we can solve the linear system using either the original matrix or the factorization object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Float64}:\n",
       " 0.9999999999999994\n",
       " 1.0000000000000002\n",
       " 1.0000000000000002"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A\\b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Float64}:\n",
       " 0.9999999999999994\n",
       " 1.0000000000000002\n",
       " 1.0000000000000002"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Alu\\b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, we can calculate the determinant of `A` using either `A` or the factorization object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "det(A) ≈ det(Alu)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### QR factorizations\n",
    "\n",
    "In Julia we can perform a QR factorization\n",
    "```\n",
    "A=QR\n",
    "``` \n",
    "\n",
    "where `Q` is unitary/orthogonal and `R` is upper triangular, using `qrfact`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LinearAlgebra.QRCompactWY{Float64, Matrix{Float64}, Matrix{Float64}}\n",
       "Q factor:\n",
       "3×3 LinearAlgebra.QRCompactWYQ{Float64, Matrix{Float64}, Matrix{Float64}}:\n",
       " -0.301071   0.773468   -0.557767\n",
       " -0.482617  -0.628056   -0.610432\n",
       " -0.822458   0.0854046   0.562378\n",
       "R factor:\n",
       "3×3 Matrix{Float64}:\n",
       " -0.962326  -1.25115   -0.773252\n",
       "  0.0       -0.342613  -0.258097\n",
       "  0.0        0.0       -0.637786"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Aqr = qr(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly to the LU factorization, the matrices `Q` and `R` can be extracted from the QR factorization object via"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 LinearAlgebra.QRCompactWYQ{Float64, Matrix{Float64}, Matrix{Float64}}:\n",
       " -0.301071   0.773468   -0.557767\n",
       " -0.482617  -0.628056   -0.610432\n",
       " -0.822458   0.0854046   0.562378"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Aqr.Q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 Matrix{Float64}:\n",
       " -0.962326  -1.25115   -0.773252\n",
       "  0.0       -0.342613  -0.258097\n",
       "  0.0        0.0       -0.637786"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Aqr.R"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Eigendecompositions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The results from eigendecompositions, singular value decompositions, Hessenberg factorizations, and Schur decompositions are all stored in `Factorization` types.\n",
    "\n",
    "The eigendecomposition can be computed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Eigen{Float64, Float64, Matrix{Float64}, Vector{Float64}}\n",
       "values:\n",
       "3-element Vector{Float64}:\n",
       " -1.18054684830493\n",
       "  0.3567033738339611\n",
       "  3.5518077270477697\n",
       "vectors:\n",
       "3×3 Matrix{Float64}:\n",
       " -0.382278   0.844888   -0.374202\n",
       " -0.466467  -0.52602    -0.711134\n",
       "  0.797666   0.0972982  -0.595199"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Asym = A + A'\n",
    "AsymEig = eigen(Asym)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The values and the vectors can be extracted from the Eigen type by special indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Float64}:\n",
       " -1.18054684830493\n",
       "  0.3567033738339611\n",
       "  3.5518077270477697"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AsymEig.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 Matrix{Float64}:\n",
       " -0.382278   0.844888   -0.374202\n",
       " -0.466467  -0.52602    -0.711134\n",
       "  0.797666   0.0972982  -0.595199"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AsymEig.vectors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once again, when the factorization is stored in a type, we can dispatch on it and write specialized methods that exploit the properties of the factorization, e.g. that $A^{-1}=(V\\Lambda V^{-1})^{-1}=V\\Lambda^{-1}V^{-1}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 Matrix{Float64}:\n",
       "  1.0           3.55271e-15  -4.27436e-15\n",
       "  1.55431e-15   1.0          -1.69309e-15\n",
       " -2.10942e-15  -3.10862e-15   1.0"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inv(AsymEig)*Asym"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Special matrix structures\n",
    "Matrix structure is very important in linear algebra. To see *how* important it is, let's work with a larger linear system"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 1000\n",
    "A = randn(n,n);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Julia can often infer special matrix structure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Asym = A + A'\n",
    "issymmetric(Asym)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "but sometimes floating point error might get in the way."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.31080854640633504"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Asym_noisy = copy(Asym)\n",
    "Asym_noisy[1,2] += 5eps()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "issymmetric(Asym_noisy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Luckily we can declare structure explicitly with, for example, `Diagonal`, `Triangular`, `Symmetric`, `Hermitian`, `Tridiagonal` and `SymTridiagonal`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "Asym_explicit = Symmetric(Asym_noisy);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's compare how long it takes Julia to compute the eigenvalues of `Asym`, `Asym_noisy`, and `Asym_explicit`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  0.260466 seconds (268.81 k allocations: 25.902 MiB, 68.80% compilation time)\n"
     ]
    }
   ],
   "source": [
    "@time eigvals(Asym);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  0.470274 seconds (14 allocations: 7.928 MiB)\n"
     ]
    }
   ],
   "source": [
    "@time eigvals(Asym_noisy);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  0.129337 seconds (69.82 k allocations: 12.733 MiB, 3.46% gc time, 27.93% compilation time)\n"
     ]
    }
   ],
   "source": [
    "@time eigvals(Asym_explicit);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, using `Symmetric()` on `Asym_noisy` made our calculations about `5x` more efficient :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### A big problem\n",
    "Using the `Tridiagonal` and `SymTridiagonal` types to store tridiagonal matrices makes it possible to work with potentially very large tridiagonal problems. The following problem would not be possible to solve on a laptop if the matrix had to be stored as a (dense) `Matrix` type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  0.596842 seconds (491.92 k allocations: 214.376 MiB, 1.72% gc time, 21.44% compilation time)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "7.087455018812964"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = 1_000_000;\n",
    "A = SymTridiagonal(randn(n), randn(n-1));\n",
    "@time eigmax(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generic linear algebra\n",
    "The usual way of adding support for numerical linear algebra is by wrapping BLAS and LAPACK subroutines. For matrices with elements of `Float32`, `Float64`, `Complex{Float32}` or `Complex{Float64}` this is also what Julia does.\n",
    "\n",
    "However, Julia also supports generic linear algebra, allowing you to, for example, work with matrices and vectors of rational numbers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Rational numbers\n",
    "Julia has rational numbers built in. To construct a rational number, use double forward slashes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1//2"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1//2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example: Rational linear system of equations\n",
    "The following example shows how linear system of equations with rational elements can be solved without promoting to floating point element types. Overflow can easily become a problem when working with rational numbers so we use `BigInt`s."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 Matrix{Rational{BigInt}}:\n",
       " 2//5   1//10  1//5\n",
       " 3//5   1//1   7//10\n",
       " 7//10  4//5   1//10"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Arational = Matrix{Rational{BigInt}}(rand(1:10, 3, 3))/10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Rational{BigInt}}:\n",
       "  7//10\n",
       " 23//10\n",
       "  8//5"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = fill(1, 3)\n",
    "b = Arational*x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Rational{BigInt}}:\n",
       " 1//1\n",
       " 1//1\n",
       " 1//1"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Arational\\b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LU{Rational{BigInt}, Matrix{Rational{BigInt}}, Vector{Int64}}\n",
       "L factor:\n",
       "3×3 Matrix{Rational{BigInt}}:\n",
       " 1//1    0//1   0//1\n",
       " 4//7    1//1   0//1\n",
       " 6//7  -22//25  1//1\n",
       "U factor:\n",
       "3×3 Matrix{Rational{BigInt}}:\n",
       " 7//10   4//5    1//10\n",
       " 0//1   -5//14   1//7\n",
       " 0//1    0//1   37//50"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lu(Arational)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercises\n",
    "\n",
    "#### 11.1\n",
    "What are the eigenvalues of matrix A?\n",
    "\n",
    "```\n",
    "A =\n",
    "[\n",
    " 140   97   74  168  131\n",
    "  97  106   89  131   36\n",
    "  74   89  152  144   71\n",
    " 168  131  144   54  142\n",
    " 131   36   71  142   36\n",
    "]\n",
    "```\n",
    "and assign it a variable `A_eigv`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5×5 Matrix{Int64}:\n",
       " 140   97   74  168  131\n",
       "  97  106   89  131   36\n",
       "  74   89  152  144   71\n",
       " 168  131  144   54  142\n",
       " 131   36   71  142   36"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using LinearAlgebra\n",
    "A = [\n",
    " 140   97   74  168  131\n",
    "  97  106   89  131   36\n",
    "  74   89  152  144   71\n",
    " 168  131  144   54  142\n",
    " 131   36   71  142   36\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5-element Vector{Float64}:\n",
       " -128.49322764802147\n",
       "  -55.887784553056875\n",
       "   42.7521672793189\n",
       "   87.16111477514521\n",
       "  542.4677301466143"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_eigv = eigvals(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "deletable": false,
    "editable": false,
    "hide_input": true,
    "nbgrader": {
     "checksum": "f9f16fdef201ed372323a291f1dd1346",
     "grade": true,
     "grade_id": "cell-4d5f60c8a814c789",
     "locked": true,
     "points": 0,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "AssertionError: A_eigv == [-128.49322764802145, -55.887784553056875, 42.7521672793189, 87.16111477514521, 542.4677301466143]",
     "output_type": "error",
     "traceback": [
      "AssertionError: A_eigv == [-128.49322764802145, -55.887784553056875, 42.7521672793189, 87.16111477514521, 542.4677301466143]",
      "",
      "Stacktrace:",
      " [1] top-level scope",
      "   @ In[45]:1"
     ]
    }
   ],
   "source": [
    "@assert A_eigv ==  [-128.49322764802145, -55.887784553056875, 42.7521672793189, 87.16111477514521, 542.4677301466143]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 11.2 \n",
    "Create a `Diagonal` matrix from the eigenvalues of `A`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5×5 Diagonal{Float64, Vector{Float64}}:\n",
       " -128.493     ⋅        ⋅        ⋅         ⋅ \n",
       "     ⋅     -55.8878    ⋅        ⋅         ⋅ \n",
       "     ⋅        ⋅      42.7522    ⋅         ⋅ \n",
       "     ⋅        ⋅        ⋅      87.1611     ⋅ \n",
       "     ⋅        ⋅        ⋅        ⋅      542.468"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_diag = Diagonal(A_eigv)\n",
    "A_diag[1,1]=round(A_diag[1,1]; digits=3);\n",
    "A_diag[5,5]=round(A_diag[5,5]; digits=3);\n",
    "A_diag = round.(A_diag;digits=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "deletable": false,
    "editable": false,
    "hide_input": true,
    "nbgrader": {
     "checksum": "3ca676f6282c1a7c214ab2cb9f9b322d",
     "grade": true,
     "grade_id": "cell-3b000a3710c9c263",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "@assert A_diag ==  [-128.493    0.0      0.0      0.0       0.0;\n",
    "    0.0    -55.8878   0.0      0.0       0.0;\n",
    "    0.0      0.0     42.7522   0.0       0.0;\n",
    "    0.0      0.0      0.0     87.1611    0.0;\n",
    "    0.0 0.0      0.0      0.0     542.468]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 11.3 \n",
    "Create a `LowerTriangular` matrix from `A` and store it in `A_lowertri`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5×5 LowerTriangular{Int64, Matrix{Int64}}:\n",
       " 140    ⋅    ⋅    ⋅   ⋅\n",
       "  97  106    ⋅    ⋅   ⋅\n",
       "  74   89  152    ⋅   ⋅\n",
       " 168  131  144   54   ⋅\n",
       " 131   36   71  142  36"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_lowertri = LowerTriangular(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "deletable": false,
    "editable": false,
    "hide_input": true,
    "nbgrader": {
     "checksum": "b3b1a272343a05082f378a5e1aa3426d",
     "grade": true,
     "grade_id": "cell-b76cee2b4a8777da",
     "locked": true,
     "points": 0,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "@assert A_lowertri ==  [140    0    0    0   0;\n",
    "  97  106    0    0   0;\n",
    "  74   89  152    0   0;\n",
    " 168  131  144   54   0;\n",
    " 131   36   71  142  36]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.9.3",
   "language": "julia",
   "name": "julia-1.9"
  },
  "language": "Julia",
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.9.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}