3b.Algebra-Advanced.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Linear Algebra Advanced\n",
    "\n",
    "**Resources: [Linear algebra (scipy.linalg)](https://docs.scipy.org/doc/scipy/reference/linalg.html#module-scipy.linalg)**\n",
    "\n",
    "Note : ```scipy.linalg``` contains all the functions in ```numpy.linalg```. plus some other more advanced ones not contained in ```numpy.linalg```.\n",
    "\n",
    "Another advantage of using ```scipy.linalg``` over ```numpy.linalg``` is that it is always compiled with BLAS/LAPACK support, while for numpy this is optional. Therefore, the scipy version might be faster depending on how numpy was installed.\n",
    "\n",
    "Therefore, unless you don’t want to add scipy as a dependency to your numpy program, use ```scipy.linalg``` instead of ```numpy.linalg```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy.linalg as LA\n",
    "np.set_printoptions(precision=2, suppress=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrix Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.25, 1.04, 1.89],\n",
       "       [0.83, 2.6 , 2.25],\n",
       "       [0.38, 1.25, 2.99]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.random.rand(3,3)\n",
    "LA.expm(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-3.54, -0.17,  3.74],\n",
       "       [ 3.22, -0.52, -1.57],\n",
       "       [-1.09,  0.68,  0.55]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LA.logm(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.06,  0.22,  0.64],\n",
       "       [ 0.37,  0.42,  0.41],\n",
       "       [ 0.02,  0.32,  0.57]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LA.sinm(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Singular Value Decomposition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1. LU decomposition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2. Cholesky decomposition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3. QR decomposition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4. Schur decomposition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Special Matrices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Hilbert Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.  , 0.5 , 0.33, 0.25, 0.2 ],\n",
       "       [0.5 , 0.33, 0.25, 0.2 , 0.17],\n",
       "       [0.33, 0.25, 0.2 , 0.17, 0.14],\n",
       "       [0.25, 0.2 , 0.17, 0.14, 0.12],\n",
       "       [0.2 , 0.17, 0.14, 0.12, 0.11]])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from scipy.linalg import hilbert\n",
    "hilbert(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- DFT matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.  +0.j    1.  +0.j    1.  +0.j    1.  +0.j    1.  +0.j  ]\n",
      " [ 1.  +0.j    0.31-0.95j -0.81-0.59j -0.81+0.59j  0.31+0.95j]\n",
      " [ 1.  +0.j   -0.81-0.59j  0.31+0.95j  0.31-0.95j -0.81+0.59j]\n",
      " [ 1.  +0.j   -0.81+0.59j  0.31-0.95j  0.31+0.95j -0.81-0.59j]\n",
      " [ 1.  +0.j    0.31+0.95j -0.81+0.59j -0.81-0.59j  0.31-0.95j]]\n"
     ]
    }
   ],
   "source": [
    "from scipy.linalg import dft\n",
    "m = dft(5)\n",
    "print(m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Block Diagonal Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 0, 0, 0, 0],\n",
       "       [0, 1, 0, 0, 0, 0],\n",
       "       [0, 0, 3, 4, 5, 0],\n",
       "       [0, 0, 6, 7, 8, 0],\n",
       "       [0, 0, 0, 0, 0, 7]], dtype=int32)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from scipy.linalg import block_diag\n",
    "A = [[1, 0],\n",
    "     [0, 1]]\n",
    "B = [[3, 4, 5],\n",
    "     [6, 7, 8]]\n",
    "C = [[7]]\n",
    "\n",
    "block_diag(A, B, C)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 0, 0, 0, 0],\n",
       "       [0, 1, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0, 0],\n",
       "       [0, 0, 3, 4, 5, 0],\n",
       "       [0, 0, 6, 7, 8, 0],\n",
       "       [0, 0, 0, 0, 0, 7]], dtype=int32)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P = np.zeros((2, 0), dtype='int32')\n",
    "block_diag(A, P, B, C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0., 0., 0.],\n",
       "       [0., 2., 3., 0., 0.],\n",
       "       [0., 0., 0., 4., 5.],\n",
       "       [0., 0., 0., 6., 7.]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "block_diag(1.0, [2, 3], [[4, 5], [6, 7]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### References:\n",
    "1. [Scipy Tutorials](https://docs.scipy.org/doc/scipy/reference/tutorial/index.html)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}