1. NumPy Basics - Arrays and Vectorized operations.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy Basics\n",
    "\n",
    "### Why NumPy is so efficient\n",
    "#### 1. Internally stores data in contiguous block of memory, so easy to retrieve.\n",
    "#### Has alogrithm library written in C that can operate on this memory without any type-checking or overhead.\n",
    "#### NumPy arrays also use much less memory than other built-in Python sequences.\n",
    "#### 2. NumPy operations perform Complex Computations without need for Python loops."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "my_arr = np.arange(1000000) # NumPy array\n",
    "my_list = list(range(1000000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 21.9 ms\n"
     ]
    }
   ],
   "source": [
    "# Time for NumPy operation\n",
    "%time for _ in range(10): my_arr2 = my_arr * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 776 ms\n"
     ]
    }
   ],
   "source": [
    "# Time for List operation\n",
    "%time for _ in range(10): my_list2 = [x * 2 for x in my_list]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Huge difference in performance time between the 2 (10 to 100 times faster). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy ndarray\n",
    "#### Fast, flexible container for large datasets. Perform mathematical operations on blocks of data.\n",
    "#### It is a container for homogenous data, all its elements must be of same type.\n",
    "#### Every array has shape (tuple showing size of each dimension) and dtype (showing data type of the array)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.82998021,  0.89132479,  1.09535155],\n",
       "       [ 0.61204807, -0.64781786,  0.66609335]])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = np.random.randn(2,3)\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-8.29980207,  8.91324786, 10.95351546],\n",
       "       [ 6.12048066, -6.47817862,  6.66093346]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data * 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-1.65996041,  1.78264957,  2.19070309],\n",
       "       [ 1.22409613, -1.29563572,  1.33218669]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data + data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.ndim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Different ways to create ndarray\n",
    "#### 1. array - Will create an array out of a list. For list of lists, will create a higher-dimensional array.\n",
    "#### 2. empty - Creates array without initializing values. May return uninitialized garbage values.\n",
    "#### 3. zeros - Creates array initialized with zeroes.\n",
    "#### 4. arange - Create array initialized with range of values.\n",
    "#### For empty and zeros, pass the size of the array. For creating multi-dimensional arrays, use tuples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([6. , 4.5, 0. , 8. , 1. ])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data1 = [6, 4.5, 0, 8, 1]\n",
    "arr1 = np.array(data1)\n",
    "arr1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3, 4],\n",
       "       [5, 6, 7, 8]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data2 = [[1,2,3,4],[5,6,7,8]]\n",
    "arr2 = np.array(data2)\n",
    "arr2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.65996041, 1.78264957, 2.19070309],\n",
       "       [1.22409613, 1.29563572, 1.33218669]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.empty((2,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[1.65996041],\n",
       "        [1.78264957],\n",
       "        [2.19070309]],\n",
       "\n",
       "       [[1.22409613],\n",
       "        [1.29563572],\n",
       "        [1.33218669]]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.empty((2,3,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NumPy Data Types\n",
    "#### dtype is a special object, containing information (metadata) the ndarray needs to interpret a chunk of memory as a particular data type.\n",
    "#### It makes numpy flexible to interact with data from other systems. They provide mapping directly to underlying disk or memory representations.\n",
    "#### This makes it easy to read & write binary streams of data to disk & connect to low-level language code like C.\n",
    "#### NumPy tries to infer a good data type for any array that it creates.\n",
    "#### The naming convention is type of data followed by number of bits per element. eg: int23, float64, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 2., 3.])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr1 = np.array([1,2,3], dtype = np.float64)\n",
    "arr1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr2 = np.array([1,2,3], dtype = np.int32)\n",
    "arr2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr1.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int32')"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr2.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### We can convert or cast an array from 1 dtype to another with astype.\n",
    "#### We can also directly used dtype of another array.\n",
    "#### But there may be loss off data if we convert larger size dtype to smaller ones.\n",
    "#### Loos of data can also happen due to the nature of the data eg. string_ type\n",
    "#### If the casting may fail, then a ValueError will be raised."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int32')"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.array([1,2,3,4])\n",
    "arr.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 2., 3., 4.])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float_arr = arr.astype(np.float64)\n",
    "float_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 2., 3., 4.])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.astype(float_arr.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3, -1, -4,  0, 10])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.array([3.4, -1.4, -4.2, 0.4, 10.4])\n",
    "arr.astype(np.int32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.23, -9.6 , 43.  ])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "strings = np.array(['1.23','-9.6','43'], dtype=np.string_)\n",
    "\n",
    "strings.astype(float)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arithmetic with NumPy arrays\n",
    "#### Arrays help in expressing batch operations without writing 'for loops'.\n",
    "#### Arithemetic operations between equal sized arrays applies to element-wise operations.\n",
    "#### Scalar operations propogate the scalar argument to each element in the array.\n",
    "#### Comparisons between equal sized arrays yields boolean arrays.\n",
    "#### Operations between differently sized arrays is called broadcasting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 2., 3.],\n",
       "       [4., 5., 6.]])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.array([[1.,2.,3.],[4.,5.,6.]])\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  4.,  9.],\n",
       "       [16., 25., 36.]])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr * arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [0., 0., 0.]])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr - arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.        , 0.5       , 0.33333333],\n",
       "       [0.25      , 0.2       , 0.16666667]])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 / arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.        , 1.41421356, 1.73205081],\n",
       "       [2.        , 2.23606798, 2.44948974]])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr ** 0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.,  4.,  1.],\n",
       "       [ 7.,  2., 12.]])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr2 = np.array([[0., 4., 1.],[7., 2., 12.]])\n",
    "arr2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False,  True, False],\n",
       "       [ True, False,  True]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr2 > arr1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic indexing and slicing\n",
    "#### There are many ways to select a subset of data.\n",
    "#### 1d arrays are simple and work similarl to Python lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.arange(10)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 6, 7])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[5:8]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### You can assign a scalar value to a slice, then that value is broadcasted to entire selection.\n",
    "#### Difference between lists and ndarrays is that array slices are views to original arrays.\n",
    "#### Data is NOT copied and modifications to the view will affect original array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr[5:7] = 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4, 12, 12,  7,  8,  9])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### A \"bare\" slice [:] will assign to all values in an array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([64, 64, 64, 64, 64, 64, 64, 64, 64, 64])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[:] = 64\n",
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### NumPy has been designed this way to be able to work with very large arrays.\n",
    "#### If copy to array slices was allowed, then it would cause a lot of performance and memory problems.\n",
    "#### If you want to make a copy, you have to explicitly mention it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([64, 64, 64, 64, 64, 64, 64, 64, 64, 64])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr_copy = arr[5:8].copy()\n",
    "arr_copy[:] = 12\n",
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### For higher dimension arrays, elements at each index are arrays and not scalars.\n",
    "#### Individual elements can be accessed recursively or through a comma seperated list.\n",
    "#### Axis 0 is rows and axis 1 is columns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([7, 8, 9])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr2d  = np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
    "arr2d[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr2d[0][2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr2d[0,2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### If we omit lower indices, we will get all the values that are present in the higher index.\n",
    "#### We can assign both scalar and array value to higher dimensional array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr2d[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[42, 42, 42],\n",
       "       [ 4,  5,  6],\n",
       "       [ 7,  8,  9]])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr_copy = arr2d[0].copy()\n",
    "arr2d[0] = 42\n",
    "arr2d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [7, 8, 9]])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr2d[0]=arr_copy\n",
    "arr2d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexing with Slices\n",
    "#### ndarrays can be sliced in the same format as Python lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([64, 64, 64, 64, 64, 64, 64, 64, 64, 64])"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([64, 64, 64, 64, 64])"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[1:6]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Slicing higher dimensional arrays is a bit different.\n",
    "#### A slice selects elements from the axis 0 or rows.\n",
    "#### To select multiple axis elements, we need to pass multiple slices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [7, 8, 9]])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr2d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr2d[:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 3],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr2d[:2, 1:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Slicing will always get you array views of the higher arrays.\n",
    "#### By mixing the integer indexes and slices, you can get lower arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 5, 6])"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr2d[1,:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 6, 9])"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr2d[:3,2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Assigning single value to a slice changes all the elements in the slice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 0],\n",
       "       [4, 5, 0],\n",
       "       [7, 8, 9]])"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr2d[:2,2] = 0\n",
    "arr2d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boolean Indexing\n",
    "#### Comparisons with Numpy arrays are also vectorized. so they result in a Boolean array.\n",
    "#### This array can also be passed when indexing the array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True, False, False,  True, False, False, False])"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])\n",
    "names =='Bob'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Joe', 'Will', 'Will', 'Joe', 'Joe'], dtype='<U4')"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names[names != 'Bob']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.35020554,  1.28446121,  0.38349251,  1.72162633],\n",
       "       [-0.0872723 , -1.04907486,  1.99997014, -2.43749582],\n",
       "       [-0.86618079, -0.14741354, -0.3903738 , -1.59466569],\n",
       "       [-0.13697873, -0.92539916,  2.32080533,  0.52011416],\n",
       "       [-1.08186853,  1.06656039,  2.48892347, -0.04482491],\n",
       "       [-1.36610791,  1.58549315, -0.83335567, -1.04326065],\n",
       "       [-0.58640442,  0.16911337,  1.45909209, -0.43214679]])"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = np.random.randn(7,4)\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.35020554,  1.28446121,  0.38349251,  1.72162633],\n",
       "       [-0.13697873, -0.92539916,  2.32080533,  0.52011416]])"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[names=='Bob']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The boolean arrays must be of the same length as the array they are indexing.\n",
    "#### The boolean selection will not fail if the boolean array is not of correct length. So you should be careful when using this feature.\n",
    "#### You can mix boolean arrays with slices or integers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.38349251, 1.72162633],\n",
       "       [2.32080533, 0.52011416]])"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[names == 'Bob', 2:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.72162633, 0.52011416])"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[names == 'Bob', 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### To select outside a condition use the != operator or simply negate the condition using ~.\n",
    "#### The ~ operator can be usefule when you want to negate an already existing general condition.\n",
    "#### You can combine multiple conditions with arithematic operators & and |. Normal Python versions 'and' and 'or' do not work here.\n",
    "#### Boolean indexing always creates a copy of the data, even if it is unchanged."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False,  True,  True, False,  True,  True,  True])"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names != 'Bob'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.0872723 , -1.04907486,  1.99997014, -2.43749582],\n",
       "       [-0.86618079, -0.14741354, -0.3903738 , -1.59466569],\n",
       "       [-1.08186853,  1.06656039,  2.48892347, -0.04482491],\n",
       "       [-1.36610791,  1.58549315, -0.83335567, -1.04326065],\n",
       "       [-0.58640442,  0.16911337,  1.45909209, -0.43214679]])"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[~(names == 'Bob')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.0872723 , -1.04907486,  1.99997014, -2.43749582],\n",
       "       [-0.86618079, -0.14741354, -0.3903738 , -1.59466569],\n",
       "       [-1.08186853,  1.06656039,  2.48892347, -0.04482491],\n",
       "       [-1.36610791,  1.58549315, -0.83335567, -1.04326065],\n",
       "       [-0.58640442,  0.16911337,  1.45909209, -0.43214679]])"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cond = names == 'Bob'\n",
    "data[~cond]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True, False,  True,  True,  True, False, False])"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mask = (names == 'Bob') | (names == 'Will')\n",
    "mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.35020554,  1.28446121,  0.38349251,  1.72162633],\n",
       "       [-0.86618079, -0.14741354, -0.3903738 , -1.59466569],\n",
       "       [-0.13697873, -0.92539916,  2.32080533,  0.52011416],\n",
       "       [-1.08186853,  1.06656039,  2.48892347, -0.04482491]])"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[mask]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Boolean indexing is simple because it works in a common-sense way.\n",
    "#### Setting whole rows and columns using one-dimensional boolean array is also easy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.35020554, 1.28446121, 0.38349251, 1.72162633],\n",
       "       [0.        , 0.        , 1.99997014, 0.        ],\n",
       "       [0.        , 0.        , 0.        , 0.        ],\n",
       "       [0.        , 0.        , 2.32080533, 0.52011416],\n",
       "       [0.        , 1.06656039, 2.48892347, 0.        ],\n",
       "       [0.        , 1.58549315, 0.        , 0.        ],\n",
       "       [0.        , 0.16911337, 1.45909209, 0.        ]])"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[data < 0] = 0\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[7.        , 7.        , 7.        , 7.        ],\n",
       "       [0.        , 0.        , 1.99997014, 0.        ],\n",
       "       [7.        , 7.        , 7.        , 7.        ],\n",
       "       [7.        , 7.        , 7.        , 7.        ],\n",
       "       [7.        , 7.        , 7.        , 7.        ],\n",
       "       [0.        , 1.58549315, 0.        , 0.        ],\n",
       "       [0.        , 0.16911337, 1.45909209, 0.        ]])"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[names != 'Joe'] = 7\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fancy Indexing\n",
    "#### It is a term to describe indexing using integer arrays.\n",
    "#### We can use it to select subset of rows in particular order.\n",
    "#### Negative indices select rows from the end."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [2., 2., 2., 2.],\n",
       "       [3., 3., 3., 3.],\n",
       "       [4., 4., 4., 4.],\n",
       "       [5., 5., 5., 5.],\n",
       "       [6., 6., 6., 6.],\n",
       "       [7., 7., 7., 7.]])"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.empty((8,4))\n",
    "\n",
    "for i in range(8):\n",
    "    arr[i] = i\n",
    "    \n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4., 4., 4., 4.],\n",
       "       [3., 3., 3., 3.],\n",
       "       [0., 0., 0., 0.],\n",
       "       [2., 2., 2., 2.]])"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[[4,3,0,2]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5., 5., 5., 5.],\n",
       "       [3., 3., 3., 3.],\n",
       "       [1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[[-3,-5,-7]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Passing mutiple index arrays selects 1d array with each element belonging to a tuple of respective indices.\n",
    "#### Eg: [[1,5,7,2],[0,3,1,2]] will get elements (1,0), (5,3), (7,1), (2,2)\n",
    "#### Multiple indices always give a 1d array as a result.\n",
    "#### To get a rectangular subset, we need to use the indices as subset.\n",
    "#### Fancy Indexing always results in copy of data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11],\n",
       "       [12, 13, 14, 15],\n",
       "       [16, 17, 18, 19],\n",
       "       [20, 21, 22, 23],\n",
       "       [24, 25, 26, 27],\n",
       "       [28, 29, 30, 31]])"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.arange(32).reshape((8,4))\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 4, 23, 29, 10])"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[[1,5,7,2],[0,3,1,2]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 4,  7,  5,  6],\n",
       "       [20, 23, 21, 22],\n",
       "       [28, 31, 29, 30],\n",
       "       [ 8, 11,  9, 10]])"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[[1,5,7,2]][:,[0,3,1,2]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Transposing and Swapping Axes\n",
    "#### Transposing - Special form of reshaping. ndarrays have 'transpose' method and special 'T' attribute.\n",
    "#### 'T' is a special case of swapping axes. Numpy also has 'swapaxes' method, which takes a pair of axis numbers and switches indicated axes to rearrange the data.\n",
    "#### For getting dot products we can use the np.dot function.\n",
    "#### For higher arrays, transpose will accept a tuple of axis numbers to permute the axes.\n",
    "#### All the methods return a view and do not make a copy of the array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4],\n",
       "       [ 5,  6,  7,  8,  9],\n",
       "       [10, 11, 12, 13, 14]])"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.arange(15).reshape((3,5))\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  5, 10],\n",
       "       [ 1,  6, 11],\n",
       "       [ 2,  7, 12],\n",
       "       [ 3,  8, 13],\n",
       "       [ 4,  9, 14]])"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[125, 140, 155, 170, 185],\n",
       "       [140, 158, 176, 194, 212],\n",
       "       [155, 176, 197, 218, 239],\n",
       "       [170, 194, 218, 242, 266],\n",
       "       [185, 212, 239, 266, 293]])"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(arr.T, arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1,  2,  3],\n",
       "        [ 4,  5,  6,  7]],\n",
       "\n",
       "       [[ 8,  9, 10, 11],\n",
       "        [12, 13, 14, 15]]])"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.arange(16).reshape((2,2,4))\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1,  2,  3],\n",
       "        [ 8,  9, 10, 11]],\n",
       "\n",
       "       [[ 4,  5,  6,  7],\n",
       "        [12, 13, 14, 15]]])"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.transpose((1,0,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  4],\n",
       "        [ 1,  5],\n",
       "        [ 2,  6],\n",
       "        [ 3,  7]],\n",
       "\n",
       "       [[ 8, 12],\n",
       "        [ 9, 13],\n",
       "        [10, 14],\n",
       "        [11, 15]]])"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.swapaxes(1,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Universal Functions\n",
    "#### Also called ufunc, is a function that performs element-wise operations on data in ndarrays.\n",
    "#### Can be thought as fast vectorized wrappers for simple functions.\n",
    "#### Unary ufuncs accept 1 array as input. Binary ufuncs take 2 arrays and return single array as result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.arange(10)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 1.        , 1.41421356, 1.73205081, 2.        ,\n",
       "       2.23606798, 2.44948974, 2.64575131, 2.82842712, 3.        ])"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sqrt(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.00000000e+00, 2.71828183e+00, 7.38905610e+00, 2.00855369e+01,\n",
       "       5.45981500e+01, 1.48413159e+02, 4.03428793e+02, 1.09663316e+03,\n",
       "       2.98095799e+03, 8.10308393e+03])"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.exp(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.random.randn(8)\n",
    "y = np.random.randn(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.44340366, -0.5063125 ,  2.93378063, -1.06516609, -0.08656581,\n",
       "       -0.79077555,  1.57882021, -0.5497823 ])"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.08570186,  1.69505143, -0.01471107, -0.29070661,  1.23498209,\n",
       "       -0.51118413,  0.58261211, -0.48581904])"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.08570186,  1.69505143,  2.93378063, -0.29070661,  1.23498209,\n",
       "       -0.51118413,  1.57882021, -0.48581904])"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.maximum(x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Some ufuncs can return multiple arrays. 'modf' is one example. It is the Numpy version of Python's divmod.\n",
    "#### It return fractional and integral parts of a floating point array.\n",
    "#### Ufuncs have optional 'out' argument. It allows them to operate in-place on arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [],
   "source": [
    "remainder, whole_part = np.modf(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "remainder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "whole_part"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Array-Oriented Programming with Arrays\n",
    "#### We can use Numpy to express data processing tasks as concise array expressions and avoid writing loops.\n",
    "#### Vectorization is the practice of replacing explicit loops with array expressions.\n",
    "#### Vectorized array operation will often be 1 or 2 (or more) orders of magnitude faster than Python counterparts."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example\n",
    "#### Evaluate function sqrt(x^2 + y^2) across regular grid of values.\n",
    "#### Will use enp.meshgrid to take 2 1-D arrays and produce 2 2-D matrices corresponding to all pairs of (x,y) in the 2 arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [],
   "source": [
    "points = np.arange(-5, 5, 0.01)\n",
    "xs, ys = np.meshgrid(points, points)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-5.  , -5.  , -5.  , ..., -5.  , -5.  , -5.  ],\n",
       "       [-4.99, -4.99, -4.99, ..., -4.99, -4.99, -4.99],\n",
       "       [-4.98, -4.98, -4.98, ..., -4.98, -4.98, -4.98],\n",
       "       ...,\n",
       "       [ 4.97,  4.97,  4.97, ...,  4.97,  4.97,  4.97],\n",
       "       [ 4.98,  4.98,  4.98, ...,  4.98,  4.98,  4.98],\n",
       "       [ 4.99,  4.99,  4.99, ...,  4.99,  4.99,  4.99]])"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ys"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Now we will use the 2 arrays and use them in the expression.\n",
    "#### We will use matplotlib to create visualisations of this 2-D array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[7.07106781, 7.06400028, 7.05693985, ..., 7.04988652, 7.05693985,\n",
       "        7.06400028],\n",
       "       [7.06400028, 7.05692568, 7.04985815, ..., 7.04279774, 7.04985815,\n",
       "        7.05692568],\n",
       "       [7.05693985, 7.04985815, 7.04278354, ..., 7.03571603, 7.04278354,\n",
       "        7.04985815],\n",
       "       ...,\n",
       "       [7.04988652, 7.04279774, 7.03571603, ..., 7.0286414 , 7.03571603,\n",
       "        7.04279774],\n",
       "       [7.05693985, 7.04985815, 7.04278354, ..., 7.03571603, 7.04278354,\n",
       "        7.04985815],\n",
       "       [7.06400028, 7.05692568, 7.04985815, ..., 7.04279774, 7.04985815,\n",
       "        7.05692568]])"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = np.sqrt(xs ** 2 + ys ** 2)\n",
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.colorbar.Colorbar at 0x2acd373c358>"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "plt.title(\"Image plot of $\\sqrt{x^2 + y^2}$ for a grid of values\")\n",
    "plt.imshow(z, cmap=plt.cm.gray);plt.colorbar()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Expressing Conditional Logic as Array Operations\n",
    "#### 'numpy.where' is vectorized version of ternary expression \"x if condition else y\".\n",
    "#### Example of 3 arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [],
   "source": [
    "xarr = np.array([1.1, 1.2, 1.3, 1.4, 1.5])\n",
    "yarr = np.array([2.1, 2.2, 2.3, 2.4, 2.5])\n",
    "cond = np.array([True, False, True, True, False])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### We want to take a value from arr or yarr based on the value in cond array.\n",
    "#### Let's check a Python List comprehension first. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.1, 2.2, 1.3, 1.4, 2.5]"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = [(x if c else y)\n",
    "         for x, y, c in zip(xarr, yarr, cond)]\n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### There are multiple problems with this-\n",
    "#### 1. It will not work for very large arrays as all work is being done in interpreted Python Code.\n",
    "#### 2. It will not work with Multidimensional arrays.\n",
    "#### With np.where, this can be done very concisely."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.1, 2.2, 1.3, 1.4, 2.5])"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = np.where(cond, xarr, yarr)\n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Second and Third arguments do not need to be arrays, they can be scalars as well.\n",
    "#### Typical use is to produce new values based on another array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.74122273,  0.39644299,  1.6108874 ,  1.2736541 ],\n",
       "       [-0.10609104,  0.0264075 ,  1.09139844,  0.11420908],\n",
       "       [-0.01466236,  1.23467661,  0.48692592, -0.32665657],\n",
       "       [ 1.20244839, -0.10119162, -0.96773116,  1.36798344]])"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.random.randn(4,4)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False,  True,  True,  True],\n",
       "       [False,  True,  True,  True],\n",
       "       [False,  True,  True, False],\n",
       "       [ True, False, False,  True]])"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr > 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-2,  2,  2,  2],\n",
       "       [-2,  2,  2,  2],\n",
       "       [-2,  2,  2, -2],\n",
       "       [ 2, -2, -2,  2]])"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.where(arr > 0, 2, -2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.74122273,  2.        ,  2.        ,  2.        ],\n",
       "       [-0.10609104,  2.        ,  2.        ,  2.        ],\n",
       "       [-0.01466236,  2.        ,  2.        , -0.32665657],\n",
       "       [ 2.        , -0.10119162, -0.96773116,  2.        ]])"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.where(arr > 0, 2, arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mathematical and Statistical methods\n",
    "#### There are methods in the array class that compute statistics about an entire array or about data along an axis.\n",
    "#### You can use aggregations (reductions) either by calling array instance method or top-level NumPy function.\n",
    "#### Eg - sum, mean, std, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.30764102, -1.39433028,  1.00435018,  0.97198033],\n",
       "       [-0.03751212,  0.38774409, -0.1722679 , -0.89256393],\n",
       "       [ 0.50650635, -2.27633506,  0.27969409,  0.98077098],\n",
       "       [ 0.78731009, -1.53407943,  1.00515138,  1.99405271],\n",
       "       [ 1.5973272 , -1.35787503, -0.28259648,  0.21150822]])"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.random.randn(5,4)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.07355971785207557"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.07355971785207557"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.4711943570415114"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Aggregation functions take an optional 'axis' argument that computes statistics over a given axis.\n",
    "#### Axis 1 means Columns and Axis 0 means Rows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.0685898 , -0.17864996, -0.12734091,  0.56310869,  0.04209097])"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.mean(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.5091981 , -1.23497514,  0.36686626,  0.65314966])"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.mean(axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Some methods do not aggregateand instead produce array of intermediate results. eg - cumsum, cumprod.\n",
    "#### In multi-dimensional arrays, these same functions return an array of same size.\n",
    "#### But they output has partial aggregates computed along the indicated axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  3,  6, 51, 57, 64], dtype=int32)"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.array([0,1,2,3,45,6,7])\n",
    "arr.cumsum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [3, 4, 5],\n",
       "       [6, 7, 8]])"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.array([[0,1,2], [3,4,5], [6,7,8]])\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2],\n",
       "       [ 3,  5,  7],\n",
       "       [ 9, 12, 15]], dtype=int32)"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.cumsum(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  3],\n",
       "       [ 3,  7, 12],\n",
       "       [ 6, 13, 21]], dtype=int32)"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.cumsum(axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Methods for Boolean arrays\n",
    "#### Sum can often be used to count True values in a Boolean array.\n",
    "#### The method 'any' checks if 1 or more values in an array is True.\n",
    "#### The method 'all' checks if every value is True.\n",
    "#### This works with non-Boolean arrays, where non-zero elements evaluate to True."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sorting\n",
    "#### Just like Python's list, ndarrays can also be sorted in-place with sort.\n",
    "#### For multi-dimensional arrays, we can sort sections along a dimension by passing axis number.\n",
    "#### np.sort returns a copy of the array instead of sorting in-place.\n",
    "#### A quick way of getting quantiles is to sort array and select value at a particular rank."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.35479202, -0.39810226,  1.31494373, -0.84614833,  1.33831323,\n",
       "       -3.31635844])"
      ]
     },
     "execution_count": 183,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.random.randn(6)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-3.31635844, -0.84614833, -0.39810226,  0.35479202,  1.31494373,\n",
       "        1.33831323])"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.sort()\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.81870756, -0.06119759, -0.88887598],\n",
       "       [ 2.11856786, -0.93286628, -0.16550543],\n",
       "       [-0.28535572, -1.39268555, -0.62279873],\n",
       "       [ 0.45246504,  0.4505424 , -0.08760122],\n",
       "       [ 1.23284699, -0.50998863, -0.58692972]])"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.random.randn(5,3)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.88887598, -0.06119759,  0.81870756],\n",
       "       [-0.93286628, -0.16550543,  2.11856786],\n",
       "       [-1.39268555, -0.62279873, -0.28535572],\n",
       "       [-0.08760122,  0.4505424 ,  0.45246504],\n",
       "       [-0.58692972, -0.50998863,  1.23284699]])"
      ]
     },
     "execution_count": 186,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.sort(1)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.6244249894535554"
      ]
     },
     "execution_count": 187,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "large_arr = np.random.randn(1000)\n",
    "large_arr.sort()\n",
    "large_arr[int(0.05 * len(large_arr))] # 5% quantile"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Unique and Other Set logic\n",
    "#### NumPy has some basic set operations of 1-D arrays.\n",
    "#### np.unique returns sorted unique values in an array.\n",
    "#### np.in1d checks presence of values of one array in another."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Bob', 'Joe', 'Will'], dtype='<U4')"
      ]
     },
     "execution_count": 189,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])\n",
    "np.unique(names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4])"
      ]
     },
     "execution_count": 190,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ints = np.array([3, 3, 3, 2, 2, 1, 1, 4, 4])\n",
    "np.unique(ints)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True, False, False,  True,  True, False,  True])"
      ]
     },
     "execution_count": 191,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "values = np.array([6,0,0,2,3,5,6])\n",
    "np.in1d(values, [2,3,6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## File Input and Output with Arrays\n",
    "#### NumPy can save and load data to and from disk, in text or binary format.\n",
    "#### Since most people will use pandas for text or tabular loading, we will use NumPy only in binary format.\n",
    "#### np.save and np.load will save and load arrays to/from disks.\n",
    "#### Arrays are by default saved in uncompressed raw binary format with extension '.npy'.\n",
    "#### If file path does not have .npy extension, it will be appended.\n",
    "#### array on disk can be loaded with np.load."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.arange(10)\n",
    "np.save('some_array', arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 195,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.load('some_array.npy')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### To save multiple arrays in uncompressed archive, you can use np.savez. File extension is '.npz'.\n",
    "#### Pass the arrays as arguments with label to the savez command.\n",
    "#### When loading, NumPy will load the arrays in a dictionary like object, with the labels as keys and arrays as values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savez('array_archive.npz', a=arr, b=arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 199,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arch = np.load('array_archive.npz')\n",
    "arch['b']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### If your data compresses well, use the np.savez_compressed command instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savez_compressed('arrays_compressed.npz', a=arr, b=arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Linear Algebra\n",
    "#### Using a * between two 2-D arrays leads to element-wise multiplication instead of dot product.\n",
    "#### Hence, NumPy ha sthe function 'dot' for matrix multiplication. x.dot(y) is equivalent to np.dot(x,y).\n",
    "#### Matrix product between 2-D and 1-D array of right size results in a 1-D array.\n",
    "#### The '@' symbol (>=Python 3.5) also works as infix operator for matrix multiplication. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 28.,  64.],\n",
       "       [ 67., 181.]])"
      ]
     },
     "execution_count": 203,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([[1.,2.,3.], [4.,5.,6.]])\n",
    "y = np.array([[6.,23.], [-1,7],[8,9]])\n",
    "x.dot(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 28.,  64.],\n",
       "       [ 67., 181.]])"
      ]
     },
     "execution_count": 204,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 6., 15.])"
      ]
     },
     "execution_count": 205,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(x, np.ones(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 6., 15.])"
      ]
     },
     "execution_count": 206,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x @ np.ones(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The module numpy.linalg has the set of functions for matrix decomposition and other functions.\n",
    "#### They are implemented under the hood via same industry-standard libraries used in other languages like R and MATLAB. Eg - BLAS, LAPACK or Intel MKL."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  63.48383781,  197.70058242,  225.18410798, -217.41299738,\n",
       "         -18.17182633],\n",
       "       [ 197.70058242,  620.24850578,  706.787963  , -682.0388079 ,\n",
       "         -59.41053306],\n",
       "       [ 225.18410798,  706.787963  ,  805.92877339, -777.36399507,\n",
       "         -68.48949687],\n",
       "       [-217.41299738, -682.0388079 , -777.36399507,  750.3109925 ,\n",
       "          65.61718389],\n",
       "       [ -18.17182633,  -59.41053306,  -68.48949687,   65.61718389,\n",
       "           8.19630524]])"
      ]
     },
     "execution_count": 210,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from numpy.linalg import inv, qr\n",
    "\n",
    "X = np.random.randn(5,5)\n",
    "mat = X.T.dot(X)\n",
    "inv(mat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.00000000e+00, -1.24409169e-13, -5.22827009e-14,\n",
       "         1.94528504e-13,  2.02595760e-14],\n",
       "       [ 2.47562781e-14,  1.00000000e+00,  9.97216869e-13,\n",
       "         1.55154405e-13, -1.08043005e-13],\n",
       "       [-1.07704916e-13,  2.79919051e-13,  1.00000000e+00,\n",
       "        -2.43980638e-13, -2.63509765e-14],\n",
       "       [-3.42261134e-14, -7.32183316e-13, -2.00967590e-13,\n",
       "         1.00000000e+00, -2.01342852e-14],\n",
       "       [ 1.94325023e-14,  4.00824169e-13, -1.83679520e-13,\n",
       "        -3.22534080e-13,  1.00000000e+00]])"
      ]
     },
     "execution_count": 211,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat.dot(inv(mat))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {},
   "outputs": [],
   "source": [
    "q, r = qr(mat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-8.7615498 , -7.89337087,  6.42644051, -3.51420162,  5.23909184],\n",
       "       [ 0.        , -6.88642471,  3.1472705 , -3.11353882,  1.3043392 ],\n",
       "       [ 0.        ,  0.        , -3.29444835, -3.35408006, -0.68754574],\n",
       "       [ 0.        ,  0.        ,  0.        , -0.03302758,  0.37691397],\n",
       "       [ 0.        ,  0.        ,  0.        ,  0.        ,  0.00879652]])"
      ]
     },
     "execution_count": 213,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pseudorandom Number Generation\n",
    "#### The module numpy.random provides functions for efficiently generating arrays of random values from many kinds of Probablity distributions.\n",
    "#### Python's inbuilt random module only samples one value at a time. But NumPy is well over an order of magnitude faster for generating very large samples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.21656203,  1.20280149, -0.30236083,  0.43056127],\n",
       "       [ 1.28695137,  1.77457505,  2.72086458, -0.57325422],\n",
       "       [ 0.24416883,  0.1130036 , -0.91843298, -0.64987006],\n",
       "       [ 1.69575643, -1.17482421, -0.01820951, -0.45221461]])"
      ]
     },
     "execution_count": 215,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "samples = np.random.normal(size=(4,4))\n",
    "samples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "677 ms ± 4.91 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "from random import normalvariate\n",
    "\n",
    "N = 1000000\n",
    "\n",
    "%timeit samples = [normalvariate(0,1) for _ in range(N)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "29.1 ms ± 344 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit np.random.normal(size=N)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The numbers generated are called 'pseudorandom numbers' because they are generated by an algorithm with deterministic behaviour based on the 'seed' of the random number generator.\n",
    "#### The data generation by default uses a global random seed. To avoid it, use numpy.random.Randomstate to get isolated generators."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.47143516, -1.19097569,  1.43270697, -0.3126519 , -0.72058873,\n",
       "        0.88716294,  0.85958841, -0.6365235 ,  0.01569637, -2.24268495])"
      ]
     },
     "execution_count": 220,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rng = np.random.RandomState(1234)\n",
    "rng.randn(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}