numpy/SciPy Numpy Extended Lectures Part 3 - Broadcasting, Shape Manipulation and Sorting Data.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "# Numerical operations with Numpy\n",
    "\n",
    "## 3.1 **Broadcasting**\n",
    "## 3.2 **Array shape manipulation**\n",
    "##  3.3 **Sorting data**\n",
    "##  **Summary**\n",
    "## **Exercises**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "## 3.1 Broadcasting Operations\n",
    "\n",
    "-  We just covered basic operations (add, multiple, square etc) such are element-wise but that works on arrays of same size\n",
    "- **Broadcasting** comes handy when we are dealing with different shapes. This time, we'll explore a more advanced concept in numpy called broadcasting. \n",
    "\n",
    "- The term broadcasting describes how numpy treats arrays with different shapes during arithmetic operations. Subject to certain constraints, *the smaller array is \"broadcast\" across the larger array so that they have compatible shapes*. \n",
    "- Broadcasting provides a means of **vectorizing array operations** so that looping occurs in C instead of Python. It does this without making needless copies of data and usually leads to efficient algorithm implementations. There are also cases where broadcasting is a bad idea because it leads to inefficient use of memory that slows computation.\n",
    "- In this little tutorial we will provide a gentle introduction to broadcasting with numerous examples ranging from simple to involved. \n",
    "- We will also go through a few examples of when to and when not to use boradcasting.\n",
    "\n",
    "\n",
    "\n",
    "#### This example below shows how broadcasting works\n",
    "\n",
    "<img src=\"figures/numpy_broadcasting.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "### So, lets start taking baby steps...\n",
    "\n",
    "Here an element-wise multiplication occurs since the two arrays are of same shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2., 4., 6.])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e = np.array([1.0, 2.0, 3.0])\n",
    "f = np.array([2.0, 2.0, 2.0])\n",
    "e*f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "##### Hint / Try it?\n",
    "\n",
    "What would have happened if `f = np.array([2.0, 2.0])`. would it still multiply?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2., 4., 6.])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# But if it was like this\n",
    "\n",
    "e = np.array([1.0, 2.0, 3.0])\n",
    "f = 2.0\n",
    "e*f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "##### What happened here\n",
    "\n",
    "This is the most simplest example on numpy broadcasting where an array and a scalar values were combined in an operation.\n",
    "\n",
    "so it kind of *stechted in the row direction*! The scalar **f** is stretched to become an array of with the same shape as **e** so the shapes are compatible for element-by-element multiplication.\n",
    "\n",
    "<img src=\"figures/broadcast_stretch.gif\">\n",
    "\n",
    "** So what are the rules then?**\n",
    "- They must either be equal / same shape\n",
    "OR\n",
    "- One of them must be 1, like f was above"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.,  0.,  0.],\n",
       "       [10., 10., 10.],\n",
       "       [20., 20., 20.],\n",
       "       [30., 30., 30.]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Typical broadcasting in practice\n",
    "g = np.array([[ 0.0, 0.0, 0.0], [10.0,10.0,10.0],[20.0,20.0,20.0],[30.0,30.0,30.0]])\n",
    "g       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 2., 3.])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h = np.array([1.0, 2.0, 3.0])\n",
    "h"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  2.,  3.],\n",
       "       [11., 12., 13.],\n",
       "       [21., 22., 23.],\n",
       "       [31., 32., 33.]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g + h"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "### What happened above?\n",
    "\n",
    "A 2-D (two-dimensional) array multiplied by 1-D (one-dimensional) array. It got stretched in the column direction so as to match the elements of the 2D array columns.\n",
    "<img src=\"figures/broadcast_strectch2.gif\">\n",
    "\n",
    "Would the same be possible for different shapes? Does broadcasting magically understands and fixes our assumptions?\n",
    "\n",
    "Let's take a look...\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "operands could not be broadcast together with shapes (4,3) (4,) ",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-7-3eb92f04cdb1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m[\u001b[0m \u001b[0;36m0.0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0.0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0.0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m10.0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m10.0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m10.0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m20.0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m20.0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m20.0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m30.0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m30.0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m30.0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mi\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0.0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1.0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2.0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3.0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mg\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (4,3) (4,) "
     ]
    }
   ],
   "source": [
    "g = np.array([[ 0.0, 0.0, 0.0], [10.0,10.0,10.0],[20.0,20.0,20.0],[30.0,30.0,30.0]])\n",
    "i = np.array([0.0, 1.0, 2.0, 3.0])\n",
    "g+i       "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "### We had a mismatch...\n",
    "\n",
    "<img src=\"figures/broadcast_strectch3.gif\">\n",
    "\n",
    "Explanation: When the trainling dimensions of the arrays are different as you saw above, then broadcasting will fail making it impossible to align the values in the rows of the first array with the elements of the second array for an **element-by-element** addition or multiplication.\n",
    "\n",
    "### Also, is there a way to do this in one line of code\n",
    "\n",
    "Tip: look up more into np.tile and np.arange"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  0,  0],\n",
       "       [10, 10, 10],\n",
       "       [20, 20, 20],\n",
       "       [30, 30, 30]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.tile(np.arange(0, 40, 10), (3, 1))\n",
    "a = a.T # transpose this\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.array([0, 1, 2])\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "##### Now, we add these two"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2],\n",
       "       [10, 11, 12],\n",
       "       [20, 21, 22],\n",
       "       [30, 31, 32]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "##### So you see that broadcasting was applied magically...\n",
    "\n",
    "Ask yourself, why couldn't we add original `a` and `b` ?\n",
    "\n",
    "Note, original a was:\n",
    "```python\n",
    "array([[ 0, 10, 20, 30],\n",
    "       [ 0, 10, 20, 30],\n",
    "       [ 0, 10, 20, 30]])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = np.ones((5, 6))\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "##### Let's assign an array of dimension 0 to an array of dimension 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2., 2., 2., 2., 2., 2.],\n",
       "       [1., 1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c[0] = 2\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0, 10, 20])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = np.arange(0, 30, 10)\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3,)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 1)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = d[:, np.newaxis] # Here we add a new axis and make it a 2D array\n",
    "d.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "operands could not be broadcast together with shapes (4,3) (3,1) ",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-16-4fbab87c839c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ma\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (4,3) (3,1) "
     ]
    }
   ],
   "source": [
    "a + d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "#### Another example on broadcasting\n",
    "\n",
    "Let’s construct an array of distances (in miles) between cities of Route 66: Chicago, Springfield, Saint-Louis, Tulsa, Oklahoma City, Amarillo, Santa Fe, Albuquerque, Flagstaff and Los Angeles."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[   0,  198,  303,  736,  871, 1175, 1475, 1544, 1913, 2448],\n",
       "       [ 198,    0,  105,  538,  673,  977, 1277, 1346, 1715, 2250],\n",
       "       [ 303,  105,    0,  433,  568,  872, 1172, 1241, 1610, 2145],\n",
       "       [ 736,  538,  433,    0,  135,  439,  739,  808, 1177, 1712],\n",
       "       [ 871,  673,  568,  135,    0,  304,  604,  673, 1042, 1577],\n",
       "       [1175,  977,  872,  439,  304,    0,  300,  369,  738, 1273],\n",
       "       [1475, 1277, 1172,  739,  604,  300,    0,   69,  438,  973],\n",
       "       [1544, 1346, 1241,  808,  673,  369,   69,    0,  369,  904],\n",
       "       [1913, 1715, 1610, 1177, 1042,  738,  438,  369,    0,  535],\n",
       "       [2448, 2250, 2145, 1712, 1577, 1273,  973,  904,  535,    0]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mileposts = np.array([0, 198, 303, 736, 871, 1175, 1475, 1544, 1913, 2448])\n",
    "distance_array = np.abs(mileposts - mileposts[:, np.newaxis])\n",
    "distance_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "#### Another example\n",
    "\n",
    "A lot of grid-based or network-based problems can also use broadcasting. For instance, if we want to compute the distance from the origin of points on a 10x10 grid, we can do"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.        , 1.        , 2.        , 3.        , 4.        ],\n",
       "       [1.        , 1.41421356, 2.23606798, 3.16227766, 4.12310563],\n",
       "       [2.        , 2.23606798, 2.82842712, 3.60555128, 4.47213595],\n",
       "       [3.        , 3.16227766, 3.60555128, 4.24264069, 5.        ],\n",
       "       [4.        , 4.12310563, 4.47213595, 5.        , 5.65685425]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x, y = np.arange(5), np.arange(5)[:, np.newaxis]\n",
    "distance = np.sqrt(x**2 + y**2)\n",
    "distance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Or in color... "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function matplotlib.pyplot.colorbar(mappable=None, cax=None, ax=None, **kw)>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.pcolor(distance)\n",
    "plt.colorbar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[0],\n",
       "        [1],\n",
       "        [2],\n",
       "        [3],\n",
       "        [4]]),\n",
       " array([[0, 1, 2, 3, 4]]))"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Note : The numpy.ogrid function allows to directly create vectors\n",
    "# x and y of the previous example\n",
    "x, y = np.ogrid[0:5, 0:5]\n",
    "x, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((5, 1), (1, 5))"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.shape, y.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " `np.ogrid` is quite useful as soon as we have to handle computations on a grid. While on other hand, `np.mgrid`\n",
    " directly provides matrices full of indices for cases where we can't or maybe don't want to benefit from broadcasting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "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]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x, y = np.mgrid[0:4, 0:4]\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2, 3],\n",
       "       [0, 1, 2, 3],\n",
       "       [0, 1, 2, 3],\n",
       "       [0, 1, 2, 3]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### A bit on Vector quantization or VQ\n",
    "\n",
    "A simple way to understand bradcasting is with this real world situation. The basic operatio in VQ finds the closest point in a set of points, called $codes$ in VQ speak, to a given point, called the `observation`.\n",
    "\n",
    "In the 2D example below, the value in an $observation$ describe the weight and height of an athlete to be classified. The $codes$ represent different classes of athletes such as dancer, runner, swimmer an so on.\n",
    "\n",
    "Finding the closest point requires calculating the distance between `observation` and each of the `codes`.\n",
    "\n",
    "The shortest distance provides the best match. Here in this example, `codes[0]` is the closest class indicating that the athlete is likely a basketball player.\n",
    "\n",
    "<img src=\"figures/VQ.png\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import array, argmin, sqrt, sum\n",
    "observation = array([111.0, 188.0])\n",
    "codes = array([[102.0, 203.0],\n",
    "               [132.0, 193.0],\n",
    "                [45.0, 155.0],\n",
    "                [57.0, 173.0]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This is how broadcast happens\n",
    "difference = codes - observation\n",
    "distance = sqrt(sum(difference**2, axis=-1))\n",
    "nearest = argmin(distance)\n",
    "nearest"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The basic operation of vector quantization calculates the distance between an object to be classified, the black square, and multiple known codes, the gray circles. In the very basic case, the codes represent classes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A more advanced example  \n",
    "\n",
    "`@article{scikit-learn,\n",
    " title={Scikit-learn: Machine Learning in {P}ython},\n",
    " author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.\n",
    "         and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.\n",
    "         and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and\n",
    "         Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},\n",
    " journal={Journal of Machine Learning Research},\n",
    " volume={12},\n",
    " pages={2825--2830},\n",
    " year={2011}\n",
    "}`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x158.4 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x158.4 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAANAAAACaCAYAAADYZ8Z+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO19f6xsV3Xet2L7Ud4N8bWb59Rv4iYktVFRaR0zA0SJYiQLsK00r6ma1qnU59IrWffWiUCtpbqJjN4fjepUan5YaedBdKkgQnlKINW7f5CkCCVqKwK9AyWA475gKAnmGh5gK0T3SaU0u3/MWfO+WbPW3vvMj3vPdeaTRjNzzj57r73PXr/32UdSSlhjjTXmw7cdNwFrrHGSsWagNdZYAGsGWmONBbBmoDXWWABrBlpjjQWwZqA11lgAK2EgEblfRK6IyLMi8vgq2lhjjS5Alp0HEpEbAPwxgDcBeA7APoCfTCn90VIbWmONDmAVGuh1AJ5NKX0+pfRNAJcAnFtBO2uscey4cQV19gB8kf4/B+D1tpCIPALgEQC46aabXnv69GlsbGxUN3J4eDgpv7GxgcPDQ7ecntOyWm5jYwNXr16daZOPe/VqXfyt19lyHh2WpsPDQ1y7dg2nT5+enLO01iA3Bjnw2OTOef3hcjW4du0aAEz6moOl6atf/SpOnz49VQePW0190Zw5ODj4WkrpTFVFBqtgIHGOzdiJKaV3AXgXAGxubqZLly5hNBpNldnf38dgMJh89/t9DIfDqTKDwQDD4RA7OzvY39+fHN/Z2QEAjEYj9Pv9ybce29/fx1NPPTXTJkOv8+jRtvWYlh8Oh5P/eo3FaDTCY489BgAYDoeT31yX/t/Z2XFpsLRx37i/uf7ZPmnblg6vHPfL/vf6y7QorXyOYdseDoc4c2Y8vzc2NmbutdeebcerV/u1t7f3J2FlBazChHsOwB30/7sBHJQu0kkNXO+4dlgHbDQaYTAYzAyELa9gZrMTzP7u9/vuTeGboBNlZ2dn6vf+/v6EPgaXVdq5rf39/anfWif3h8fFjpediNq+flthYycUj5llHqXJ9mceeO169HqwfdjZ2Zk5Zuvb2dmZjDt/tA/88ZiqDVYRRLgR4yDCfQC+hHEQ4R+nlJ6Orun1ekknIneIpRZLfT4PXGe+SPJ71wCYaAuW2PYY16XawE6k3E0YDofo9/tZzWV/19at/Yk0tz3G9ZXK5GiK6CsxmBVelv6I0RTMPDqmdg5oGzna+f4Oh0McHBx8PKU023gFls5AACAiDwL4JQA3AHh3SunncuXvuuuuxOaUSm5gegB1MgKYmZB6nSJ3LDJ3+NjW1taU5uN2h8Mhdnd3XUloMRqNJjfeExIKzySaRzp6E7+2HnutFRglU60NLNN7zMPleOz0nnn3xhNAEc1ad+cYqC3uuuuudP78+cl/ZhRgehB4QHPldKKzNFJ4WkgRTdySf5PTICWmidqzPk4kqS1dto1S/V7d1m+pZSLrJ3k+Tskvs3TqvY76n9NgHmz7izDQKoIIrXF4eDilUu2ktxNNpY9V1cxQel5tYy7LkyJiCGaYWqlbknQK9u2shLfo9/szWjKqN2f+5TSaZ1rxcdWiei4XRLDf3qT22vLKKL1bW1sz1zKNUTse2jBvDTqhgdQHAq5Lw8gfYk2U01J8kyJTTBGZK1qWTTXLjFxH5NtEjGX9L/bD7HiUEPmKHl0ePD8wKsN9XgRev6L+Lso4UXvAS8CE6/V6iR1tb6LXhi09m1knJE/MKBxr67HMFTnezKj6P/LXonA190Xp4D7m/AQrYHKINEjkQ5QwLyPVaoNa5snNlaitfr+Pvb29k81Am5ub6d57721lLpUke0n6e+VKGiTnZ3h1cx1A3nSpNdP4PNc3r2aoiQRy2XlMW0UkBEqM5I1bbY4nV7/WceIZiE04hee01tw0Lz/CWkdRCixE5fQ8a5scjTUS3DPjlHZFLozP/bamnEeTRWSO5n7bNmx9fE61f01EzMILe+doZ7pydfJ1TzzxxNwM1InHGTSIsL9/PXnHyUqgPoRqGdHWq3XxjVCzkQecJw1fq8GJ6CZZGr1krgYG9GPPWcaxdfJ1fCyaMDVaOHfM/m7DjIPBIAzaKErmqcc8g8FsQp1pjbS8zqtloRMMtLGxMZFQ7Ae1zWN4iCJI9qaypNP2lB5PAms5u2pAoTfKagn+jmAnCkOjjbYuj6midnITzzJLZNZFTOQJnJLgKyVT7fGcKc1RV77WC/wsA51hIGUYvmmDwWBGozB4QKxE4lAxcP0GsF/DQYXoBipNPMEGgwF2d3cn7ahG4mM26GAnqNV4DG8SWNhgC9NvJywzmxUOSiMfj7RPBG/ca84xrDb2fucQ9VkZZxXMA3SEga5evYrd3d0pf0XBmsjzk3gieNDBt9cqc5bMHq1fr7caDLieyNQVCspwHvMrw+WcaXuetR5/syaybXBZnUQlX7BGW3iI7oNlnrbmn3d+Z2dnyvzVOq1AWqXWYXSCgW677bYp5mEpyjkJ9SeiUDL/1puqA8sDnLPv7TGbTwIwFUBQejjc7YWkPXPO82P4vEejLWeZWaETjdFmAnsTzxNCzDhRkCHys7w2mPlZe1jG0c/u7q57/qjQmZUIwPWJwREbNr2AfIjau4GsGfSGRFE277fNzOs3L2wcjUYTDaptetqtJsfj/facbza57HU5n8IbNxuA8NpSRp1XokemLEOPsV9pgyxA/vGIthHQeTQuoxMaaGNjY0YNewzDsJqGy1rwZFZNYbWags2xqD2eTHqTOYFrw8keTZ65YaVnLojCmlmvKwUpuB5lTM3rsJlsk9j6Oxc4yLUVlckFU9jU9fJdo9F42ZeasWyqeu17NC/KPEBHGAiYtpFZbbO24f/WfABmNRCfs84kH2dNp+f4uL0x7Jcpo2lZKwCYWb2wtSIKKtgV6Aqvnlwo2HOyOdBiI5F2PHKaI4K1Iiy843rft7e3Q5NWmYfbsHVEWBbjKDrBQIeHhzOTXyWj9S+iwbG2uL05PNE9NR+t3LZakTWYZRqdqPxMkfaljV0e5TCYXqXHMl7Jt9I6bDQwoi8a79IktNrTG1cPnsaxmsfzW0vju2zGUXTCB9Ln1K2ZxMxjFzhaf0mvYwe+xrxjeBOp9pEJbr+U51H6axOftu+eFrVMxH23E441ovUntre3p3wLzp/p9TmJ75nbtp8cKOBjbIp6IXpPk3IbEROVAid7e3vh+RI6oYGuXr0KYDZ3k2OAnMnDN90LCedyS3wjWNuwhtPfyjwc4rY3PtImJfvf0qTXKVjYeA/2sQa0ES/LUJ4GK/lRHhN7tEfaz4uwRX21NHvwopE5rRNFAduiEwzEGogno42EseRU8ERhf8MyG8PbmERhAwJRtIjNRJsTsuU8M8six1Cen8PjE00Eb0KxMCjtLaDQMc5pH37U2qPBXlujpW1wwBtLBQvFo2AcRWcYSP0bHjQrKa3PAVz3lXKhW4U3cCwNWYp5dUTRJtYG9tEH60jntJKeZ//EntffkcT36mWT2NJux4Gv0fvgMa2NkHkhZ20357N442zHaGtrq5ohSubastEJBjo8PJza3cYzIWwETW9e5BvpDVXmslojN5g8mT3fg8ETU/vg+SwsGHLRsgh21UGuLE9cG263/bTmZ9RX6wta6D2zObZo/Pi3jo23soKFY0645fyjZWsdRicYSMFbQAGxhLSLQ3lA7dOjbOZ4zquWU3gTgSekdzNslJBNvyjHo+dysKapnUheHTYNoGVYu1rTMjK77H8OHXtlVJNzXokDLjzBPY3LfeDvqL+sDXPMs0p0hoF0ciij2AnMG0vYGxqZRVpvyaRjMy53s1hLKrwIkdLLk9TS1+/3cfHixbrBQcxsbO5yGJ5p9J7EzYWnvTRAjZ/l+Vzeby7L0VbPFItSATaS6GHVzAMAN1y4cGHljZTwzne+88KZM2cwHA5x7tw5HBwcTCTu2bNnJwMhMr3paa/Xm/rf7/chIjg4OMD+/j56vR7Onj2Lg4MDHBwcTJVR6HE91u/3cXBwgF6vh8uXL6PX603+P/HEExN6er3epH2l7+DgAHt7ezh37hwuX74MAJP+AMDZs2en2uX/el5pHQwGODg4mGg2LXv27NmZj5qM2o6OjY6DnuPJqn3iOg8ODnDu3LmpMRSRSXk7wUejEXq9Hvr9/mSstG9MD9PP/e/1epMQMjOEtj8ajXBwcBAysx7XsfbKRNjf35+0feXKlecvXLjwruwFAYoaSETuEJHfE5FnRORpEXlbc/xWEfmQiHy2+b6lOS4i8lTzapNPicg9tcRYVWw1TGQCcf6gZBZ50sra41y3nrc5HutL6SS2T6paCW2v9+jlRatRGdZ80UJK1kjsl1kNFElx67Ow9uUACUfgPNONQ9a2bg44KJ3aL6/fVvN4EdUc8yi9PH6LoMaE+xaAf5lS+psA3gDgURF5NYDHAXw4pXQngA83/wHgAQB3Np9HABR3H7Sbk/PgA7OP9Sp4EOyAWJ/B2t8ln0T9GVuGAwX2Wju5PHBf7MTlSVMSBLY8H7OT0WMs/s2mpDVFdfJ7vpZNO7APGAVctKy9x3pefSg7DhwIsUznteEdjx7/WASt90QQkcsAfqX5vDGl9LyI3A7g91NKrxKRdza/f70pf0XLRXX2er0ETEtMGxjwFoTqBPK26PW+FRFD8nnvOr3BnsS2fgYjl7hdBKzNbH+9Mrw7ETDtA9ZMeDvZbV22DLe5tbU1IzwUNsDgwWqemnC1l1z1sMi2Vq2CCCLyvQB+AMDHAHyXMkXzfVtTzHu9ybSzMq7rEREZicjoxRdfnDBPlGsBpqVRaWCsE8rwzDTrOOc0gF1XZ6/lKFjODIvaiDSk0h6FxCMzVyedjXDmnHyGVy5nDnKbwHQI3KNR66wJqXOEzwOblcvWNh6q18KJyLcD+ACAt6eUvmEdei7qHMu+3qTX6yVrJrB2AXzJw2YDwx6zdbH2AqYfvvOkN7fHUpb9D949k8HaMuej5Y57E4HXrHl0e//t8dxOSFaYKBMwI9iddnjie9E+zumwtaHl2Sz2BE8NQ9TsV277/sQTT1Rd46FKA4nITRgzz/tSSr/VHP5KY7qh+b7aHG/9ehNdysNhbP3vOZ+5+H8kue21rKFK/oplNIXeBDbfuK1SfZ4WsbCT3jM/c76cpd/WrRLdOvpeeNrzM/XbajQVLOyPeePpBSaicchpnlwqg8eBrYJloCYKJwB2ATyTUvoFOrUH4OHm98MALtPx80007g0A/izn/wDXF5N6mkAnGK8oAPxFi7kBLN2AkgZgh1npsKaNaiQNNOgNi/JASpdHaym3xWVzfeJAipa3fc3lv7w+RgEFG8Cwj6NwgMGuefTM95KvWhonhd6TVeSFikEEEflhAP8NwKcB/EVz+Gcw9oN+A8BfB/CnAH4ipfRCw3C/AuB+ANcAvDWllO3h5uZmeuyxx6YmqYJvCmsPb7vdyIzhcnyMzSA9xvXYOnQyehsrKtieL4XVayJtTBdf5/lxtTa/NbNsnXzcG3v9nwvgKDj3pNd5GjsK9DDNbIbXaJtahlnpxooppf+eUpKU0t9OKd3dfD6YUvp6Sum+lNKdzfcLTfmUUno0pfT9KaXXlJhH4UWCOMJjI0bWGeaJXhpc70YDs5E/LWuh5eyzP0obv3olJyVzx73f1pQrMaBnMlpavTq9nI9eY2njR9h1guv98JhH27H5IttPHjcORtiyXp9XpW08dGJr383NzaTvvlTozeLNOliq2/Csl6uwYV7+HUm4nBTkOjlnYQMJth+RNvK0W4SobxGdEWwbnibjc542AvwcXVTWhrvtNVyfhRc8sv3waK9hIK17EQ3UCQY6depU4qcCIxPADgqf80y/GoawbebCrV55zy8o3TyrGaK6uXyJnrbI+UTaHuduIhOO64tMa73OWhFR/ikSFqVckaKt9jnxDKSveGSnkxnDC29ax74NPN9GfwN5jeXZ4mz2RJPGm/xttUpOW7RFzjTVPl28eHFGQLQRWJEvZf0thT2X04o51DKQ3sMT/4Y6YDZ3A0xHh6K9BhaVzF6IWH97N1J9A5tnYkSTJWrXg9f2MjUQ+xnb29vuOS8ZHYXUt7e3cfHixalj3H++fznTrSbwUquJPNTmiWrRiccZeGNFz7m1g196uMtDyZn3jkVt2CU7LJ1VG9l8SinC5Jlty2SYCPv7++FjFSrAOGCj4+IJm4i5PJPVc/Ttio4IbU00TdLaN2UsY4w7wUC6saI64TYrrZEdT/JYCc8T1k7aKCqVM6/sxI6eq9HviFZu2zIVn6thrghR30vno0kUjbf1fSL6+v3+RLvV+DWWYXP15iJtOv688aJHfy5xW4tOMNDVq1enJBVn+BVeZ72ID8ObrB5yZZiRPF/Ac4Ttza0NXniBjLZQbTIajXDx4sWpb+5HDhGD299cF0t0K6hs3+wk5gnPWojNTI/26L7rXNEEqrfrj16/iDkIdMQHuu2223D+/PmZd5lyNMd+230HGJHZEEXlImc1ik4B02FsYPaZoijAwc62V3/0PzIp2eFXWO3N9XHovbQ0pgTtp/Whcn3J9d+27TGgpc2uYIjmRE7bLLIvXCcYCLiulhk22cZlOQHHwYac0+7dtNxELpk5TBczvY3Uedn+Eh2eT+QdBzCJllmo8+49mJjzI9nPZP/H0meToLn6PM3ljQf3gzUP998uL7L1KqLHSxiLmnCdYKDDw8OpAR0MBjM5CG9ggelEpaKNYxhJdT4XSWNew2XNT3u9xxzM1DltZ2lQjVNrfvA42k1XIsGQCwwwahOW/NuzEJhRlQa2OHJah/vCddsyNsXQxr+M0AkfaGNjY6rz29vbkxUIwPRgslnHyGWqI3hS3h6z0k9h32LA0k4ZQiU536xIy3h2vqel1CkuhdK9frKWt74dl/VyV5YWy4jetls5AeDVz/9tcMbznex5j06mRYMKSusyVmZ3IpF66tSp9I53vMOVejaJurW15Zp63upsIG9zl0wPi0gz2ZwG+xheIlG1ZsnctG3rcW/1Q0SvTUR70Lch6DXWTGJhoWU0YmrHVn/nFtN65px9vqkGOS3UBkf2ROqqcPr06UkUxk7O3d3dKd9CX5QVSRxvcSKXi46X4Jla3rX82IUXNeTJFZkQnuSOmEq/7Tn2WUo0e6YgS3hLDz886NGgZfSelvqYC6p45q2l2bZ9lOgEA/EDdTrgOqgaXdIX+HqOZRR8ADAlWYG6FQCRVrDlFNbM8HyjaJlKaZLn6FUz1xMOHICxCzht3ZZJ7PV8rX3ylncE4nqtFaH3tWZHHEurR9txMYxFJxjo8PBwxsFjE0GR0zwRIj+D6ygFIKJjPHk18KGTlcPcnBj2fCDP7/HMHBYM/f549XeOiRRs8lmprrRaDadCoORn1ew9wE69XaHB8O6Dp/m7wjxAR3ygzc3NdO+99wKYjrCwGZez+WsG0jMTavwIrx3L1LoGjM+XHjSz9VhatF6mHZg2UZl551nexLCLdLVeq0lKY23zS9YEZZqtmRv5rbbvXG8bROOzt7d3sn2gjY2NGWlncyc55mEJ5+WMchOrdCOsSeeZF3bi6zkvUpWrO+qXhZ3YngZpA6sV9F54WrBkAUShddsfq00js81jnqh9q2E9jbtsdIKBgOlBVLvabqoOzJpkdmBtxMi7pmSyzRtosMzuPVjH/7lub7JynQo7sb3252Ekbi+azJHfVmtWe+a0mpdbW1tTx2xd0XNDq2aQEjphwunzQIxc6NX6S0C8fs6CE68eo5XMRM82Z+lszY7hcDiJHKoWinIPdgNJD9GzUhF9EWz+JOfQe4IqqtMLsef6wyadB5sDXAWjLGLCdYaBzp8/P2Nvl8B2tL3WWz6j/4Fy4CCHEvNZZrJMndOQCrvCwvbDyzFpe9oGr+aw7UeBh4ih2i66LEUy7RhGDyLq/8iPbINV+ECdYKBer5c0TA1MS2JvOYa3eJAZqUbieQEB7xifm0f6Wa0TMZ4yvdVQNZNG6/TW3tlE9Gg0mgntR3R7qGWknEbjoEfEOPOsLJkXJz6ReubMGQDX8wX6WwfYhlT5tx1ou3+cgh1tb7Vyyeyo0RpenQBcU8tb+gKMI468HCgHS6+nkex2ubxy2uuT1UbWx7Cmlr0m8sFYcPH4Ryup+ZGQLoSrI1RrIBG5AcAIwJdSSj8qIq8EcAnArQA+AeCfpJS+KSIvA/BeAK8F8HUA/yil9IVc3XfffXd68sknJxqHFz3ymrgIueXsNgxaWvxoTULWhjkThKH9sMtoomeE7K5CNdrRPs5hgxQ8ljknP4om2ogbM0akHTxtGS0lisw3r/4Iy2Kso9JAbwPwDP3/eQC/2Lze5EUAmqLeAvBiSulvAPjFplwW165dA3B9UnCEivdkzj1AxfDyBeyMchn7bfNQXpZeabPHeSJFzJPTLHaCetpAJ7K36psz/uwLlbSZPR8xU8m09RifE8gRLZx+aONr2TqPIxpXpYFE5LsBvAfAzwH4FwD+LoCvAvhrKaVvicgPAriQUnqLiPxu8/sPRORGAF8GcCZlGur1esk+NejZ78Cs5GVYJphXspW0GCcdI7OP/Rq72JTrtBqFo17Wp+M+RSalrbdNaLkGnhZi85OX+lhaahCZ5vOA68r1cxENVMtA7wfwbwG8AsBjAP4pgI82WgYicgeA304p/S0R+QyA+1NKzzXnPgfg9Smlr0X1axTOZsC9ieRNRkZ0PjeInjaxJkZu8gJxZM7S5ElrG2GqYZQI80zatvCigTq+vCsrMD12y2CKRcG0KlbKQCLyowAeTCn9cxF5I8YM9FYAf2AY6IMppdeIyNMA3mIY6HUppa+beh/B+A12ePnLX/7aN73pTa7ZYzURT7ya3AGXyYXGrfaLED02wfR5DGnzVVwu8l9Go9HMIlrLXDmhENHI9UWRx1xAhQWbhWcKdxVK/yIbK9Y8kfpDAH5MRB4E8FcAfAeAXwKwKSI3ppS+helXmOjrTZ5rTLibAbxgK+X3A21ubiZgNiLGE8Q+QJWDlXq8MtoyVLRFFdfD7XrRPS98bjWK1uGFqZkeC88P4nPeROeIo7dfAdNX8sdsIIHp8PrnfXtBh1VqyBxj58rMg1Z5INVATRTuNwF8IKV0SUQuAvhUSuk/isijAF6TUtoWkYcA/P2U0j/M1auLSaMcj50kpax0JP1qpGJbyekxaylaxxPRy3mpKdTvX19x7V2vyJmUOQaJFrxG/lMkICLT2htHrn8VKwxqoqy23Ko1UIR/BeCSiPwbAP8T43cIofn+NRF5FmPN81BthZGzrbA7zJTqYXiMYSNIGulry4Ascb1Fkjm/RaN83HdrXvFvjym8iW3psOV1LDUCxnRYk9LWbdv0EAkhpsXT+osy06o0TYROrEQ4depUOnPmTGjaAPEat0Vsbp4EXvbfu5EcJrZg/4bh+WSsrXgFgc0f8bGoD5H5yG2woLAMFsF7lNu2bfvnjc2y/aEorZBDbqnQid9cXl+wpYiYJydN7E0EZp9NsbDmBLdnzSYLZSS7BKk2dO6t9bL7KOTML29iR5E8PacmYS0Gg8GUD+UxkA3y1NSZG5N5TO/aUDz7wCx4TzwDaR4I8JmnRg3XSDgv4sTrshg25JyTcN4EKvkCWsYLcTN00nv0eEnMCG0ZSOvObX7Cmky1Zq0JVmIKq6ktouBOm7yW0rnIYtJO7AsH+GHU0Wj2jQ01iG6OSiBOXvIEyIWEvccQcqYQ32CPmSKBof1mE8xG+aIJ6jETZ/g9MzDyDUv/1V/0jtegZHrXBHvsf+5jDUO1TSJ76AQD6aYiwPQkaKOaWYvkBt8LU3vRLtu2x8i2Xb6WmZR9CZufYYde2+FgBjOU52zbaJtHt1014CU5edxKGocDHXqt/V/r8+SCMlymRpCyEPTSHst+tQnQEROOH6jjiVBjvtmbHd0Qnsg2iallcs56DrwBSul6u+uQXsc0eIGGnPax9XkTjiVyKQek5YD8Yt5Ii7RlIr6ubRTNCo6ob14flvGCrU4xEHeat67VQSw9Q6L/I3gmGNerbc0TRrVRMK3Xy9lEDKSIGMibLNx+VLeloVYS61i3dfr53Lx5Nf0N1GmgtveMx+TEBxEiBooQJVtZY3mSLDJzbNl5t3vVJ0Dnsa29CRBF47yQde0EYqER0cFRTGB2JXuEeaJoy87TzCP8HnjggZPPQB/5yEcm/635FklahmUqK8VK0SpvFcC8aBMqVkTt5VY2RL9LsIImt7IhmuDWJOTy3r2IzLxlIDJro3MWizBQJ55IVXhM4UWp9Ns65m1vipdgBBZzNudlQG0/ct75XE2AJXeeNexgMJjaXbRW+3J0kNu0Y+clkZetdbzx4Hu7SnQiCnf69GkAvpbIaQy98SxRo2U1FvMO7mg0vRG61YYcfvdWFMyTlfeSokqLjcLV9s8GHbgtrTPSJvqboQyVCx/XRtPmQU2YfxXoBAMpvBsa7bjJNyIKMdesx4oYNLf9VInBOfSsTGT3RMjBalTbPzabciH0trDMaMev9F9hmUnr5jZWoYVyQZVVoTMmXC70aE2YtrH90gB6EyGXVM35DF49NWaRx9SWLtuOagsvAlgCMwvndUrmoU0MMy2ctLVlrZZUobLMNXKMSMAsm5k6pYGAvETn7L1lJi+EC/h+VE2bety7tibHwHSMRqNJPiVieEt7SVNFObJ5JK71fTj87jGtbS/aD1vBAQtvYnuP7relvxbzREhz6IwG4sQmS8SawVlEyuTKtjG7SnXrxF70jWiA70ss0/7nN1vnghvq50Wa0lu46Wkw1k78Frla7ZS7P6v2hzqngYDpJyoB/+Ew77wHT0MdF7R9u/kGn1fw5I18EsUiQseOra3DRtAsHVFo2hM+rGWZ8XgViF2Jsah2WrbGseiEBtJtrRQ2wsWb7HmoyaFE4eESaiKCufORuVd6XKLkh3iw0bk2AQsec2sG68TWT+SjcRmt00s3lMxCPaYaTt9SmEMtoyxbgHaCgSIwA9T4IoC/pGYRaBSwRnvlznM/lMbal9xaZojWi3nBjRqm9/wu66OohvN8tWVJ+SjMHfXd88d4bzxPkCxbI3VmJcJTTz3lvk/ekloAAAxQSURBVGmgdjmLva4G6nOVBrX0gi9bp1fO2/De0l2zvEb/A7NrBBm2Lb4uR7dHF1D3eEHtIwht18Z5sOZftIYuqouZ9bj2RFgaNJEKzC63r5HqOURSmJ3WWtRMxEhbWf/AJkZ1HZ1OBFuHF+bWsl6b1i8qIRfFjMAMXOOHcn1tFopGdUah86hOz5dbNB/VCQbywGZJNCnZxm6rmtuUr30qNgcberfhdd6Fx9MAXgCFNY83ea2DH9VntU4Uko58F09Y1DCe/d0W0bVeAtoymj0+LzrnA0V+TXTDS1iGzTtv9C4Kr2s4m9/KxgET72lVL+/Fx0v0s7TWY55P44WkWUjVtJdb97aqpTwlcAjdfhZBJxjo2rVr2QRirRl3VCHqWqbMPZIBXI9ueeHrKErX1uywzr7mVywz8bFcglaf+ixFCW04+jjTB6tEJxgImF3EqChJ2mUmEHMotc/IRQytU8/mDptmwPVEJW+XpZOdV1FHyK3l87SSwmMk3tzf5uRKbbfxxU4aqhhIRDZF5P0i8r9E5BkR+UERuVVEPiQin22+b2nKiog8JSLPisinROSeZRA6j6apDX3X1DOPFO33+8XVDCwwOLzNZqOdtLau0Wh285XBYFAMkLBW8mC1iNJbggpDj0FXtfbtuFAbRPhlAL+TUvoHInIKwGkAPwPgwymlJ0XkcQCPY7xb6QMA7mw+rwcwbL6LiHyGyAdpM6G9CNMigQebJKxpW2GDIspo3saMlnEtU+kxnZi6+rsmPB/1jdvKmYylCKfVtpGfZZGLpHUNRQYSke8A8CMYv9IEKaVvAvimiJwD8Mam2HsA/D7GDHQOwHub9wF9tNFet6eUno/aODw8dM03RWmSRhN02UnVaMLMG2SwIXu78Yn+txrCaiwdtxqN5/WJ6bH01dY1TyQ0go6Lx0S5fOBxoEYDfR/GL9P6TyLydwB8HOO31X2XMkVK6XkRua0p3wPwRbr+uebYFAPx601uvvnmqa2tGG0mZ5vIFNDenPA0Q6ktG463tNr/Xn02N6QTS5lOTTjvrdwWi2rhmjqXgUWZl4XxKuhT1DDQjQDuAfDTKaWPicgvY2yuRRDn2MxyB/t6k2hCLRt2MNsMLptZ1jHOmZm1ARAvmclBA/ZrdHKwc891RljFRGpTpzXrllGvZybWJINLifoa1AQRngPwXErpY83/92PMUF8RkdsBoPm+SuXvoOv53UGtkTMxIkSmSOlcmzqZvjYassastAlXLcv+kF3u34aO40atpVBKX5TMOc51ebCrvedBUQOllL4sIl8UkVellK4AuA/AHzWfhwE82Xxfbi7ZA/BTInIJ4+DBn+X8nxzm9S2Wibb+l4ft7e2pzRdt/Tag4MFbDaGJVzXhVrHz5rLRJvgCxMzmabGaSCe/9HgZqI3C/TSA9zURuM9j/IrHbwPwGyKyBeBPAfxEU/aDAB4E8CyAa03ZpWKZNq3dSxmYvTnclveGuZyJpuf5BuZMh1y/7DUaYGBzrm307bjQVjjmAjh6Puo/ayEvN7a3t9eG9ClUMVBK6ZMAvN7e55RNAB6dmyLECzJzaCvZgGnn3KNB643os+dLgQL1Zbz+Mf01Pprd/cYmn08KEwHt83o5RgLygiRK2M+LzqxEKKGWoeygRbv6ROBJXGKeNueA/HM7NfCezuQggvWJuopaPzSXf/L6Z/NM3koNa00savZ2loHahqSPss3ooa4aWjU77zGbMq1n1+c0DGu1kwpPYJWSqZ455kXfeONIy3xHEYU7MtiJEE0mIF617dXpQcPDXFcuYhO1WWsGlCJGbaON9n2xPHYnnZEYHMK30H0UopcGcDmFt85yEXSKgRiej1HLNKVznP0v1RFh3jVdkSapYVw7iWzup7QHxEmBCoFoVx8GaxmvDotlr8XrHAN5DFOTL/DCwDWDNa8j2fa6nFTMBTHseTsxvGU+XfZ/2iDyTyKNVPJ5autpg84wkN743ANdNfB8Aw+LSKIcM3jngXLiLzoX7bnG37ZM9PrIkwgVGN798hhAH/OwdXjXRo9ztEFnGMhinpvPk7RtaLotPcs2BSJ6o01V7MptS09p26yThtEofuzCg/WNSkJvXnSCgXQhKdu9bRBFcJaBaH0bo5bmiMacsLD5Hg6sREzk+UQvFbQNPXMEbhV+YScYSGGffamJKEWmz6KTJzfoNTei5NfU1FcTTrda1eaCaveeO2los/XvMnydCJ1iIF3hXDvRIuapWVqTq8dOyhpGrH1ita0paHe40Uy6ausovGv9q5ciE6lZV8NI+/v72Rcmz4tOMRBjnvB0bb25jH0pl+Il6trQNQ/tNjDC0FyIhRd8eKn5RYoaRuL1gjyGizJUZxjI8weWmTUuXbuonRztZNOWjoi23LURE3lvCe8CEy3DtPY+DI+ZrCDyInZt0ZmNFXNbKbVBW39CTaHctrpeHdHmgcyE0aJYzywr7QMQmYgcjvVo8q6L3g5xVPA2efR2DI1WEOSQ25prFeiMBvJQWpqf83lWHX2KtoOySU8PucBHhNolOl4dnnDY3d09lgid5q2s5lAhYJmmbQBglQEDD51goMPDQ/d4rVlUC54wnF+psZ0X9bvs/2hNVpQwzEEnTa4fHhPN8zbxGpTMLO0PT/Zl7hZaom2Z6IQJp3mgRWP1JZOv7ULLEnMtC7kJw2MSmXh2waW3kw/gj48+0brMp1lzY8y05bT1qqKGpQhsW3RCA+VQE0hoM8lry9YO7DIYLFdHm1A6X1PalZSxqjC3F+GsZVR+1eMqX0j8konCWbQZrNqtY+eVNrWDXDKjcrTUOL8RHV4QxGOiHG2rYCJL76KmmWpK+2EsK2pbi04xUC7fsez6gXiwVzHwVvLnmHIePyhq0/oUdrkPY9UJ11VtesLMNE/kdhF0ioHaYFmRt5J2WWbm2vp4yxQS1jyyuaOIiSJzbtmT8KhWQgyHQ2xtbU2+V41OvOJRRP4cwJXjpiPAdwL42nETEWBN23ywtH1PSunMPBV1IgoH4Mq876hcNURktKatPf6y0HZiTbg11ugC1gy0xhoLoCsM9K7jJiCDNW3z4S8FbZ0IIqyxxklFVzTQGmucSKwZaI01FsCxM5CI3C8iV5qXEude3LWKtu8Qkd9rXpz8tIi8rTl+QUS+JCKfbD4P0jX/uqH1ioi8ZcX0fUFEPt3QMGqOHenLnQO6XkVj80kR+YaIvP24xk1E3i0iV0XkM3Ss9TiJyMNN+c+KyMNVjaeUju0D4AYAn8P4NZKnAPwhgFcfYfu3A7in+f0KAH8M4NUALgB4zCn/6obGlwF4ZUP7DSuk7wsAvtMc+3cAHm9+Pw7g55vfDwL4bYzfEPgGAB87wnv4ZQDfc1zjhvE7fO8B8Jl5xwnArRi/uudWALc0v28ptX3cGuh1AJ5NKX0+jV9efAnjlxQfCVJKz6eUPtH8/nMAz2D8PtcI5wBcSin9n5TS/8b4HUivWz2lMzS8p/n9HgB/j46/N43xUQCb+gbBFeM+AJ9LKf1JpsxKxy2l9F8BvOC02Wac3gLgQymlF1JKLwL4EID7S20fNwNFLyQ+cojI9wL4AQD6KsufalT8u1X94+jpTQD+i4h8vHkpM2Be7gyg9HLnVeMhAL9O/7swbkD7cZqLxuNmoKoXEq+cCJFvB/ABAG9PKX0DwBDA9wO4G+O3i/97Lepcvkp6fyildA+ABwA8KiI/kil75GPZvLHwxwD8ZnOoK+OWQ0TLXDQeNwMt9YXE80BEbsKYed6XUvotAEgpfSWl9P9SSn8B4Fdx3dw4UnpTSgfN91UA/7mh40he7lyJBwB8IqX0lYbOToxbg7bjNBeNx81A+wDuFJFXNtLsIYxfUnwkEBEBsAvgmZTSL9Bx9h1+HIBGd/YAPCQiLxORVwK4E8D/WBFtGyLyCv0N4M0NHXsYv9QZmH258/kmyvQGLPBy5xb4SZD51oVxI7Qdp98F8GYRuaUxPd/cHMvjKCI1hQjKgxhHvz4H4GePuO0fxlhNfwrAJ5vPgwB+DcCnm+N7AG6na362ofUKgAdWSNv3YRy5+kMAT+vYAPirAD4M4LPN963NcQHwHxraPg2gv+KxOw3g6wBupmPHMm4YM/HzAP4vxppka55xAvDPMA5wPAvgrTVtr5fyrLHGAjhuE26NNU401gy0xhoLYM1Aa6yxANYMtMYaC2DNQGussQDWDLTGGgtgzUBrrLEA/j98bOCC4H3LrQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 216x158.4 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x158.4 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# A more complex example\n",
    "import numpy as np\n",
    "import scipy as sp\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from sklearn import cluster\n",
    "\n",
    "\n",
    "try:  # SciPy >= 0.16 have face in misc\n",
    "    from scipy.misc import face\n",
    "    face = face(gray=True)\n",
    "except ImportError:\n",
    "    face = sp.face(gray=True)\n",
    "\n",
    "n_clusters = 5\n",
    "np.random.seed(0)\n",
    "\n",
    "X = face.reshape((-1, 1))  # We need an (n_sample, n_feature) array\n",
    "k_means = cluster.KMeans(n_clusters=n_clusters, n_init=4)\n",
    "k_means.fit(X)\n",
    "values = k_means.cluster_centers_.squeeze()\n",
    "labels = k_means.labels_\n",
    "\n",
    "# create an array from labels and values\n",
    "face_compressed = np.choose(labels, values)\n",
    "face_compressed.shape = face.shape\n",
    "\n",
    "vmin = face.min()\n",
    "vmax = face.max()\n",
    "\n",
    "# original face\n",
    "plt.figure(1, figsize=(3, 2.2))\n",
    "plt.imshow(face, cmap=plt.cm.gray, vmin=vmin, vmax=256)\n",
    "\n",
    "# compressed face\n",
    "plt.figure(2, figsize=(3, 2.2))\n",
    "plt.imshow(face_compressed, cmap=plt.cm.gray, vmin=vmin, vmax=vmax)\n",
    "\n",
    "# equal bins face\n",
    "regular_values = np.linspace(0, 256, n_clusters + 1)\n",
    "regular_labels = np.searchsorted(regular_values, face) - 1\n",
    "regular_values = .5 * (regular_values[1:] + regular_values[:-1])  # mean\n",
    "regular_face = np.choose(regular_labels.ravel(), regular_values, mode=\"clip\")\n",
    "regular_face.shape = face.shape\n",
    "plt.figure(3, figsize=(3, 2.2))\n",
    "plt.imshow(regular_face, cmap=plt.cm.gray, vmin=vmin, vmax=vmax)\n",
    "\n",
    "# histogram\n",
    "plt.figure(4, figsize=(3, 2.2))\n",
    "plt.clf()\n",
    "plt.axes([.01, .01, .98, .98])\n",
    "plt.hist(X, bins=256, color='.5', edgecolor='.5')\n",
    "plt.yticks(())\n",
    "plt.xticks(regular_values)\n",
    "values = np.sort(values)\n",
    "for center_1, center_2 in zip(values[:-1], values[1:]):\n",
    "    plt.axvline(.5 * (center_1 + center_2), color='b')\n",
    "\n",
    "for center_1, center_2 in zip(regular_values[:-1], regular_values[1:]):\n",
    "    plt.axvline(.5 * (center_1 + center_2), color='b', linestyle='--')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "## 3.2 Array Shape Manipulation\n",
    "\n",
    "### Flattening"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nA 1-D array, containing the elements of the input, is returned.  A copy is\\n    made only if needed.\\n    Do help(np.ravel) to learn more\\n'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "a.ravel() \n",
    "\"\"\"\n",
    "A 1-D array, containing the elements of the input, is returned.  A copy is\n",
    "    made only if needed.\n",
    "    Do help(np.ravel) to learn more\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 4],\n",
       "       [2, 5],\n",
       "       [3, 6]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "###  Reshaping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.reshape(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = a.ravel()\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = b.reshape((2, 3))\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Which is same as ...\n",
    "a.reshape(2, -1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[99,  2,  3],\n",
       "       [ 4,  5,  6]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Note:  ndarray.reshape may return a view (cf help(np.reshape))), or copy\n",
    "b[0, 0] = 99\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.]])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Reshape also returns a copy, take a look\n",
    "a = np.zeros((3, 2))\n",
    "b = a.T.reshape(3 * 2)\n",
    "b [0] = 9\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Memory layout of a numpy array\n",
    "\n",
    "- [Here's a good example of how it works](https://eli.thegreenplace.net/2015/memory-layout-of-multi-dimensional-arrays/)\n",
    "- "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<memory at 0x7faf84de2ee0>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.random.rand(2, 2)\n",
    "x.data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(140391821883968, False)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.__array_interface__['data']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(140391821883968, False)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[0].__array_interface__['data']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(140391821883968, False)"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[0,:].__array_interface__['data']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(140391821883984, False)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[1,:].__array_interface__['data']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(140391740312704, False)"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[0,0].__array_interface__['data']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "## 3.3 Sorting Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Function*\n",
    "\n",
    "`sort (arr, axis=-1, kind='quick', order=None)`\n",
    "\n",
    "*Method*\n",
    "\n",
    "`arr.sort (axis=-1, kind='quick', order=None)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 3 4]\n",
      " [1 3 3]]\n"
     ]
    }
   ],
   "source": [
    "# Sorting along an axis. see what happens?\n",
    "a = np.array([[1, 4, 3], [3, 1, 3]])\n",
    "b = np.sort(a, axis=1)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 3 4]\n",
      " [1 3 3]]\n"
     ]
    }
   ],
   "source": [
    "# In-place sort\n",
    "a.sort(axis=1)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 1, 0, 2])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Sorting with fancy indexing\n",
    "a = np.array([5, 4, 6, 1])\n",
    "x = np.argsort(a)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "# Finding minima and maxima\n",
    "b = np.array([3,5,2,6])\n",
    "b_max = np.argmax(b)\n",
    "b_min = np.argmin(b)\n",
    "print(b_max)\n",
    "print(b_min)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Some Exercises  😅\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1. Array manipulations\n",
    "\n",
    "Create this 2D array (without typing manually)\n",
    "\n",
    "`\n",
    "[[1,  7, 12],\n",
    " [2,  8, 13],\n",
    " [3,  9, 14],\n",
    " [4, 10, 15],\n",
    " [5, 11, 16]]\n",
    "`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "#### Fun Exercises: Challenge questions\n",
    "\n",
    "1. Try in-place, out_of_place sorting\n",
    "2. Create arrays with different dtypes and sort them.\n",
    "3. Use all or array_equal to see what it returns\n",
    "4. Use np.random.shuffle to create a more sortable input\n",
    "5. Combine ravel, sort and reshape in one\n",
    "6. Look at the `axis` keyword for `sort` and rewrite the previous exercise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4],\n",
       "       [ 5,  6,  7,  8,  9],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [15, 16, 17, 18, 19],\n",
       "       [20, 21, 22, 23, 24]])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(25).reshape(5, 5)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function sum in module numpy:\n",
      "\n",
      "sum(a, axis=None, dtype=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)\n",
      "    Sum of array elements over a given axis.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    a : array_like\n",
      "        Elements to sum.\n",
      "    axis : None or int or tuple of ints, optional\n",
      "        Axis or axes along which a sum is performed.  The default,\n",
      "        axis=None, will sum all of the elements of the input array.  If\n",
      "        axis is negative it counts from the last to the first axis.\n",
      "    \n",
      "        .. versionadded:: 1.7.0\n",
      "    \n",
      "        If axis is a tuple of ints, a sum is performed on all of the axes\n",
      "        specified in the tuple instead of a single axis or all the axes as\n",
      "        before.\n",
      "    dtype : dtype, optional\n",
      "        The type of the returned array and of the accumulator in which the\n",
      "        elements are summed.  The dtype of `a` is used by default unless `a`\n",
      "        has an integer dtype of less precision than the default platform\n",
      "        integer.  In that case, if `a` is signed then the platform integer\n",
      "        is used while if `a` is unsigned then an unsigned integer of the\n",
      "        same precision as the platform integer is used.\n",
      "    out : ndarray, optional\n",
      "        Alternative output array in which to place the result. It must have\n",
      "        the same shape as the expected output, but the type of the output\n",
      "        values will be cast if necessary.\n",
      "    keepdims : bool, optional\n",
      "        If this is set to True, the axes which are reduced are left\n",
      "        in the result as dimensions with size one. With this option,\n",
      "        the result will broadcast correctly against the input array.\n",
      "    \n",
      "        If the default value is passed, then `keepdims` will not be\n",
      "        passed through to the `sum` method of sub-classes of\n",
      "        `ndarray`, however any non-default value will be.  If the\n",
      "        sub-class' method does not implement `keepdims` any\n",
      "        exceptions will be raised.\n",
      "    initial : scalar, optional\n",
      "        Starting value for the sum. See `~numpy.ufunc.reduce` for details.\n",
      "    \n",
      "        .. versionadded:: 1.15.0\n",
      "    \n",
      "    where : array_like of bool, optional\n",
      "        Elements to include in the sum. See `~numpy.ufunc.reduce` for details.\n",
      "    \n",
      "        .. versionadded:: 1.17.0\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    sum_along_axis : ndarray\n",
      "        An array with the same shape as `a`, with the specified\n",
      "        axis removed.   If `a` is a 0-d array, or if `axis` is None, a scalar\n",
      "        is returned.  If an output array is specified, a reference to\n",
      "        `out` is returned.\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    ndarray.sum : Equivalent method.\n",
      "    \n",
      "    add.reduce : Equivalent functionality of `add`.\n",
      "    \n",
      "    cumsum : Cumulative sum of array elements.\n",
      "    \n",
      "    trapz : Integration of array values using the composite trapezoidal rule.\n",
      "    \n",
      "    mean, average\n",
      "    \n",
      "    Notes\n",
      "    -----\n",
      "    Arithmetic is modular when using integer types, and no error is\n",
      "    raised on overflow.\n",
      "    \n",
      "    The sum of an empty array is the neutral element 0:\n",
      "    \n",
      "    >>> np.sum([])\n",
      "    0.0\n",
      "    \n",
      "    For floating point numbers the numerical precision of sum (and\n",
      "    ``np.add.reduce``) is in general limited by directly adding each number\n",
      "    individually to the result causing rounding errors in every step.\n",
      "    However, often numpy will use a  numerically better approach (partial\n",
      "    pairwise summation) leading to improved precision in many use-cases.\n",
      "    This improved precision is always provided when no ``axis`` is given.\n",
      "    When ``axis`` is given, it will depend on which axis is summed.\n",
      "    Technically, to provide the best speed possible, the improved precision\n",
      "    is only used when the summation is along the fast axis in memory.\n",
      "    Note that the exact precision may vary depending on other parameters.\n",
      "    In contrast to NumPy, Python's ``math.fsum`` function uses a slower but\n",
      "    more precise approach to summation.\n",
      "    Especially when summing a large number of lower precision floating point\n",
      "    numbers, such as ``float32``, numerical errors can become significant.\n",
      "    In such cases it can be advisable to use `dtype=\"float64\"` to use a higher\n",
      "    precision for the output.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> np.sum([0.5, 1.5])\n",
      "    2.0\n",
      "    >>> np.sum([0.5, 0.7, 0.2, 1.5], dtype=np.int32)\n",
      "    1\n",
      "    >>> np.sum([[0, 1], [0, 5]])\n",
      "    6\n",
      "    >>> np.sum([[0, 1], [0, 5]], axis=0)\n",
      "    array([0, 6])\n",
      "    >>> np.sum([[0, 1], [0, 5]], axis=1)\n",
      "    array([1, 5])\n",
      "    >>> np.sum([[0, 1], [np.nan, 5]], where=[False, True], axis=1)\n",
      "    array([1., 5.])\n",
      "    \n",
      "    If the accumulator is too small, overflow occurs:\n",
      "    \n",
      "    >>> np.ones(128, dtype=np.int8).sum(dtype=np.int8)\n",
      "    -128\n",
      "    \n",
      "    You can also start the sum with a value other than zero:\n",
      "    \n",
      "    >>> np.sum([10], initial=5)\n",
      "    15\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(np.sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function sum in module numpy.matrixlib.defmatrix:\n",
      "\n",
      "sum(self, axis=None, dtype=None, out=None)\n",
      "    Returns the sum of the matrix elements, along the given axis.\n",
      "    \n",
      "    Refer to `numpy.sum` for full documentation.\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    numpy.sum\n",
      "    \n",
      "    Notes\n",
      "    -----\n",
      "    This is the same as `ndarray.sum`, except that where an `ndarray` would\n",
      "    be returned, a `matrix` object is returned instead.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> x = np.matrix([[1, 2], [4, 3]])\n",
      "    >>> x.sum()\n",
      "    10\n",
      "    >>> x.sum(axis=1)\n",
      "    matrix([[3],\n",
      "            [7]])\n",
      "    >>> x.sum(axis=1, dtype='float')\n",
      "    matrix([[3.],\n",
      "            [7.]])\n",
      "    >>> out = np.zeros((2, 1), dtype='float')\n",
      "    >>> x.sum(axis=1, dtype='float', out=np.asmatrix(out))\n",
      "    matrix([[3.],\n",
      "            [7.]])\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(np.matrix.sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.5"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum([1.0, 1.5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum([1.0, 0.4, 0.5, 0.6], dtype=np.int32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum([[0, 2], [0, 6]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 8])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum([[0, 2], [0, 6]], axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 6])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum([[0, 2], [0, 6]], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_code_all_hidden": false,
  "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}