8. Fancy indexing and index tricks.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Fancy indexing and index tricks\n",
    "NumPy offers more indexing facilities than regular Python sequences. In addition to indexing by integers and slices, as we saw before, arrays can be indexed by arrays of integers and arrays of booleans.\n",
    "\n",
    "##### Indexing with Arrays of Indices¶"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1  1  9 64 25 36] # the elements of a at the positions i\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(12)**2                    # the first 12 square numbers\n",
    "i = np.array( [ 1,1,3,8,5,6 ] )              # an array of indices\n",
    "print(a[i] ,\"# the elements of a at the positions i\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 9, 16],\n",
       "       [81, 49]], dtype=int32)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "j = np.array( [ [ 3, 4], [ 9, 7 ] ] )      # a bidimensional array of indices\n",
    "a[j]                                       # the same shape as j"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When the indexed array a is multidimensional, a single array of indices refers to the first dimension of a. The following example shows this behavior by converting an image of labels into a color image using a palette."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "palette = np.array( [ [0,0,0],                # black\n",
    "                     [255,0,0],              # red\n",
    "                     [0,255,0],              # green\n",
    "                     [0,0,255],              # blue\n",
    "                     [255,255,255] ] )       # white"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  0,   0,   0],\n",
       "       [255,   0,   0],\n",
       "       [  0, 255,   0],\n",
       "       [  0,   0, 255],\n",
       "       [255, 255, 255]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "palette"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x1bf5ab9ec88>"
      ]
     },
     "execution_count": 6,
     "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": [
    "import matplotlib.pyplot as plt\n",
    "plt.imshow(palette)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 6 2 8]\n",
      " [5 3 4 0]]\n"
     ]
    }
   ],
   "source": [
    "image = np.array( [ [ 0, 6, 2, 8 ],           # each value corresponds to a color in the palette\n",
    "...                     [ 5, 3, 4, 0 ]  ] )\n",
    "print(image)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x1bf5ad5a160>"
      ]
     },
     "execution_count": 16,
     "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": [
    "import matplotlib.pyplot as plt\n",
    "plt.imshow(image)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[  0,   0,   0],\n",
       "        [255,   0,   0],\n",
       "        [  0, 255,   0],\n",
       "        [  0,   0,   0]],\n",
       "\n",
       "       [[  0,   0,   0],\n",
       "        [  0,   0, 255],\n",
       "        [255, 255, 255],\n",
       "        [  0,   0,   0]]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "palette[image]                            # the (2,4,3) color image"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also give indexes for more than one dimension. The arrays of indices for each dimension must have the same shape."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(12).reshape(3,4);a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1],\n",
       "       [1, 2]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "i = np.array( [ [0,1],                        # indices for the first dim of a\n",
    "...                 [1,2] ] )\n",
    "i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 1],\n",
       "       [3, 3]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "j = np.array( [ [2,1],                        # indices for the second dim\n",
    "...                 [3,3] ] )\n",
    "j"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  5],\n",
       "       [ 7, 11]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[i,j]                                     # i and j must have equal shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  6],\n",
       "       [ 6, 10]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[i,2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 2,  1],\n",
       "        [ 3,  3]],\n",
       "\n",
       "       [[ 6,  5],\n",
       "        [ 7,  7]],\n",
       "\n",
       "       [[10,  9],\n",
       "        [11, 11]]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[:,j]                                     # i.e., a[ : , j]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Naturally, we can put i and j in a sequence (say a list) and then do the indexing with the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([[0, 1],\n",
       "        [1, 2]]), array([[2, 1],\n",
       "        [3, 3]])]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = [i,j]\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\kumar\\appdata\\local\\programs\\python\\python36\\lib\\site-packages\\ipykernel_launcher.py:1: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 2,  5],\n",
       "       [ 7, 11]])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[l] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 0, 3, 1], dtype=int64)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "time = np.linspace(20, 145, 5)                 # time scale\n",
    "data = np.sin(np.arange(20)).reshape(5,4)      # 4 time-dependent series\n",
    "ind = data.argmax(axis=0)                  # index of the maxima for each series\n",
    "ind"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 82.5 ,  20.  , 113.75,  51.25])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "time_max = time[ind]                       # times corresponding to the maxima\n",
    "time_max"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4]\n",
      "[0 0 2 0 0]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(5)\n",
    "print(a)\n",
    "a[[1,3,4]] = 0 \n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexing with Boolean Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we index arrays with arrays of (integer) indices we are providing the list of indices to pick. With boolean indices the approach is different; we explicitly choose which items in the array we want and which ones we don’t.\n",
    "\n",
    "The most natural way one can think of for boolean indexing is to use boolean arrays that have the same shape as the original array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False, False],\n",
       "       [False,  True,  True,  True],\n",
       "       [ True,  True,  True,  True]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(12).reshape(3,4)\n",
    "b = a > 4\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5,  6,  7,  8,  9, 10, 11])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[b]  # 1d array with the selected elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The ix_() function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The ix_ function can be used to combine different vectors so as to obtain the result for each n-uplet. For example, if you want to compute all the a+b*c for all the triplets taken from each of the vectors a, b and c:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[2]]\n",
      "\n",
      " [[3]]\n",
      "\n",
      " [[4]]\n",
      "\n",
      " [[5]]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([2,3,4,5])\n",
    "b = np.array([8,5,4])\n",
    "c = np.array([5,4,6,8,3])\n",
    "ax,bx,cx = np.ix_(a,b,c)\n",
    "print(ax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[5, 4, 6, 8, 3]]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[8],\n",
       "        [5],\n",
       "        [4]]])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((4, 1, 1), (1, 3, 1), (1, 1, 5))"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ax.shape, bx.shape, cx.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[42, 34, 50, 66, 26],\n",
       "        [27, 22, 32, 42, 17],\n",
       "        [22, 18, 26, 34, 14]],\n",
       "\n",
       "       [[43, 35, 51, 67, 27],\n",
       "        [28, 23, 33, 43, 18],\n",
       "        [23, 19, 27, 35, 15]],\n",
       "\n",
       "       [[44, 36, 52, 68, 28],\n",
       "        [29, 24, 34, 44, 19],\n",
       "        [24, 20, 28, 36, 16]],\n",
       "\n",
       "       [[45, 37, 53, 69, 29],\n",
       "        [30, 25, 35, 45, 20],\n",
       "        [25, 21, 29, 37, 17]]])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = ax+bx*cx\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result[3,2,4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[3]+b[2]*c[4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You could also implement the reduce as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ufunc_reduce(ufct, *vectors):\n",
    "...    vs = np.ix_(*vectors)\n",
    "...    r = ufct.identity\n",
    "...    for v in vs:\n",
    "...        r = ufct(r,v)\n",
    "...    return r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[15, 14, 16, 18, 13],\n",
       "        [12, 11, 13, 15, 10],\n",
       "        [11, 10, 12, 14,  9]],\n",
       "\n",
       "       [[16, 15, 17, 19, 14],\n",
       "        [13, 12, 14, 16, 11],\n",
       "        [12, 11, 13, 15, 10]],\n",
       "\n",
       "       [[17, 16, 18, 20, 15],\n",
       "        [14, 13, 15, 17, 12],\n",
       "        [13, 12, 14, 16, 11]],\n",
       "\n",
       "       [[18, 17, 19, 21, 16],\n",
       "        [15, 14, 16, 18, 13],\n",
       "        [14, 13, 15, 17, 12]]])"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ufunc_reduce(np.add,a,b,c)"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}