numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A hands-on tutorial on NumPy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 1: Let's add a few numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creating an array/list in vanilla Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_list = list(range(5000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num_list[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### C like indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "len_list = len(num_list)\n",
    "sum_list = 0\n",
    "for i in range(len_list):\n",
    "    sum_list+= num_list[i]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Let's make it a function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def c_like_sum(l):\n",
    "    len_list = len(num_list)\n",
    "    sum_list = 0\n",
    "    for i in range(len_list):\n",
    "        sum_list+= num_list[i]\n",
    "    return sum_list\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "376 µs ± 22.6 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
     ]
    }
   ],
   "source": [
    "c_like = %timeit c_like_sum(num_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "c_like"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Pythonic iteration to find sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def python_like_sum(l):\n",
    "    sum_list = 0\n",
    "    for x in l:\n",
    "        sum_list+= x\n",
    "    return sum_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "207 µs ± 10.8 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit python_like_sum(num_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Well, just use `sum`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "38.8 µs ± 1.94 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit sum(num_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = np.array(num_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What does a numpy array look like?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([   0,    1,    2, ..., 4997, 4998, 4999])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.74 µs ± 30.4 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit np.sum(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Some attributes of numpy arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5000"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5000,)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5000"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([   0,    1,    2, ..., 4997, 4998, 4999])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([   0,    1,    2, ..., 4997, 4998, 4999], dtype=int32)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_32 = np.array(num_list, dtype='int32')\n",
    "y_32"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([   0,    1,    2, ..., 4997, 4998, 4999], dtype=int32)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_32_as_type = y.astype('int32')\n",
    "y_32_as_type"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparing two numpy arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Plain check for equals?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True,  True,  True, ...,  True,  True,  True])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_32_as_type == y_32"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This tells us if all the values in the arrays are the same. But, we need a single answer!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, ..., 1, 1, 1])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(y_32_as_type == y_32).astype('int')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum((y_32_as_type == y_32).astype('int'))==y_32.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### use in-built checker!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array_equal(y_32, y_32_as_type)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Find sum of first `n` numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "55"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = 10\n",
    "y.cumsum()[n]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What does `cumsum` do?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 3, 7])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([0, 1, 2, 4]).cumsum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 1: Find n! using numpy in a single line of code\n",
    "\n",
    "#### Hint: Similar to `cumsum`, there is a `cumprod` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([      1,       2,       6,      24,     120,     720,    5040,\n",
       "         40320,  362880, 3628800])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y[1:].cumprod()[:n]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2: Given the starting number, the ratio and the length of a sequence, use cumprod to generate a Geometric Progression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([   3,    6,   12,   24,   48,   96,  192,  384,  768, 1536])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 3\n",
    "r = 2\n",
    "np.array([a]+[r]*(n-1)).cumprod()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialisation "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
       "       1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
       "       1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
       "       1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
       "       1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
       "       1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones(100).dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 3: Initialise an array of ones of length 100 with int16 datatype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones(100, dtype='int')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Initialising multi dimensional arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1.],\n",
       "       [1., 1.],\n",
       "       [1., 1.],\n",
       "       [1., 1.],\n",
       "       [1., 1.]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multi_dim_ones = np.ones((5,2))\n",
    "multi_dim_ones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Let us re-run some of the previous attributes for a numpy array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, 2)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multi_dim_ones.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multi_dim_ones.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Initialising empty array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.00000000e+000, 0.00000000e+000],\n",
       "       [0.00000000e+000, 0.00000000e+000],\n",
       "       [0.00000000e+000, 0.00000000e+000],\n",
       "       [0.00000000e+000, 0.00000000e+000],\n",
       "       [0.00000000e+000, 3.73610348e-061],\n",
       "       [1.28822975e-231, 1.28822975e-231],\n",
       "       [4.94065646e-323, 0.00000000e+000],\n",
       "       [0.00000000e+000, 0.00000000e+000],\n",
       "       [0.00000000e+000, 0.00000000e+000],\n",
       "       [0.00000000e+000, 0.00000000e+000]])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.empty((10, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But, this is not empty! What is empty and why is it different from `np.zero`?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the documentation\n",
    "\n",
    "    \n",
    " >Array of uninitialized (arbitrary) data of the given shape, dtype, and\n",
    "    order.  Object arrays will be initialized to None."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Let's compare the relative speed of initialisation!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "281 µs ± 3.37 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit np.zeros((1000, 1000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.79 µs ± 269 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit np.empty((1000, 1000))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Initialising `np.empty` is way quicker! This is due to the fact that we do not have to set the values to be zeros!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Initialising using `ones_like`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, ..., 1, 1, 1])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones_like((y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### Initialising using evenly spaced numbers over a range"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(0, 10, 11, dtype=int)\n",
    "# start, stop, number of elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Initialising similar to `range` for Python lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(0, 11, 1, dtype=int)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 4: Using both linspace and arange, create a numpy array of all numbers till 30 divisble by 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3,  6,  9, 12, 15, 18, 21, 24, 27, 30])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(3, 30, (30//3), dtype=int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3,  6,  9, 12, 15, 18, 21, 24, 27, 30])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(3, 33, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reshaping!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 3],\n",
       "       [4, 5]])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[1, 3], [4, 5]])\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2)"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1],\n",
       "       [3],\n",
       "       [4],\n",
       "       [5]])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.reshape(4, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 5: Using reshape, generate the array \n",
    "      [[1],\n",
    "       [4],\n",
    "       [3],\n",
    "       [5]]\n",
    "    \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1],\n",
       "       [4],\n",
       "       [3],\n",
       "       [5]])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.reshape(4, 1, order='F')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1],\n",
       "       [4],\n",
       "       [3],\n",
       "       [5]])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.T.reshape(4, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 6: Write five numbers in each row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  1,   2,   3,   4,   5],\n",
       "       [  6,   7,   8,   9,  10],\n",
       "       [ 11,  12,  13,  14,  15],\n",
       "       [ 16,  17,  18,  19,  20],\n",
       "       [ 21,  22,  23,  24,  25],\n",
       "       [ 26,  27,  28,  29,  30],\n",
       "       [ 31,  32,  33,  34,  35],\n",
       "       [ 36,  37,  38,  39,  40],\n",
       "       [ 41,  42,  43,  44,  45],\n",
       "       [ 46,  47,  48,  49,  50],\n",
       "       [ 51,  52,  53,  54,  55],\n",
       "       [ 56,  57,  58,  59,  60],\n",
       "       [ 61,  62,  63,  64,  65],\n",
       "       [ 66,  67,  68,  69,  70],\n",
       "       [ 71,  72,  73,  74,  75],\n",
       "       [ 76,  77,  78,  79,  80],\n",
       "       [ 81,  82,  83,  84,  85],\n",
       "       [ 86,  87,  88,  89,  90],\n",
       "       [ 91,  92,  93,  94,  95],\n",
       "       [ 96,  97,  98,  99, 100]])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(1, 100, 100, dtype=int).reshape(20, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Without using the `20` in the reshape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  1,   2,   3,   4,   5],\n",
       "       [  6,   7,   8,   9,  10],\n",
       "       [ 11,  12,  13,  14,  15],\n",
       "       [ 16,  17,  18,  19,  20],\n",
       "       [ 21,  22,  23,  24,  25],\n",
       "       [ 26,  27,  28,  29,  30],\n",
       "       [ 31,  32,  33,  34,  35],\n",
       "       [ 36,  37,  38,  39,  40],\n",
       "       [ 41,  42,  43,  44,  45],\n",
       "       [ 46,  47,  48,  49,  50],\n",
       "       [ 51,  52,  53,  54,  55],\n",
       "       [ 56,  57,  58,  59,  60],\n",
       "       [ 61,  62,  63,  64,  65],\n",
       "       [ 66,  67,  68,  69,  70],\n",
       "       [ 71,  72,  73,  74,  75],\n",
       "       [ 76,  77,  78,  79,  80],\n",
       "       [ 81,  82,  83,  84,  85],\n",
       "       [ 86,  87,  88,  89,  90],\n",
       "       [ 91,  92,  93,  94,  95],\n",
       "       [ 96,  97,  98,  99, 100]])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(1, 100, 100, dtype=int).reshape(-1, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reshape the array to 5, 4, 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[  1,   2,   3,   4,   5],\n",
       "        [  6,   7,   8,   9,  10],\n",
       "        [ 11,  12,  13,  14,  15],\n",
       "        [ 16,  17,  18,  19,  20]],\n",
       "\n",
       "       [[ 21,  22,  23,  24,  25],\n",
       "        [ 26,  27,  28,  29,  30],\n",
       "        [ 31,  32,  33,  34,  35],\n",
       "        [ 36,  37,  38,  39,  40]],\n",
       "\n",
       "       [[ 41,  42,  43,  44,  45],\n",
       "        [ 46,  47,  48,  49,  50],\n",
       "        [ 51,  52,  53,  54,  55],\n",
       "        [ 56,  57,  58,  59,  60]],\n",
       "\n",
       "       [[ 61,  62,  63,  64,  65],\n",
       "        [ 66,  67,  68,  69,  70],\n",
       "        [ 71,  72,  73,  74,  75],\n",
       "        [ 76,  77,  78,  79,  80]],\n",
       "\n",
       "       [[ 81,  82,  83,  84,  85],\n",
       "        [ 86,  87,  88,  89,  90],\n",
       "        [ 91,  92,  93,  94,  95],\n",
       "        [ 96,  97,  98,  99, 100]]])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(1, 100, 100, dtype=int).reshape(5,4,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arithmetic operations\n",
    "\n",
    "### Adding two vectors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "y1 = y.copy()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([   0,    1,    2, ..., 4997, 4998, 4999])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([   0,    2,    4, ..., 9994, 9996, 9998])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y1+y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y1.shape==y.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "ones_a = np.ones((2,2))\n",
    "ones_b = np.ones((2,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2., 2.],\n",
       "       [2., 2.]])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ones_a+ones_b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2., 2.],\n",
       "       [2., 2.]])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.add(ones_a, ones_b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 8: Find the additive inverse of an array \n",
    "\n",
    ">x + add_inv(x) = O"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "def additive_inverse(x):\n",
    "    zeroes = np.zeros_like(x)\n",
    "    return zeroes - x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-1., -1., -1.],\n",
       "       [-1., -1., -1.],\n",
       "       [-1., -1., -1.]])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "additive_inverse((np.ones((3, 3))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Elementwise mutiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "a1 = np.array([[3, 4], [5, 1]])\n",
    "a2 = np.array(([4, 3], [5, 7]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5,1,'A1')"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAAEICAYAAAD8yyfzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAEBBJREFUeJzt3XuQZGV5x/Hv0zPAIguIcgmCuiRGZaEiFCCxVLJcUtkAtV6iUZCAFnGqUmKhYESiRQJ/JCARlEJjpgAxaLhEMSKIQikrEbktFwm4EEAQlttyWa7iKrtP/phOMhlnunvYnvcc3v1+qk5Vd58z73mGGn771NvvOScyE0lSGZ2mC5Ck9YmhK0kFGbqSVJChK0kFGbqSVJChK0kFGbqSVJChqzkXEUsjYlVEbDTps70j4oqIeCoi7m2wPKkoQ1dzKiIWAG8HElgyaddzwFnAX5evSmqOoau5dihwDXA2cNj/fJiZ12XmOcDPG6pLasRo0wWoeocCpwDXAtdExDaZ+UjDNUmNsdPVnImItwGvBS7IzBuAu4GDm61Kapahq7l0GHBZZj7Wff+vTJpikNZHTi9oTkTExsCfAyMR8XD3442Al0fEmzLzp81VJzXHTldz5Z3AGmAhsEt32xH4D+DQiOhExDxgAyAiYl5EbNhYtVIhdrqaK4cBX8nM+yZ/GBGnA6cBlwKXT9r1PPAjYFGpAqUmhDcxl6RynF6QpIIMXUkqyNCVpIIMXUkqaM5XL3zkW8v9pk6/5btXessF/bZ7Tj0g1nWMjXc9YuDMef6m09f5fLNlpytJBblOV1Jdot29pKErqS6dkaYr6MnQlVSXKD5NOyuGrqS6OL0gSQXZ6UpSQS3vdNtdnSTNVsTg20DDxUhE3BQRF0+z7zXdp1rfFBG3RMT+/caz05VUl+GvXjgSWA5sNs2+zzDxOKp/ioiFwHeBBT3LG3Z1ktSo6Ay+9RsqYnvgAOCMGQ5J/i+MNwce7Demna6kuszii7SIGAPGJn00npnjk95/HvgksOkMQ/wdcFlEfBTYBNiv3zkNXUl1mcUXad2AHZ9uX0QcCKzMzBsiYtEMQxwEnJ2Zn4uItwDnRMTOmbl2pnMaupLqMrzVC28FlnS/HJsHbBYRX8vMQyYdcziwGCAzr+4+929LYOVMgzqnK6kuIyODbz1k5rGZuX1mLgDeD/xwSuAC3AfsCxAROzIRzo/2GtfQlVSXIS8Z++3h44SIWNJ9ezTw4Yj4KXAu8MHs8+BJpxck1WUOLo7IzKXA0u7r4yZ9/jMmpiEGZuhKqouXAUtSQS2/DNjQlVQXO11JKsibmEtSQU4vSFJBTi9IUkF2upJUkKErSQX5RZokFeScriQV5PSCJBVkpytJ5YShK0nlGLqSVFB0DF1JKsZOV5IKMnQlqSBDV5JKanfmGrqS6mKnK0kFdTpekSZJxdjpSlJJ7c5cQ1dSXex0JakgQ1eSCvIyYEkqyE5XkgoydCWpIENXkgoydCWppHZnrqErqS5eBixJBTm9IEkltTtzDd0SRjvBx9/+WkZHgpEIbnrgaS65/bGmy1ILdAIuOuptPPzUr/jLM5Y1XU4V7HTFC2uT0378C1avSToBR++1gNseeZZ7V/2q6dLUsA/ttQN3PfIs8+f5v+KwDDt0I2IEWAY8kJkHTtm3EfAvwG7A48D7MvPeXuP1nXGOiDdGxDERcVpEfKH7escX/Rusp1avSQBGOkGn5Zcpqozf2Xweey/cmvOvub/pUqoSEQNvAzoSWD7DvsOBVZn5OuBU4KR+g/UM3Yg4BjiPiVmS64Dru6/PjYhPDVqxJv6jHbv3Dpy0/+u5faVdruC4dy3kxO8sZ21m06VUJTox8NZ3rIjtgQOAM2Y45B3AV7uvvwHsG33SvF+neziwR2aemJlf624nAm/u7pup0LGIWBYRy2677II+p1g/JPAPV9zDp793Jwu22JhtN92o6ZLUoH0Wbs1jz/yaW1c83XQp1ZlNpzs5q7rb2JThPg98Elg7w+m2A+4HyMwXgKeAV/aqr99E0lrgVcAvpny+bY8iyMxxYBzgI99a7j/jkzz/m7Xc+dgvWbjNJjz0zOqmy1FDdtthC/bbeWv2Xrg3G412mD9vA079wC58/Os3N13aS95s5nQnZ9U04xwIrMzMGyJi0Uynm27YXufsF7ofA34QEXfSTXPgNcDrgCP6/Ky65m84wppMnv/NWjboBG/YahMuv/PxpstSg06+5A5OvuQOAPb8vVfw4b1/18AdkiF+j/ZWYElE7A/MAzaLiK9l5iGTjlkBvBpYERGjwObAE70G7Rm6mfm9iHg9E9MJ2zGR6iuA6zNzzYv+VdYzm80b5dDdXkUnJv4gblzxDLc+/GzTZUlVGtbqhcw8Fji2O+Yi4BNTAhfgIuAw4GrgPcAPM3tP0vddp5KZa4FrXkTN6nrw6dWceMU9TZehlrr27ie49u6ezZFmYa5XB0XECcCyzLwIOBM4JyLuYqLDfX+/n3dxoKSqzMW1EZm5FFjafX3cpM9/Bbx3NmMZupKq0vZ18IaupKq0/CpgQ1dSXbz3giQV1PLMNXQl1cWbmEtSQXa6klSQc7qSVFDLM9fQlVQXO11JKqjlmWvoSqqLV6RJUkFOL0hSQS3PXENXUl3sdCWpoJZnrqErqS5+kSZJBTm9IEkFGbqSVFDLM9fQlVQXO11JKqjlmWvoSqqLqxckqaBOy1tdQ1dSVVqeuYaupLr4RZokFdTyKV1DV1Jd/CJNkgoKDF1JKqblja6hK6kufpEmSQW1PHMNXUl18eIISSrI1QuSVFDLG106TRcgScPUiRh46yUi5kXEdRHx04i4LSKOn+aYoyLiZxFxS0T8ICJe27e+dfjdJKl1YhZbH6uBfTLzTcAuwOKI+MMpx9wE7J6ZfwB8A/hsv0ENXUlViYiBt15ywrPdtxt0t5xyzBWZ+cvu22uA7fvVZ+hKqkonBt8iYiwilk3axiaPFREjEXEzsBK4PDOv7XHqw4FL+9XnF2mSqjKb1QuZOQ6M99i/BtglIl4OfCsids7MW6ceFxGHALsDf9S3voGrk6SXgGFNL0yWmU8CS4HF05xvP+DTwJLMXN1vLENXUlVmM73QS0Rs1e1wiYiNgf2A26ccsyvwz0wE7spB6nN6QVJVhnjvhW2Br0bECBMN6gWZeXFEnAAsy8yLgJOB+cC/dc97X2Yu6TWooSupKsOK3My8Bdh1ms+Pm/R6v9mOa+hKqsqIlwFLUjne2lGSCmp55hq6kurirR0lqaCWZ+7ch+5ZJ3xxrk+hl6BV15/edAmqlHO6klTQiKErSeW0fMWYoSupLoauJBXknK4kFWSnK0kFtbzRNXQl1WW05alr6EqqSssz19CVVBcvA5akglqeuYaupLq4ekGSCvIm5pJUUMsz19CVVJcY2lPS5oahK6kqdrqSVJChK0kFecMbSSpopNN0Bb0ZupKq4hVpklSQc7qSVFDLG11DV1JdOq7TlaRy7HQlqaDRlk/qGrqSqmKnK0kFuWRMkgpqeeYaupLq0vIL0gxdSXVp+/RC2/9RkKRZ6UQMvPUSEa+OiCsiYnlE3BYRR/Y4do+IWBMR7+lXn52upKoMsc99ATg6M2+MiE2BGyLi8sz82f87X8QIcBLw/UEGtdOVVJWIwbdeMvOhzLyx+/oZYDmw3TSHfhT4JrBykPoMXUlViYjZbGMRsWzSNjbDmAuAXYFrp3y+HfAu4MuD1uf0gqSqzKaTzMxxYLzXMRExn4lO9mOZ+fSU3Z8HjsnMNYPePN3QlVSVYa5eiIgNmAjcr2fmhdMcsjtwXjdwtwT2j4gXMvPfZxrT0JVUlWE9ricmBjoTWJ6Zp0x3TGbuMOn4s4GLewUuGLqSKjPEL6reCvwF8J8RcXP3s78BXgOQmQPP405m6EqqyrA63cz8MbNYgZaZHxzkOENXUlXafT2aoSupMiMtvwzY0JVUlZZnrqErqS7R8gkGQ1dSVex0JakgnwYsSQXZ6UpSQW2/ibmhK6kqLX8Cu6ErqS6uXpCkglo+u2DolnL7JcfzzHOrWbN2LS+sWcvbPvDZpktSw477zLFc+aOlvOIVr+TCb1/cdDnVsNPV/1o89gUef/K5pstQS7zjne/moIMP4dPHHtN0KVVxTlfStHbbfQ8eeGBF02VUx9ULAiAz+c6XjiAzOfObV3HWhVc1XZJUpXZH7jqEbkR8KDO/MsO+MWAMYHT7RYxuudOLPU019vnQqTz06FNstcV8Lv7yEdxx78NcdePdTZclVaftne663GT9+Jl2ZOZ4Zu6embsbuBMeevQpAB5d9SwX/fAW9thpQbMFSZWKWWxN6NnpRsQtM+0Cthl+OXV62bwN6XSCZ3+5mpfN25D93vJG/n780qbLkurU7ka37/TCNsCfAKumfB7AT+akogpt/cpNOf+UDwMwOjLC+Zcu4/KfLG+4KjXtmE8cxbLrr+PJJ1fxx/vsxV995KO8+8/e23RZL3ltn17oF7oXA/Mz8+apOyJi6ZxUVKF7H3icPd93YtNlqGVO+sdpHzCrddTuyO0Tupl5eI99Bw+/HElaRy1PXZeMSaqKV6RJUkEtn9I1dCXVpeWZa+hKqku0vNU1dCVVpeWZa+hKqkvLM9fQlVSZlqeuoSupKi4Zk6SCnNOVpIIMXUkqyOkFSSrITleSCmp55q7TkyMkqX2G+OiIiDgrIlZGxK09jlkUETdHxG0R8aN+Yxq6kqrSiRh4G8DZwOKZdkbEy4EvAUsycyeg713oDV1JVRnmM9Iy80rgiR6HHAxcmJn3dY9f2W9MQ1dSXWaRuhExFhHLJm1jszzb64EtImJpRNwQEYf2+wG/SJNUldksGcvMcWB8HU43CuwG7AtsDFwdEddk5n/1+gFJqkbhJWMrgMcy8znguYi4EngTMGPoOr0gqSrDnNMdwLeBt0fEaES8DNgT6PmobztdSVUZ5k3MI+JcYBGwZUSsAP4W2AAgM7+cmcsj4nvALcBa4IzMnHF5GRi6kiozzOmFzDxogGNOBk4edExDV1JV2n5FmqErqS4tT11DV1JVvMuYJBXkXcYkqaCOoStJJbU7dQ1dSVVxekGSCmp55hq6kupipytJBQ3zMuC5YOhKqkq7I9fQlVSZlje6hq6kunhFmiSV1O7MNXQl1aXlmWvoSqrLgI9Wb4yhK6kqLc9cn5EmSSXZ6UqqSts7XUNXUlVcMiZJBdnpSlJBhq4kFeT0giQVZKcrSQW1PHMNXUmVaXnqGrqSqtL2y4AjM5uuYb0REWOZOd50HWoX/y7WL14GXNZY0wWolfy7WI8YupJUkKErSQUZumU5b6fp+HexHvGLNEkqyE5XkgoydCWpIEO3kIhYHBF3RMRdEfGpputR8yLirIhYGRG3Nl2LyjF0C4iIEeCLwJ8CC4GDImJhs1WpBc4GFjddhMoydMt4M3BXZv48M38NnAe8o+Ga1LDMvBJ4ouk6VJahW8Z2wP2T3q/ofiZpPWPoljHdHThcqyethwzdMlYAr570fnvgwYZqkdQgQ7eM64Hfj4gdImJD4P3ARQ3XJKkBhm4BmfkCcATwfWA5cEFm3tZsVWpaRJwLXA28ISJWRMThTdekuedlwJJUkJ2uJBVk6EpSQYauJBVk6EpSQYauJBVk6EpSQYauJBX032x6Xvvjsa1/AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.heatmap(a1, annot=True, cmap='Blues')\n",
    "plt.title(\"A1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5,1,'A2')"
      ]
     },
     "execution_count": 66,
     "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": [
    "sns.heatmap(a2, annot=True, cmap='Blues')\n",
    "plt.title(\"A2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "a1_elem_mul_a2 = np.multiply(a1, a2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[12, 12],\n",
       "       [25,  7]])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a1_elem_mul_a2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5,1,'A1 Element Wise Multiplication with A2')"
      ]
     },
     "execution_count": 69,
     "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": [
    "sns.heatmap(a1_elem_mul_a2, annot=True, cmap='Blues')\n",
    "plt.title(\"A1 Element Wise Multiplication with A2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Square root"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5,1,'SQRT(A1)')"
      ]
     },
     "execution_count": 70,
     "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": [
    "sns.heatmap(np.sqrt(a1), annot=True, cmap='Blues')\n",
    "plt.title(\"SQRT(A1)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Find $n^{th}$ number in fibonacci sequence using matrix math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](https://www.geeksforgeeks.org/wp-content/uploads/fibonaccimatrix.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Use numpy matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[1, 1],\n",
       "        [1, 0]])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "base_matrix = np.matrix([[1, 1], [1,0]])\n",
    "base_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 10\n",
    "nth_power = base_matrix **n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[89, 55],\n",
       "        [55, 34]])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nth_power"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "55"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fib_n = nth_power[1, 0]\n",
    "fib_n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Broadcasting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "one_d = np.arange(1, 10, 1)\n",
    "one_d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Add 1 elementwise to each number in the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2,  3,  4,  5,  6,  7,  8,  9, 10])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.add(one_d, np.ones_like(one_d))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Let's do something different!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2,  3,  4,  5,  6,  7,  8,  9, 10])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "one_d + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, 1, 1, 1, 1, 1, 1])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.tile(1, one_d.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2,  4,  6,  8, 10, 12, 14, 16, 18])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "one_d*2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 4,  6,  8, 10, 12, 14, 16, 18, 20])"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(one_d*2)+2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2],\n",
       "       [ 3,  4],\n",
       "       [ 5,  6],\n",
       "       [ 7,  8],\n",
       "       [ 9, 10]])"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "two_d = np.arange(1, 11, 1).reshape(-1, 2)\n",
    "two_d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  3],\n",
       "       [ 4,  5],\n",
       "       [ 6,  7],\n",
       "       [ 8,  9],\n",
       "       [10, 11]])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "two_d + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  4],\n",
       "       [ 4,  6],\n",
       "       [ 6,  8],\n",
       "       [ 8, 10],\n",
       "       [10, 12]])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "two_d + np.array([1, 2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  4],\n",
       "       [ 4,  6],\n",
       "       [ 6,  8],\n",
       "       [ 8, 10],\n",
       "       [10, 12]])"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Works with list too!\n",
    "two_d + np.array([1, 2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  3],\n",
       "       [ 4,  5],\n",
       "       [ 6,  7],\n",
       "       [ 8,  9],\n",
       "       [10, 11]])"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "two_d + np.array([[1], [1], [1], [1], [1]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 9: Find the mean of each row of a matrix and subtract the mean from the corresponding row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [7, 8, 9],\n",
       "       [1, 4, 9]])"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "two_d = np.array([[1,2,3],[4,5,6],[7,8,9],[1,4,9]])\n",
    "two_d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-1.        ,  0.        ,  1.        ],\n",
       "       [-1.        ,  0.        ,  1.        ],\n",
       "       [-1.        ,  0.        ,  1.        ],\n",
       "       [-3.66666667, -0.66666667,  4.33333333]])"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "two_d - np.mean(two_d, axis = 1).reshape(-1,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 10: Find the softmax of an array.\n",
    "If x is the array and p is its softmax, then\n",
    "$ p_i =\\frac{e^{(x_i)}}{\\sum_{t=1}^{n}e^{(x_t)}} $"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6, 7, 8])"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([1,2,3,4,5,6,7,8])\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5.76612770e-04, 1.56739601e-03, 4.26062410e-03, 1.15815771e-02,\n",
       "       3.14819905e-02, 8.55769227e-02, 2.32622194e-01, 6.32332683e-01])"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.exp(x) / np.sum(np.exp(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2],\n",
       "       [ 3,  4],\n",
       "       [ 5,  6],\n",
       "       [ 7,  8],\n",
       "       [ 9, 10]])"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_array = np.arange(1, 11, 1).reshape(5, 2)\n",
    "test_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Syntax\n",
    "\n",
    "arr[outer selector, inner selector, ...]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Get a row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2])"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "test_array[0, :]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise : Print the last column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2,  4,  6,  8, 10])"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_array[:, 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We knew that there are 2 columns and thus we used the index [:, 1]. Could we use some other way?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2,  4,  6,  8, 10])"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_array[:, -1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise find the element in last row and last column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_array[-1, -1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise: Find the first two rows and first column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 3])"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_array[:2, 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wait, this is a lower rank array. What if we want the same rank array?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1],\n",
       "       [3]])"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_array[:2, 0:1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simple condition checking and indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False],\n",
       "       [False,  True],\n",
       "       [False, False],\n",
       "       [False,  True],\n",
       "       [False, False]])"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_array%4==0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 8])"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_array[test_array%4==0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise: Print all numbers greater than 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 6,  7,  8,  9, 10])"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_array[test_array>5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexing and assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Set the last column to be all 1s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1],\n",
       "       [3, 1],\n",
       "       [5, 1],\n",
       "       [7, 1],\n",
       "       [9, 1]])"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_array[:, 1] = 1\n",
    "test_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise: Set the first column of last two rows to be all -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  1],\n",
       "       [ 3,  1],\n",
       "       [ 5,  1],\n",
       "       [-1,  1],\n",
       "       [-1,  1]])"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_array[-2:, 0] = -1\n",
    "test_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise: Set all negative numbers to 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1],\n",
       "       [3, 1],\n",
       "       [5, 1],\n",
       "       [0, 1],\n",
       "       [0, 1]])"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_array[test_array<0] = 0\n",
    "test_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interfacing with files - Persistence and Loading"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Saving data to disk in binary format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.save('test-arr.npy', test_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-rw-r--r--  1 nipun  staff   208B Oct 27 15:01 test-arr.npy\r\n"
     ]
    }
   ],
   "source": [
    "!ls -lah test-arr.npy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "�NUMPY\u0001\u0000v\u0000{'descr': '<i8', 'fortran_order': False, 'shape': (5, 2), }                                                          \r\n",
      "\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0003\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0005\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0000"
     ]
    }
   ],
   "source": [
    "!cat test-arr.npy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Loading binary data from disk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_loaded = np.load('test-arr.npy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1],\n",
       "       [3, 1],\n",
       "       [5, 1],\n",
       "       [0, 1],\n",
       "       [0, 1]])"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_loaded"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array_equal(test_loaded, test_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Saving data to disk in text format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/nipun/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:1: DeprecationWarning: This function is deprecated. Please call randint(1, 100 + 1) instead\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 17,  26,  43,  25,  44,  65,   4,  94,  61,  42],\n",
       "       [ 12,  58,  56,  13,  18,  13,  66,  15,  13,  48],\n",
       "       [  6,  65,  59,   6,  13,  80,   8,   7,  98,   8],\n",
       "       [ 63,  92,  47,  24,  10,   8,  50, 100,  76,  79],\n",
       "       [ 23,  89,  35,  16,   6,  35,  48,  26,  62,  56],\n",
       "       [ 45,  84,  37,  66,   5,  45,  40,  55,   9,  54],\n",
       "       [ 22,  38,  50,  15,  76,  46,  13,  48,  41,  38],\n",
       "       [ 60,  34,  44,  61,  28,  19,  98,  72,  40,  84],\n",
       "       [ 90,  48,  97,  13,  21,  34,  59,  17,  91,  55],\n",
       "       [ 18,  55,   6,  22,  74,  10,  74,  42,  71,  23]])"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "big_array = np.random.random_integers(1, 100, size=(10,10))\n",
    "big_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savetxt('big-array.csv', big_array, delimiter=',', fmt='%d')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17,26,43,25,44,65,4,94,61,42\r\n",
      "12,58,56,13,18,13,66,15,13,48\r\n",
      "6,65,59,6,13,80,8,7,98,8\r\n",
      "63,92,47,24,10,8,50,100,76,79\r\n",
      "23,89,35,16,6,35,48,26,62,56\r\n",
      "45,84,37,66,5,45,40,55,9,54\r\n",
      "22,38,50,15,76,46,13,48,41,38\r\n",
      "60,34,44,61,28,19,98,72,40,84\r\n",
      "90,48,97,13,21,34,59,17,91,55\r\n",
      "18,55,6,22,74,10,74,42,71,23\r\n"
     ]
    }
   ],
   "source": [
    "!head big-array.csv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Loading text data from disk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 17.,  26.,  43.,  25.,  44.,  65.,   4.,  94.,  61.,  42.],\n",
       "       [ 12.,  58.,  56.,  13.,  18.,  13.,  66.,  15.,  13.,  48.],\n",
       "       [  6.,  65.,  59.,   6.,  13.,  80.,   8.,   7.,  98.,   8.],\n",
       "       [ 63.,  92.,  47.,  24.,  10.,   8.,  50., 100.,  76.,  79.],\n",
       "       [ 23.,  89.,  35.,  16.,   6.,  35.,  48.,  26.,  62.,  56.],\n",
       "       [ 45.,  84.,  37.,  66.,   5.,  45.,  40.,  55.,   9.,  54.],\n",
       "       [ 22.,  38.,  50.,  15.,  76.,  46.,  13.,  48.,  41.,  38.],\n",
       "       [ 60.,  34.,  44.,  61.,  28.,  19.,  98.,  72.,  40.,  84.],\n",
       "       [ 90.,  48.,  97.,  13.,  21.,  34.,  59.,  17.,  91.,  55.],\n",
       "       [ 18.,  55.,   6.,  22.,  74.,  10.,  74.,  42.,  71.,  23.]])"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.loadtxt('big-array.csv', delimiter=',')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Miscellaneous exercises\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Swap two rows of a 2-d array.\n",
    "2. Given two vectors (1-d arrays), find the projection of the first vector on the second.\n",
    "3. Given n arrays, create a matrix where each array is a column of the matrix.\n",
    "4. Given a system of equations (say 3 variable, 3 equation system), solve it.\n",
    "   Hint: Use the numpy.linalg sub-module. It contains an inverse function.\n",
    "\n",
    "##### The linalg sub-module is a very useful module which has linear algebra functions."
   ]
  }
 ],
 "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
}