NumPy_Recap.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "823f778a",
   "metadata": {},
   "source": [
    "### NumPy Revision"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "de0c7911",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "622b3ffd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([1,2,3,4,5])\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "ff0abc22",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d37d72b2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[:2] # you are slicing up to the stopping index of 2 - format is i:j:k where i is starting, j stopping, k is step"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "cce2a67c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5,)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.shape "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "04535236",
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])\n",
    "A = A.astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f5f613e3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 4)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "435ec8f1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[2,3] # single element indexing (2nd row 3rd col)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "7ced612c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 6,  7],\n",
       "       [10, 11]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[1:, 1:3] # multi element indexing - select all rows from index 1 onwards, select columns from 1 to 3 (2nd to 4th-not inclusive)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "6fa170f2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  1,   2,   3,   4],\n",
       "       [  5,   6,   7,   8],\n",
       "       [  9,  10,  11, 250]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[2,3] = 250 # setting new elements\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "8419a1b5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0.],\n",
       "       [0., 1.]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "I = np.eye(2) # creates a 2x2 identity array\n",
    "I"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "20ab0209",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0.],\n",
       "       [0., 1., 0.],\n",
       "       [0., 0., 1.]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.identity(3) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "e2c90bcc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((5,5)) # creates an array of 0s with specified shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "bda1bf05",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones((3,4)) # creates an array of 1s with specified shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "e2658485",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[nan, nan, nan, nan, nan],\n",
       "       [nan, nan, nan, nan, nan],\n",
       "       [nan, nan, nan, nan, nan],\n",
       "       [nan, nan, nan, nan, nan],\n",
       "       [nan, nan, nan, nan, nan]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C = np.full((5,5), np.nan) # creates an array with specified shape and fill_value (in this case np.nan)\n",
    "C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "7b2c6940",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.92731985]\n",
      " [0.75509351]\n",
      " [0.44419956]\n",
      " ...\n",
      " [0.81235095]\n",
      " [0.94652129]\n",
      " [0.89221622]]\n"
     ]
    }
   ],
   "source": [
    "X = np.random.random((100000,1)) # uniform distribution with 10,000 samples\n",
    "print(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "7da8da3f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean of X is approx: 0.4991287677563973\n",
      "Stdev of X is approx: 0.0833947739531488\n"
     ]
    }
   ],
   "source": [
    "print('Mean of X is approx:', np.mean(X)) # should be 0.5 \n",
    "print('Stdev of X is approx:', np.std(X)**2) # should be close to 1/12"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1c580ad",
   "metadata": {},
   "source": [
    "* Arithmetic Operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "4eae58d3",
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([[1,5,6], [1,8,9], [1,-1,6]])\n",
    "B = np.array([[4,8,4], [1,1,5], [6,-8,4]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "62694505",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  5,  6],\n",
       "       [ 1,  8,  9],\n",
       "       [ 1, -1,  6]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "0582fd88",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 4,  8,  4],\n",
       "       [ 1,  1,  5],\n",
       "       [ 6, -8,  4]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "64a80ce9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5., 13., 10.],\n",
       "       [ 2.,  9., 14.],\n",
       "       [ 7., -9., 10.]])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C = np.add(A,B, dtype=float)\n",
    "C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "cb47ba99",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "5671886f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-3., -3.,  2.],\n",
       "       [ 0.,  7.,  4.],\n",
       "       [-5.,  7.,  2.]])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D = np.subtract(A,B, dtype=float)\n",
    "D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "6adad3c8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 4., 40., 24.],\n",
       "       [ 1.,  8., 45.],\n",
       "       [ 6.,  8., 24.]])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E = np.multiply(A, B, dtype=float) # pointwise multiplication\n",
    "E"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "e3434b4a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.25      , 0.625     , 1.5       ],\n",
       "       [1.        , 8.        , 1.8       ],\n",
       "       [0.16666667, 0.125     , 1.5       ]])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "F = np.divide(A, B, dtype=float) # pointwise division\n",
    "F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "49fe3406",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 1],\n",
       "       [1, 8, 1],\n",
       "       [0, 0, 1]])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "F = np.int64(F)\n",
    "F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "13c8dc46",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 45., -35.,  53.],\n",
       "       [ 66., -56.,  80.],\n",
       "       [ 39., -41.,  23.]])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "G = np.matmul(A, B, dtype=float) # matrix multiplcation\n",
    "G"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "2375d24f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = A[:, 0]\n",
    "b = B[:, 0]\n",
    "\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "e75d85da",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 1, 6])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "c5a2deef",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.matmul(a, b) # 4+1+6"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e3343e8",
   "metadata": {},
   "source": [
    "recall in linear algebra dot product is represented as $ x\\cdot y \\text{ becomes } \\textbf{x}^T \\textbf{y}.$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "44acc51a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(a, b) # dot product, product of 2 same size vectors; returns scalar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "da22b1cc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.inner(a, b) # inner product, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "90c26e4b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 12,  39,  87],\n",
       "       [ 18,  60, 132],\n",
       "       [  6,  -9,  33]])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.matmul(A, A) # matrix multiplication of A with itself"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "5c00c7b1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 12,  39,  87],\n",
       "       [ 18,  60, 132],\n",
       "       [  6,  -9,  33]])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.matrix_power(A, 2) # matrix power 2 "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "086f14c3",
   "metadata": {},
   "source": [
    "* Matrix Decomposition"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a35178a7",
   "metadata": {},
   "source": [
    "**QR Decomposition**\n",
    "\n",
    "$$ A = QR $$\n",
    "where Q is an orthonormal matrix and R is an upper triangular matrix. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "17347dd3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  5,  6],\n",
       "       [ 1,  8,  9],\n",
       "       [ 1, -1,  6]])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "9aeb14f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "Q, R = np.linalg.qr(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "d38b471e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.57735027, -0.15430335, -0.80178373],\n",
       "       [-0.57735027, -0.6172134 ,  0.53452248],\n",
       "       [-0.57735027,  0.77151675,  0.26726124]])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "5d34c939",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ -1.73205081,  -6.92820323, -12.12435565],\n",
       "       [  0.        ,  -6.4807407 ,  -1.8516402 ],\n",
       "       [  0.        ,   0.        ,   1.60356745]])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "R"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "a0cfff2c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  5.,  6.],\n",
       "       [ 1.,  8.,  9.],\n",
       "       [ 1., -1.,  6.]])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.matmul(Q, R)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8dd1aca",
   "metadata": {},
   "source": [
    "**Eigenvalue Decomposition**\n",
    "\n",
    "$$ A = PDP^{-1} $$\n",
    "where P's columns consists of the eigenvectors of A and D is a diagonal matrix whose entries are the eigenvalues of A."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "25dab88b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  5,  6],\n",
       "       [ 1,  8,  9],\n",
       "       [ 1, -1,  6]])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "b8612b37",
   "metadata": {},
   "outputs": [],
   "source": [
    "d, P = np.linalg.eig(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "5ed3356a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.32598999+0.j        , 7.33700501+1.17676556j,\n",
       "       7.33700501-1.17676556j])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "a4dc2fb7",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.98472698+0.j        ,  0.53851429+0.00214369j,\n",
       "         0.53851429-0.00214369j],\n",
       "       [-0.06233426+0.j        ,  0.82690915+0.j        ,\n",
       "         0.82690915-0.j        ],\n",
       "       [ 0.16256452+0.j        , -0.1207501 +0.10788161j,\n",
       "        -0.1207501 -0.10788161j]])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "a5a89b67",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.32598999+0.j        , 0.        +0.j        ,\n",
       "        0.        +0.j        ],\n",
       "       [0.        +0.j        , 7.33700501+1.17676556j,\n",
       "        0.        +0.j        ],\n",
       "       [0.        +0.j        , 0.        +0.j        ,\n",
       "        7.33700501-1.17676556j]])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D = np.diag(d) # extract a diagonal array\n",
    "D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "abef11fd",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  5.,  6.],\n",
       "       [ 1.,  8.,  9.],\n",
       "       [ 1., -1.,  6.]])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.real(np.matmul(np.matmul(P, D), np.linalg.inv(P)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37238061",
   "metadata": {},
   "source": [
    "**Singular Value Decomposition**\n",
    "\n",
    "$$ A = USV^{T} $$\n",
    "\n",
    "where the equation represents the decomposition of a matrix $A$ into three matrices: $U$, $S$, and $V^{T}$.\n",
    "\n",
    "$A$ is an $m \\times n$ matrix that we want to decompose using SVD.\n",
    "$U$ is an $m \\times m$ orthogonal matrix, which means that its columns are orthonormal vectors (unit vectors that are orthogonal to each other). The columns of $U$ are called the left singular vectors of $A$.\n",
    "$S$ is an $m \\times n$ diagonal matrix with non-negative real numbers on the diagonal. These diagonal entries are known as the singular values of $A$ and are typically arranged in descending order. The singular values represent the scaling factors applied to the singular vectors.\n",
    "$V^{T}$ is the transpose of an $n \\times n$ orthogonal matrix $V$. The columns of $V$ are called the right singular vectors of $A$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "cc01a42d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  5,  6],\n",
       "       [ 1,  8,  9],\n",
       "       [ 1, -1,  6]])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "9c621b8a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  5.,  6.],\n",
       "       [ 1.,  8.,  9.],\n",
       "       [ 1., -1.,  6.]])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "U, s, V_t = np.linalg.svd(A)\n",
    "S = np.diag(s)\n",
    "\n",
    "np.matmul(np.matmul(U, S), V_t)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5330b544",
   "metadata": {},
   "source": [
    "* Matrix Norms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "e4258b19",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15.684387141358123"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.norm(A) # default norm for vectors 2-norm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "683be9ec",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17.999999999999996"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.det(A) # compute the determinant of an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "3f4fa25a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.matrix_rank(A) # return matrix rank of array using SVD method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "c4e52ebd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.trace(A) # return sum along diagonals of the array"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0476b21b",
   "metadata": {},
   "source": [
    "* Solving Equations\n",
    "\n",
    "$$ Ax = b $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "70e98af2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  5,  6],\n",
       "       [ 1,  8,  9],\n",
       "       [ 1, -1,  6]])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "d9a76429",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.35555247],\n",
       "       [0.97543415],\n",
       "       [0.1037853 ]])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.random.random((3,1))\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "873e085f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.84224969],\n",
       "       [ 0.0419612 ],\n",
       "       [ 0.16466603]])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.solve(A, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17665aca",
   "metadata": {},
   "source": [
    "alternatively:\n",
    "\n",
    "$$ \\text{taking inverse A on both sides:} \\ A^{-1}Ax = A^{-1}b $$\n",
    "\n",
    "the matrix multiplied by its inverse equates to 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "7b356137",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.84224969],\n",
       "       [ 0.0419612 ],\n",
       "       [ 0.16466603]])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.matmul(np.linalg.inv(A), b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4d729e30",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}