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": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1  1  9 64 25] # 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 ] )              # an array of indices\n",
    "print(a[i] ,\"# the elements of a at the positions i\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 9, 16],\n",
       "       [81, 49]], dtype=int32)"
      ]
     },
     "execution_count": 10,
     "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": 11,
   "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": 13,
   "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": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "palette"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2 0]\n",
      " [0 3 4 0]]\n"
     ]
    }
   ],
   "source": [
    "image = np.array( [ [ 0, 1, 2, 0 ],           # each value corresponds to a color in the palette\n",
    "...                     [ 0, 3, 4, 0 ]  ] )\n",
    "print(image)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "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": 18,
     "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": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11]])"
      ]
     },
     "execution_count": 21,
     "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": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 0, 3, 1], dtype=int64)"
      ]
     },
     "execution_count": 46,
     "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": 54,
   "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": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False, False],\n",
       "       [False,  True,  True,  True],\n",
       "       [ True,  True,  True,  True]])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(12).reshape(3,4)\n",
    "b = a > 4\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5,  6,  7,  8,  9, 10, 11])"
      ]
     },
     "execution_count": 60,
     "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": 69,
   "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": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[5, 4, 6, 8, 3]]])"
      ]
     },
     "execution_count": 71,
     "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": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((4, 1, 1), (1, 3, 1), (1, 1, 5))"
      ]
     },
     "execution_count": 75,
     "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
}