extra-material/indexing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "source": [
    "# A possibly incomplete Demo of all the combinations of indexing methods\n",
    "... and interesting cases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T16:30:25.759Z",
     "iopub.status.busy": "2021-08-23T16:30:25.741Z",
     "iopub.status.idle": "2021-08-23T16:30:25.840Z",
     "shell.execute_reply": "2021-08-23T16:30:25.859Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "source": [
    "# 1d Array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T16:30:26.147Z",
     "iopub.status.busy": "2021-08-23T16:30:26.132Z",
     "iopub.status.idle": "2021-08-23T16:30:26.176Z",
     "shell.execute_reply": "2021-08-23T16:30:26.190Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['A', 'B', 'C', 'D', 'E', 'F', 'H', 'I', 'J', 'K', 'L', 'M', 'N',\n",
       "       'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'],\n",
       "      dtype='<U1')"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array(list(\"ABCDEFHIJKLMNOPQRSTUVWXYZ\"))\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "source": [
    "### \\[int]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T16:30:26.550Z",
     "iopub.status.busy": "2021-08-23T16:30:26.533Z",
     "iopub.status.idle": "2021-08-23T16:30:26.579Z",
     "shell.execute_reply": "2021-08-23T16:30:26.591Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'K'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[9]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "source": [
    "### \\[slice]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T16:30:27.051Z",
     "iopub.status.busy": "2021-08-23T16:30:27.033Z",
     "iopub.status.idle": "2021-08-23T16:30:27.084Z",
     "shell.execute_reply": "2021-08-23T16:30:27.099Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['C', 'F', 'J', 'M', 'P', 'S', 'V', 'Y'], dtype='<U1')"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[2::3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "source": [
    "### \\[array]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T16:30:27.838Z",
     "iopub.status.busy": "2021-08-23T16:30:27.821Z",
     "iopub.status.idle": "2021-08-23T16:30:27.868Z",
     "shell.execute_reply": "2021-08-23T16:30:27.884Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['B', 'C', 'D'], dtype='<U1')"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[[1,2,3]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "source": [
    "# 2D Array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T16:30:28.669Z",
     "iopub.status.busy": "2021-08-23T16:30:28.653Z",
     "iopub.status.idle": "2021-08-23T16:30:28.701Z",
     "shell.execute_reply": "2021-08-23T16:30:28.715Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([['A', 'B', 'C', 'D', 'E', 'F'],\n",
       "       ['G', 'H', 'I', 'J', 'K', 'L'],\n",
       "       ['M', 'N', 'O', 'P', 'Q', 'R'],\n",
       "       ['S', 'T', 'U', 'V', 'W', 'X'],\n",
       "       ['Y', 'Z', '0', '1', '2', '3'],\n",
       "       ['4', '5', '6', '7', '8', '9']], dtype='<U1')"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array(list(\"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\")).reshape(6,6)\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "source": [
    "### Field access Indexing \\[int\\]\\[int\\]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T16:30:30.021Z",
     "iopub.status.busy": "2021-08-23T16:30:30.001Z",
     "iopub.status.idle": "2021-08-23T16:30:30.054Z",
     "shell.execute_reply": "2021-08-23T16:30:30.069Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'W'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[3][4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "source": [
    "### Regular Indexing \\[int, int\\]\n",
    "usually you index within one square bracket"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T16:30:31.983Z",
     "iopub.status.busy": "2021-08-23T16:30:31.965Z",
     "iopub.status.idle": "2021-08-23T16:30:32.013Z",
     "shell.execute_reply": "2021-08-23T16:30:32.028Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'W'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[3, 4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "source": [
    "Behind the scenes, the comma causes the indexes to be interpreted as a tuple, so explicitely indexing with tuples also works!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T16:31:58.257Z",
     "iopub.status.busy": "2021-08-23T16:31:58.241Z",
     "iopub.status.idle": "2021-08-23T16:31:58.288Z",
     "shell.execute_reply": "2021-08-23T16:31:58.303Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'W'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[(3, 4)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "source": [
    "### Mixing and matching \\[int, slice], \\[slice, int], \\[int, array], \\[array, int]\n",
    "When one index refers to multiple elements and the other does not, the int dimension gets eaten! You end up with a 1D array of the lenth of the multi-element index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T16:36:55.259Z",
     "iopub.status.busy": "2021-08-23T16:36:55.245Z",
     "iopub.status.idle": "2021-08-23T16:36:55.290Z",
     "shell.execute_reply": "2021-08-23T16:36:55.307Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['S', 'U', 'W'], dtype='<U1')"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[3, ::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T16:36:55.707Z",
     "iopub.status.busy": "2021-08-23T16:36:55.690Z",
     "iopub.status.idle": "2021-08-23T16:36:55.743Z",
     "shell.execute_reply": "2021-08-23T16:36:55.759Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['T', 'U'], dtype='<U1')"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[3, [1,2]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "source": [
    "### \\[slice, slice], \\[slice, array], \\[array, slice]\n",
    "When both indexes refer to multiple elements (and at least one of them is a slice) you get orthogonal indexing. You can think of it as subsetting the original array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T16:38:46.032Z",
     "iopub.status.busy": "2021-08-23T16:38:46.017Z",
     "iopub.status.idle": "2021-08-23T16:38:46.063Z",
     "shell.execute_reply": "2021-08-23T16:38:46.079Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([['B', 'D', 'F'],\n",
       "       ['N', 'P', 'R'],\n",
       "       ['Z', '1', '3']], dtype='<U1')"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[::2, 1::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T16:38:49.065Z",
     "iopub.status.busy": "2021-08-23T16:38:49.048Z",
     "iopub.status.idle": "2021-08-23T16:38:49.097Z",
     "shell.execute_reply": "2021-08-23T16:38:49.112Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([['B', 'C', 'D'],\n",
       "       ['N', 'O', 'P'],\n",
       "       ['Z', '0', '1']], dtype='<U1')"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[::2, [1,2,3]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "source": [
    "### \\[array, array]\n",
    "When both indexes are arrays they act like lookup-coordinates for rows and columns. This is fancy indexing!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2020-07-26T08:12:17.855Z",
     "iopub.status.busy": "2020-07-26T08:12:17.847Z",
     "iopub.status.idle": "2020-07-26T08:12:17.870Z",
     "shell.execute_reply": "2020-07-26T08:12:17.877Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['W', 'T', 'F'], dtype='<U1')"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[[3,3,0],[4,1,5]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "source": [
    "Actually, orthogonal indexing is a subset of fancy indexing! The returned array size always corresponds to the indexing array size. In the case above we have two 1X3 arrays as indexes. When you index with a row and a column vector instead (see below), they get broadcast together to produce the same result you would get with the slice syntax.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T16:45:01.411Z",
     "iopub.status.busy": "2021-08-23T16:45:01.395Z",
     "iopub.status.idle": "2021-08-23T16:45:01.445Z",
     "shell.execute_reply": "2021-08-23T16:45:01.459Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[0],\n",
       "        [2]]),\n",
       " array([[1, 3, 5]]))"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ix_([0,2], [1,3,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T16:45:02.971Z",
     "iopub.status.busy": "2021-08-23T16:45:02.954Z",
     "iopub.status.idle": "2021-08-23T16:45:03.013Z",
     "shell.execute_reply": "2021-08-23T16:45:03.030Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([['B', 'D', 'F'],\n",
       "       ['N', 'P', 'R']], dtype='<U1')"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get it to be orthogonal \n",
    "a[np.ix_([0,2], [1,3,5])]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "source": [
    "### \\[mdarray, slice\\]\n",
    "indexing with one multidimensionsional array also basically broadcasts them together to get the final shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T16:50:42.043Z",
     "iopub.status.busy": "2021-08-23T16:50:42.021Z",
     "iopub.status.idle": "2021-08-23T16:50:42.083Z",
     "shell.execute_reply": "2021-08-23T16:50:42.101Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [1, 2]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ix = np.array([[1,2],[1,2]])\n",
    "ix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T16:50:42.369Z",
     "iopub.status.busy": "2021-08-23T16:50:42.351Z",
     "iopub.status.idle": "2021-08-23T16:50:42.403Z",
     "shell.execute_reply": "2021-08-23T16:50:42.419Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([['A', 'B', 'C', 'D', 'E', 'F'],\n",
       "       ['G', 'H', 'I', 'J', 'K', 'L'],\n",
       "       ['M', 'N', 'O', 'P', 'Q', 'R'],\n",
       "       ['S', 'T', 'U', 'V', 'W', 'X'],\n",
       "       ['Y', 'Z', '0', '1', '2', '3'],\n",
       "       ['4', '5', '6', '7', '8', '9']], dtype='<U1')"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T16:50:42.749Z",
     "iopub.status.busy": "2021-08-23T16:50:42.727Z",
     "iopub.status.idle": "2021-08-23T16:50:42.785Z",
     "shell.execute_reply": "2021-08-23T16:50:42.802Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[['G', 'H', 'I', 'J', 'K', 'L'],\n",
       "        ['M', 'N', 'O', 'P', 'Q', 'R']],\n",
       "\n",
       "       [['G', 'H', 'I', 'J', 'K', 'L'],\n",
       "        ['M', 'N', 'O', 'P', 'Q', 'R']]], dtype='<U1')"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[ix,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T16:50:50.135Z",
     "iopub.status.busy": "2021-08-23T16:50:50.118Z",
     "iopub.status.idle": "2021-08-23T16:50:50.169Z",
     "shell.execute_reply": "2021-08-23T16:50:50.184Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2, 6)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[ix,:].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T16:51:37.167Z",
     "iopub.status.busy": "2021-08-23T16:51:37.149Z",
     "iopub.status.idle": "2021-08-23T16:51:37.207Z",
     "shell.execute_reply": "2021-08-23T16:51:37.223Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([['A', 'B', 'C', 'D', 'E', 'F'],\n",
       "       ['G', 'H', 'I', 'J', 'K', 'L'],\n",
       "       ['M', 'N', 'O', 'P', 'Q', 'R'],\n",
       "       ['S', 'T', 'U', 'V', 'W', 'X'],\n",
       "       ['Y', 'Z', '0', '1', '2', '3'],\n",
       "       ['4', '5', '6', '7', '8', '9']], dtype='<U1')"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "source": [
    "below you can see how the broadcasting works explicitely"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T16:53:18.196Z",
     "iopub.status.busy": "2021-08-23T16:53:18.178Z",
     "iopub.status.idle": "2021-08-23T16:53:18.237Z",
     "shell.execute_reply": "2021-08-23T16:53:18.252Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[array([[1, 1],\n",
      "       [2, 2]]), array([[2, 3],\n",
      "       [2, 3]])]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([['I', 'J'],\n",
       "       ['O', 'P']], dtype='<U1')"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(np.broadcast_arrays([[1],[2]],[2,3]))\n",
    "a[[[1],[2]],[2,3]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T16:53:18.845Z",
     "iopub.status.busy": "2021-08-23T16:53:18.830Z",
     "iopub.status.idle": "2021-08-23T16:53:18.885Z",
     "shell.execute_reply": "2021-08-23T16:53:18.900Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[array([[2, 3],\n",
      "       [2, 3]]), array([[1, 1],\n",
      "       [2, 2]])]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([['N', 'T'],\n",
       "       ['O', 'U']], dtype='<U1')"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(np.broadcast_arrays([2, 3], [[1],[2]]))\n",
    "a[[2, 3], [[1],[2]]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "source": [
    "the reason why fancy indexing works, is that they are also broadcast together but no changes are made"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T16:54:49.604Z",
     "iopub.status.busy": "2021-08-23T16:54:49.590Z",
     "iopub.status.idle": "2021-08-23T16:54:49.638Z",
     "shell.execute_reply": "2021-08-23T16:54:49.654Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[array([2, 3]), array([1, 2])]\n"
     ]
    }
   ],
   "source": [
    "print(np.broadcast_arrays([2, 3], [1, 2]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "source": [
    "### Boolean Indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T16:55:07.769Z",
     "iopub.status.busy": "2021-08-23T16:55:07.753Z",
     "iopub.status.idle": "2021-08-23T16:55:07.801Z",
     "shell.execute_reply": "2021-08-23T16:55:07.816Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[9, 6, 8, 0, 0],\n",
       "       [1, 3, 4, 5, 7],\n",
       "       [5, 1, 0, 6, 2],\n",
       "       [2, 5, 9, 8, 1],\n",
       "       [8, 6, 9, 0, 6]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.random.randint(0,10,(5,5))\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T16:55:08.717Z",
     "iopub.status.busy": "2021-08-23T16:55:08.700Z",
     "iopub.status.idle": "2021-08-23T16:55:08.756Z",
     "shell.execute_reply": "2021-08-23T16:55:08.772Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False,  True,  True],\n",
       "       [ True,  True, False, False, False],\n",
       "       [False,  True,  True, False,  True],\n",
       "       [ True, False, False, False,  True],\n",
       "       [False, False, False,  True, False]])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a<4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T16:55:16.291Z",
     "iopub.status.busy": "2021-08-23T16:55:16.274Z",
     "iopub.status.idle": "2021-08-23T16:55:16.325Z",
     "shell.execute_reply": "2021-08-23T16:55:16.339Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 1, 3, 1, 0, 2, 2, 1, 0])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[a<4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "source": [
    "# 3+ D Indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T16:56:12.060Z",
     "iopub.status.busy": "2021-08-23T16:56:12.045Z",
     "iopub.status.idle": "2021-08-23T16:56:12.091Z",
     "shell.execute_reply": "2021-08-23T16:56:12.107Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[4, 4, 4, 5, 6],\n",
       "        [6, 8, 1, 0, 0],\n",
       "        [0, 0, 6, 9, 2],\n",
       "        [1, 3, 3, 6, 8]],\n",
       "\n",
       "       [[9, 6, 8, 3, 1],\n",
       "        [5, 1, 5, 2, 2],\n",
       "        [8, 1, 5, 9, 6],\n",
       "        [7, 2, 3, 7, 5]],\n",
       "\n",
       "       [[9, 7, 8, 3, 8],\n",
       "        [8, 1, 5, 9, 5],\n",
       "        [0, 4, 5, 6, 7],\n",
       "        [8, 6, 7, 6, 5]]])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.random.randint(0,10,(3,4,5))\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T16:56:12.350Z",
     "iopub.status.busy": "2021-08-23T16:56:12.334Z",
     "iopub.status.idle": "2021-08-23T16:56:12.385Z",
     "shell.execute_reply": "2021-08-23T16:56:12.400Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 4, 5)"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "source": [
    "### all ints"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T16:56:13.198Z",
     "iopub.status.busy": "2021-08-23T16:56:13.181Z",
     "iopub.status.idle": "2021-08-23T16:56:13.232Z",
     "shell.execute_reply": "2021-08-23T16:56:13.248Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[1,2,3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "source": [
    "### all slices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T16:56:28.153Z",
     "iopub.status.busy": "2021-08-23T16:56:28.136Z",
     "iopub.status.idle": "2021-08-23T16:56:28.186Z",
     "shell.execute_reply": "2021-08-23T16:56:28.202Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[4, 4, 6],\n",
       "        [0, 6, 2]],\n",
       "\n",
       "       [[9, 8, 8],\n",
       "        [0, 5, 7]]])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[::2,::2,::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "source": [
    "### arrays/fancy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T16:56:48.995Z",
     "iopub.status.busy": "2021-08-23T16:56:48.976Z",
     "iopub.status.idle": "2021-08-23T16:56:49.030Z",
     "shell.execute_reply": "2021-08-23T16:56:49.046Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 5])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[[1,2],[1,2],[1,2]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T16:56:53.466Z",
     "iopub.status.busy": "2021-08-23T16:56:53.450Z",
     "iopub.status.idle": "2021-08-23T16:56:53.502Z",
     "shell.execute_reply": "2021-08-23T16:56:53.516Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[4, 4, 4, 5, 6],\n",
       "        [6, 8, 1, 0, 0],\n",
       "        [0, 0, 6, 9, 2],\n",
       "        [1, 3, 3, 6, 8]],\n",
       "\n",
       "       [[9, 6, 8, 3, 1],\n",
       "        [5, 1, 5, 2, 2],\n",
       "        [8, 1, 5, 9, 6],\n",
       "        [7, 2, 3, 7, 5]],\n",
       "\n",
       "       [[9, 7, 8, 3, 8],\n",
       "        [8, 1, 5, 9, 5],\n",
       "        [0, 4, 5, 6, 7],\n",
       "        [8, 6, 7, 6, 5]]])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "source": [
    "### Mixing it up \\[slice, int, array\\]\n",
    "the single dimension gets eaten again"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T16:57:12.083Z",
     "iopub.status.busy": "2021-08-23T16:57:12.063Z",
     "iopub.status.idle": "2021-08-23T16:57:12.188Z",
     "shell.execute_reply": "2021-08-23T16:57:12.206Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[8 1]\n",
      " [1 5]\n",
      " [1 5]]\n",
      "(3, 2)\n"
     ]
    }
   ],
   "source": [
    "print(a[:,1,[1,2]])\n",
    "print(a[:,1,[1,2]].shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T16:57:13.091Z",
     "iopub.status.busy": "2021-08-23T16:57:13.074Z",
     "iopub.status.idle": "2021-08-23T16:57:13.124Z",
     "shell.execute_reply": "2021-08-23T16:57:13.139Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[8 0]\n",
      " [1 1]\n",
      " [1 4]]\n",
      "(3, 2)\n"
     ]
    }
   ],
   "source": [
    "print(a[:,[1,2],1])\n",
    "print(a[:,[1,2],1].shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T16:57:14.515Z",
     "iopub.status.busy": "2021-08-23T16:57:14.494Z",
     "iopub.status.idle": "2021-08-23T16:57:14.552Z",
     "shell.execute_reply": "2021-08-23T16:57:14.567Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[5 1 5 2 2]\n",
      " [8 1 5 9 6]]\n",
      "(2, 5)\n"
     ]
    }
   ],
   "source": [
    "print(a[1, [1,2], :])\n",
    "print(a[1, [1,2], :].shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2020-07-26T14:03:01.948Z",
     "iopub.status.busy": "2020-07-26T14:03:01.925Z",
     "iopub.status.idle": "2020-07-26T14:03:01.986Z",
     "shell.execute_reply": "2020-07-26T14:03:02.004Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 3 7 4 8]\n",
      " [8 8 7 2 5]]\n",
      "(2, 5)\n"
     ]
    }
   ],
   "source": [
    "print(a[[1,2], 1, :])\n",
    "print(a[[1,2], 1, :].shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2020-07-26T14:03:27.078Z",
     "iopub.status.busy": "2020-07-26T14:03:27.062Z",
     "iopub.status.idle": "2020-07-26T14:03:27.111Z",
     "shell.execute_reply": "2020-07-26T14:03:27.125Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[7 3 0 9]\n",
      " [1 8 2 0]]\n",
      "(2, 4)\n"
     ]
    }
   ],
   "source": [
    "print(a[[1,2], :, 1])\n",
    "print(a[[1,2], :, 1].shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2020-07-26T14:17:03.791Z",
     "iopub.status.busy": "2020-07-26T14:17:03.774Z",
     "iopub.status.idle": "2020-07-26T14:17:03.827Z",
     "shell.execute_reply": "2020-07-26T14:17:03.843Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 0 9 7]\n",
      " [7 7 8 5]]\n",
      "(2, 4)\n"
     ]
    }
   ],
   "source": [
    "print(a[0, :, [1,2]])\n",
    "print(a[0, :, [1,2]].shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "source": [
    "why not 4,2 you might ask?\n",
    "\n",
    "slice in the middle -> slice dimensions always go at the back."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T17:01:17.046Z",
     "iopub.status.busy": "2021-08-23T17:01:17.028Z",
     "iopub.status.idle": "2021-08-23T17:01:17.087Z",
     "shell.execute_reply": "2021-08-23T17:01:17.106Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[4, 4, 4, 5, 6],\n",
       "        [6, 8, 1, 0, 0],\n",
       "        [0, 0, 6, 9, 2],\n",
       "        [1, 3, 3, 6, 8]],\n",
       "\n",
       "       [[9, 6, 8, 3, 1],\n",
       "        [5, 1, 5, 2, 2],\n",
       "        [8, 1, 5, 9, 6],\n",
       "        [7, 2, 3, 7, 5]],\n",
       "\n",
       "       [[9, 7, 8, 3, 8],\n",
       "        [8, 1, 5, 9, 5],\n",
       "        [0, 4, 5, 6, 7],\n",
       "        [8, 6, 7, 6, 5]]])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T17:01:17.578Z",
     "iopub.status.busy": "2021-08-23T17:01:17.561Z",
     "iopub.status.idle": "2021-08-23T17:01:17.605Z",
     "shell.execute_reply": "2021-08-23T17:01:17.621Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [],
   "source": [
    "i1 = (np.arange(2*3*5) % 3).reshape(2,3,5)\n",
    "i2 = (np.arange(2*3*5) % 5).reshape(2,3,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T17:01:20.859Z",
     "iopub.status.busy": "2021-08-23T17:01:20.842Z",
     "iopub.status.idle": "2021-08-23T17:01:20.896Z",
     "shell.execute_reply": "2021-08-23T17:01:20.913Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([[[0, 1, 2, 0, 1],\n",
       "         [2, 0, 1, 2, 0],\n",
       "         [1, 2, 0, 1, 2]],\n",
       " \n",
       "        [[0, 1, 2, 0, 1],\n",
       "         [2, 0, 1, 2, 0],\n",
       "         [1, 2, 0, 1, 2]]]),\n",
       " array([[[0, 1, 2, 3, 4],\n",
       "         [0, 1, 2, 3, 4],\n",
       "         [0, 1, 2, 3, 4]],\n",
       " \n",
       "        [[0, 1, 2, 3, 4],\n",
       "         [0, 1, 2, 3, 4],\n",
       "         [0, 1, 2, 3, 4]]])]"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.broadcast_arrays(i1, i2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T17:02:34.143Z",
     "iopub.status.busy": "2021-08-23T17:02:34.123Z",
     "iopub.status.idle": "2021-08-23T17:02:34.178Z",
     "shell.execute_reply": "2021-08-23T17:02:34.195Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3, 5)"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# this should be the shape of our output also\n",
    "np.broadcast(i1, i2).shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "source": [
    "slice dimension moves to the back again"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-23T17:02:39.698Z",
     "iopub.status.busy": "2021-08-23T17:02:39.680Z",
     "iopub.status.idle": "2021-08-23T17:02:39.735Z",
     "shell.execute_reply": "2021-08-23T17:02:39.752Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3, 5, 4)"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[i1, : ,i2].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2020-07-26T14:27:09.635Z",
     "iopub.status.busy": "2020-07-26T14:27:09.618Z",
     "iopub.status.idle": "2020-07-26T14:27:09.671Z",
     "shell.execute_reply": "2020-07-26T14:27:09.687Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[[7, 2, 0, 5],\n",
       "         [7, 3, 0, 9],\n",
       "         [3, 7, 3, 8],\n",
       "         [6, 0, 8, 5],\n",
       "         [0, 8, 2, 3]],\n",
       "\n",
       "        [[5, 8, 7, 0],\n",
       "         [0, 0, 9, 7],\n",
       "         [5, 7, 0, 1],\n",
       "         [3, 2, 2, 8],\n",
       "         [9, 0, 5, 7]],\n",
       "\n",
       "        [[1, 0, 1, 5],\n",
       "         [1, 8, 2, 0],\n",
       "         [7, 7, 8, 5],\n",
       "         [6, 4, 2, 8],\n",
       "         [3, 5, 4, 2]]],\n",
       "\n",
       "\n",
       "       [[[7, 2, 0, 5],\n",
       "         [7, 3, 0, 9],\n",
       "         [3, 7, 3, 8],\n",
       "         [6, 0, 8, 5],\n",
       "         [0, 8, 2, 3]],\n",
       "\n",
       "        [[5, 8, 7, 0],\n",
       "         [0, 0, 9, 7],\n",
       "         [5, 7, 0, 1],\n",
       "         [3, 2, 2, 8],\n",
       "         [9, 0, 5, 7]],\n",
       "\n",
       "        [[1, 0, 1, 5],\n",
       "         [1, 8, 2, 0],\n",
       "         [7, 7, 8, 5],\n",
       "         [6, 4, 2, 8],\n",
       "         [3, 5, 4, 2]]]])"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[i1, : ,i2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "source": [
    "EXCEPT, when they dont. If the slice is the first thing, it is taken as the first dimension\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": true,
    "execution": {
     "iopub.execute_input": "2021-08-24T15:19:49.717Z",
     "iopub.status.busy": "2021-08-24T15:19:49.693Z",
     "iopub.status.idle": "2021-08-24T15:19:49.763Z",
     "shell.execute_reply": "2021-08-24T15:19:49.812Z"
    },
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 2, 3, 5)"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[:, i1 ,i2].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": false,
     "source_hidden": false
    },
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nteract": {
     "transient": {
      "deleting": false
     }
    }
   },
   "source": [
    "## Resources\n",
    "https://www.youtube.com/watch?v=o0EacbIbf58&t=1680s\n",
    "\n",
    "\n",
    "https://stackoverflow.com/questions/53841497/why-does-numpy-mixed-basic-advanced-indexing-depend-on-slice-adjacency\n",
    "\n",
    "https://stackoverflow.com/questions/46325897/non-adjacent-slicing-of-numpy-multidimensional-array-in-python?noredirect=1&lq=1\n",
    "\n",
    "https://numpy.org/doc/stable/reference/arrays.indexing.html#combining-advanced-and-basic-indexing\n",
    "\n",
    "https://towardsdatascience.com/numpy-indexing-explained-c376abb2440d\n",
    "\n",
    "\n",
    "https://github.com/numpy/numpy/pull/6075"
   ]
  }
 ],
 "metadata": {
  "kernel_info": {
   "name": "scenewalk"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.8"
  },
  "nteract": {
   "version": "0.28.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}