notebooks/032_More_numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img alt='UCL' src=\"images/ucl_logo.png\" align='center'>\n",
    "\n",
    "\n",
    "[<img src=\"images/noun_post_2109127.svg\" width=\"50\" align='right'>](040_GDAL_mosaicing_and_masking.ipynb)\n",
    "[<img src=\"images/noun_pre_2109128.svg\" width=\"50\" align='right'>](031_Numpy.ipynb)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 032 More `numpy`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Purpose\n",
    "\n",
    "\n",
    "We continue our exploration of `numpy` and move onto topics we need for efficient array processing.\n",
    "\n",
    "\n",
    "### Prerequisites\n",
    "\n",
    "* [020_Python_files](020_Python_files.ipynb)\n",
    "* [021 URLs](021_URLs.ipynb)\n",
    "* [022 Pandas](022_Pandas.ipynb)\n",
    "* [023 Plotting](023_Plotting.ipynb)\n",
    "* [031_Numpy](031_Numpy.ipynb)\n",
    "\n",
    "You will need to know the material  from [031_Numpy](031_Numpy.ipynb) in detail."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `np.loadtxt`\n",
    "\n",
    "Let's access an interesting dataset on the frequency of satellite launches to illustrate this.\n",
    "\n",
    "[![SpaceX landing](images/giphy.gif)](https://media.giphy.com/media/26DNbCqVfLJbYrXIA/giphy.gif)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The library code `geog0111.nsat` accesses a database at [https://www.n2yo.com](https://www.n2yo.com) and gets a table satellite launch data.\n",
    "\n",
    "Data from this is stored in the datafile [data/satellites-1957-2021.gz](data/satellites-1957-2021.gz). This is a compressed text file.\n",
    "\n",
    "We can use `np.loadtxt` to read files of this nature into numpy arrays in a similar way to how we [read into panadas](022_Pandas.ipynb#Reading-data-into-pandas). If the dataset is not `CSV` but simply a whitespaced text file, it is often easier to use `np.loadtxt` than `pandas`.\n",
    "\n",
    "In the case of this dataset, we wish to interpret the launch counts as integers, so we convert the data we read to integers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(12, 64)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "filename = 'data/satellites-1957-2021.gz'\n",
    "data=np.loadtxt(filename).astype(np.int)\n",
    "\n",
    "# shape of data\n",
    "print(data.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The dataset dimensions are to `(month,year)`. Indices into the array are zero-based, so we can relate month number (1 being January) and year number to index `(i,j)` through:\n",
    "\n",
    "    i = month - 1\n",
    "    j = year - 1957\n",
    "    \n",
    "We can print some summary statistics:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data shape (12, 64)\n",
      "some summary statistics over the period 1957 to 2021:\n",
      "The total number of launches is 45689\n",
      "The mean number of launches is  59.49 per month\n"
     ]
    }
   ],
   "source": [
    "print(f'data shape {data.shape}')\n",
    "\n",
    "print(f'some summary statistics over the period 1957 to 2021:')\n",
    "print(f'The total number of launches is {data.sum()}')\n",
    "print(f'The mean number of launches is {data.mean() : .2f} per month')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### slicing, `slice`\n",
    "\n",
    "We have seen [above](031_Numpy.ipynb#Indexing-arrays) how we can provide a tuple of indices to access particular array elements. Often we want to access 'blocks' of an array. A set of indices would be inefficient for that. Instead, we use the idea of slices `(from:to:step)` that we have come across before for [strings](013_Python_string_methods.ipynb#slice) . Remember that `to` is \"up to but not including\" the to number.\n",
    "\n",
    "If we specify `:` or `::` in the slice, it means we take the defaults for `(from:to:step)`. If we specify only one number, that is `from`. If we specify two, it is `from:to`.\n",
    "\n",
    "So:\n",
    "\n",
    "    data[0]\n",
    "    \n",
    "is the data for month index 0 (January), `data[1]` for February etc. Or:\n",
    "\n",
    "    data[0:2]\n",
    "   \n",
    "is the data for month index 0 (January) **and** 1 (February)  etc. \n",
    "\n",
    "We can get more specific statistics then such as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(64,)\n",
      "mean launches in month 0: 33.95\n",
      "max  launches in month 0: 237\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "filename = 'data/satellites-1957-2021.gz'\n",
    "data=np.loadtxt(filename).astype(np.int)\n",
    "\n",
    "print(data[0].shape)\n",
    "\n",
    "print(f'mean launches in month 0: {data[0].mean() :.2f}')\n",
    "print(f'max  launches in month 0: {data[0].max()}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can refer to items in the second dimension of the array, by using a code for *all* values of the first dimension. So:\n",
    "\n",
    "    data[:,0]\n",
    "    \n",
    "refers to all elements in dimension 0 (i.e. all months here) by only year 0 (1957)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(12,)\n",
      "mean launches in year 1957: 3\n",
      "max  launches in year 1957: 2\n"
     ]
    }
   ],
   "source": [
    "print(data[:,0].shape)\n",
    "\n",
    "print(f'mean launches in year 1957: {data[:,0].sum()}')\n",
    "print(f'max  launches in year 1957: {data[:,0].max()}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "#### Exercise 1\n",
    "\n",
    "* Print out the total number of launches per month, for each month.\n",
    "* Print out the total number of launches per year, for the years 2010 to 2020 inclusive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2173 launches in month 0\n",
      "3745 launches in month 1\n",
      "2895 launches in month 2\n",
      "3183 launches in month 3\n",
      "6606 launches in month 4\n",
      "5772 launches in month 5\n",
      "3279 launches in month 6\n",
      "2481 launches in month 7\n",
      "4402 launches in month 8\n",
      "4035 launches in month 9\n",
      "3273 launches in month 10\n",
      "3845 launches in month 11\n"
     ]
    }
   ],
   "source": [
    "# ANSWER\n",
    "import numpy as np\n",
    "\n",
    "filename = 'data/satellites-1957-2021.gz'\n",
    "data=np.loadtxt(filename).astype(np.int)\n",
    "\n",
    "# Print out the total number of launches \n",
    "# per month, for each month.\n",
    "# use sum() to sum over data[m] and loop over m\n",
    "# get length of m from data.shape[0]\n",
    "for m in range(data.shape[0]):\n",
    "    print(f'{data[m].sum()} launches in month {m}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "373 launches in year 2010\n",
      "315 launches in year 2011\n",
      "435 launches in year 2012\n",
      "352 launches in year 2013\n",
      "355 launches in year 2014\n",
      "335 launches in year 2015\n",
      "308 launches in year 2016\n",
      "512 launches in year 2017\n",
      "741 launches in year 2018\n",
      "735 launches in year 2019\n",
      "922 launches in year 2020\n"
     ]
    }
   ],
   "source": [
    "# ANSWER\n",
    "import numpy as np\n",
    "\n",
    "filename = 'data/satellites-1957-2021.gz'\n",
    "data=np.loadtxt(filename).astype(np.int)\n",
    "\n",
    "# Print out the total number of launches \n",
    "# per year, for the years 2010 to 2020\n",
    "# use sum() to sum over data[y] and loop over y\n",
    "# translate year to index by subtracting 1957\n",
    "\n",
    "# its best to be explicit about this\n",
    "# this answer more clearly relates to the qn\n",
    "years = np.arange(2010,2020+1) - 1957\n",
    "for y in years:\n",
    "    print(f'{data[:,y].sum()} launches in year {y+1957}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `numpy` formatting for slice in an array is `start:stop:step` as we have seen. Sometimes it is convenient to use the function `slice(start:stop:step)` to specify this.\n",
    "\n",
    "Recall that the array `data` is two-dimensional of shape `(12, 64)` where the first axis is month and the second year after 1957. To describe the months of May to July inclusive (axis 0: index `4:7`) and years `1990-2000` inclusive (axis 1: index `1990-1957:2000-1957+1` = `33:44`) we can write:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "shape of subset is (3, 11)\n"
     ]
    }
   ],
   "source": [
    "subset = data[4:7,33:44]\n",
    "print(f'shape of subset is {subset.shape}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Equivalently, using `slice`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "shape of subset is (3, 11)\n",
      "slices: slice(4, 7, None),slice(33, 44, None)\n"
     ]
    }
   ],
   "source": [
    "axis0 = slice(4,7)\n",
    "axis1 = slice(33,44)\n",
    "\n",
    "subset = data[axis0,axis1]\n",
    "print(f'shape of subset is {subset.shape}')\n",
    "print(f'slices: {axis0},{axis1}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One advantage of using `slice` is that we can store the axis slice information in a variable. We access the individual elements as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 7, None)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "axis0.start,axis0.stop,axis0.step"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "#### Exercise 2\n",
    "\n",
    "        import numpy as np\n",
    "        filename = 'data/satellites-1957-2021.gz'\n",
    "        data=np.loadtxt(filename).astype(np.int)\n",
    "\n",
    "* Use `slice` to produce a sub-set of the launch dataset `data` for the months January, March, and May for the years 1960-1966 inclusive. This is 3 months and 7 years, so the resultant array should have shape `(3,7)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "subset is of shape (3, 7)\n"
     ]
    }
   ],
   "source": [
    "# ANSWER\n",
    "import numpy as np\n",
    "filename = 'data/satellites-1957-2021.gz'\n",
    "data=np.loadtxt(filename).astype(np.int)\n",
    "\n",
    "msg = '''\n",
    " Use slice to produce a sub-set of the launch \n",
    " dataset data for the months January, March, and May\n",
    "\n",
    " January, March, and May -> months 0,2,4 so slice(0:6:2)\n",
    "\n",
    " for the years 1960-1966 inclusive\n",
    " -> slice(1960-1957:1966-1957+1:1) -> slice(3,10)\n",
    "'''\n",
    "axis0 = slice(0,6,2)\n",
    "axis1 = slice(3,10)\n",
    "subset = data[axis0,axis1]\n",
    "print(f'subset is of shape {subset.shape}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### axis\n",
    "\n",
    "Whilst it is perfectly possibly to loop over one dimension of an array and calculate statistics over the other dimension, it is not very [Pythonic](https://docs.python-guide.org/writing/style/) to do it that way. \n",
    "\n",
    "Instead. we can specify the array axes over which we want the operation to occur.\n",
    "\n",
    "For example, in our satellite launch dataset, the dimension 0 is month index and the dimension 1 is year index. To calculate the mean over all years then, we apply the `mean` function to axis 1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 33.953125,  58.515625,  45.234375,  49.734375, 103.21875 ,\n",
       "        90.1875  ,  51.234375,  38.765625,  68.78125 ,  63.046875,\n",
       "        51.140625,  60.078125])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "filename = 'data/satellites-1957-2021.gz'\n",
    "data=np.loadtxt(filename).astype(np.int)\n",
    "\n",
    "# mean over all years\n",
    "data.mean(axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is much more convenient than the loop we did above. The axis keyword is widely used in `numpy`, and you can apply most operations over one or more axis. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "#### Exercise 3\n",
    "\n",
    "* Plot the total number of satellite launches per year, as a function of year\n",
    "\n",
    "You will need to remember how to [plot line graphs](023_Plotting.ipynb#Plotting-Graphs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0, 'year')"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# ANSWER\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "filename = 'data/satellites-1957-2021.gz'\n",
    "data=np.loadtxt(filename).astype(np.int)\n",
    "\n",
    "# total for all years, so sum over all months (axis 0)\n",
    "n = data.sum(axis=0)\n",
    "# clean way to do years\n",
    "years = np.arange(1957,1957+data.shape[1])\n",
    "\n",
    "name = f'Number of satellite launches per year {years[0]} to {years[-1]}'\n",
    "\n",
    "# plot size \n",
    "x_size,y_size = 12,4\n",
    "fig, axs = plt.subplots(1,1,figsize=(x_size,y_size))\n",
    "fig.suptitle(name)\n",
    "# plot y-data and set the label\n",
    "axs.plot(years,n)\n",
    "# set x-limits to get a neat graph\n",
    "axs.set_xlim(years[0],years[-1])\n",
    "\n",
    "axs.set_ylabel(f'Number of launches')\n",
    "# x-label\n",
    "axs.set_xlabel(f'year')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2173 launches in month index 0\n",
      "3745 launches in month index 1\n",
      "2895 launches in month index 2\n",
      "3183 launches in month index 3\n",
      "6606 launches in month index 4\n",
      "5772 launches in month index 5\n",
      "3279 launches in month index 6\n",
      "2481 launches in month index 7\n",
      "4402 launches in month index 8\n",
      "4035 launches in month index 9\n",
      "3273 launches in month index 10\n",
      "3845 launches in month index 11\n"
     ]
    }
   ],
   "source": [
    "# ANSWER\n",
    "# Print out the total number of \n",
    "# launches per month, for each month.\n",
    "\n",
    "# use sum for total\n",
    "# we can use data.shape[0] for the size of the 1st dimension\n",
    "for m in range(data.shape[0]):\n",
    "    print(f'{data[m].sum()} launches in month index {m}')\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "373 launches in year 2010\n",
      "315 launches in year 2011\n",
      "435 launches in year 2012\n",
      "352 launches in year 2013\n",
      "355 launches in year 2014\n",
      "335 launches in year 2015\n",
      "308 launches in year 2016\n",
      "512 launches in year 2017\n",
      "741 launches in year 2018\n",
      "735 launches in year 2019\n",
      "922 launches in year 2020\n"
     ]
    }
   ],
   "source": [
    "# ANSWER\n",
    "# Print out the total number of \n",
    "# launches per year, for the years 2010 to 2020 inclusive\n",
    "\n",
    "# use sum for total\n",
    "for y in range(2010,2020+1):\n",
    "    # y is a year, but we need index\n",
    "    j = y - 1957\n",
    "    print(f'{data[:,j].sum()} launches in year {y}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `argmin`, `argmax` \n",
    "\n",
    "Whilst we have generated some initial summary statistics on the dataset, it's not really enough to give us a good idea of the data characteristics.\n",
    "\n",
    "To do that, we want to be able to ask somewhat more complex questions of the data, such as:\n",
    "\n",
    "* which *year* has the most/least launches? \n",
    "* which month do most launches happen in? \n",
    "* which month in which year had the most launches? \n",
    "* which years had more than 100 launches?\n",
    "\n",
    "Whilst we could do some of these with loops and slicing, we expect a more convenient approach for `numpy`.\n",
    "\n",
    "To be able to address these, we need some new concepts:\n",
    "\n",
    "* methods `argmin()` and `argmax()` that provide the *index* where the min/max occurs\n",
    "* masking out array elements that meet some condition\n",
    "\n",
    "The first set of these, `argmin()` and `argmax()` are straightforward to visualise and use:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 42\n",
      "the year with most   launches was 1999 with 4195\n",
      "the year with fewest launches was 1957 with 3\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# read data as before\n",
    "filename = 'data/satellites-1957-2021.gz'\n",
    "data=np.loadtxt(filename).astype(np.int)\n",
    "\n",
    "# sum the data over all months (axis 0)\n",
    "sum_per_year = data.sum(axis=0)\n",
    "# Construct an array of years\n",
    "year_array = 1957 + np.arange(data.shape[1])\n",
    "\n",
    "# Find the location (year) with **most** launches\n",
    "# Find the index of sum_per_year with highest number (argmmax)\n",
    "imax = np.argmax(sum_per_year)\n",
    "\n",
    "# Find the location (year) with **least** launches\n",
    "# Find the index of sum_per_year with lowest number (argmmax)\n",
    "imin = np.argmin(sum_per_year)\n",
    "print(imin,imax)\n",
    "print(f'the year with most   launches was',\\\n",
    "      f'{year_array[imax]} with {sum_per_year[imax]}')\n",
    "print(f'the year with fewest launches was',\\\n",
    "      f'{year_array[imin]} with {sum_per_year[imin]}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "#### Exercise 4\n",
    "\n",
    "* Write code to print the months with highest and lowest number of launches"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the month with most   launches was 5 with 6606\n",
      "the month with fewest launches was 1 with 2173\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "# ANSWER\n",
    "# Write code to print the months with \n",
    "# highest and lowest number of launches\n",
    "\n",
    "# read data as before\n",
    "filename = 'data/satellites-1957-2021.gz'\n",
    "data=np.loadtxt(filename).astype(np.int)\n",
    "\n",
    "# sum the data over all years (axis 1)\n",
    "sum_per_month = data.sum(axis=1)\n",
    "# Construct an array of months\n",
    "month_array = 1 + np.arange(data.shape[0])\n",
    "\n",
    "# Find the location (month) with **most** launches\n",
    "# Find the index of sum_per_month with highest number (argmmax)\n",
    "imax = np.argmax(sum_per_month)\n",
    "\n",
    "# Find the location (month) with **least** launches\n",
    "# Find the index of sum_per_month with lowest number (argmmax)\n",
    "imin = np.argmin(sum_per_month)\n",
    "\n",
    "print(f'the month with most   launches was',\\\n",
    "      f'{month_array[imax]} with {sum_per_month[imax]}')\n",
    "print(f'the month with fewest launches was',\\\n",
    "      f'{month_array[imin]} with {sum_per_month[imin]}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### masking\n",
    "\n",
    "In section [011_Python_data_types](011_Python_data_types.ipynb#Data-types:-bool) we came across the boolean (binary) data type that can take the states `True` or `False`.\n",
    "\n",
    "Boolean arrays in `numpy` are important in the efficient use of arrays, as they can act as a mask on an array. \n",
    "\n",
    "For example:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The form of filtering above (`high = sum_per_year >= 1000`) produces a numpy array of the same shape as that operated on (`sum_per_year` here) of `bool` data type.  It has entries of `True` where the condition is met, and `False` where it is not met."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[False False False False False False False False  True False False False\n",
      " False False False False False False  True  True False False False False\n",
      "  True False False False False  True  True False False False False False\n",
      "  True  True False False False False  True False False False False False\n",
      " False  True False False False False False False False False False False\n",
      " False False False False]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# read data as before\n",
    "filename = 'data/satellites-1957-2021.gz'\n",
    "data=np.loadtxt(filename).astype(np.int)\n",
    "# sum over all months (axis 0)\n",
    "sum_per_year = data.sum(axis=0)\n",
    "\n",
    "high = sum_per_year >= 1000\n",
    "print(high)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can think of this logical array as a 'data mask' that we use to select (filter) entries:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "years with 1000 or more launches [1965 1975 1976 1981 1986 1987 1993 1994 1999 2006]\n"
     ]
    }
   ],
   "source": [
    "# form the data mask\n",
    "high = (sum_per_year >= 1000)\n",
    "# form an attau of years\n",
    "years = 1957 + np.arange(data.shape[1])\n",
    "\n",
    "# select only elements where mask is True\n",
    "print(f'years with 1000 or more launches {years[high]}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can apply logical operators to boolean arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ True  True  True  True  True  True  True  True False  True  True  True\n",
      "  True  True  True  True  True  True False False  True  True  True  True\n",
      " False  True  True  True  True False False  True  True  True  True  True\n",
      " False False  True  True  True  True False  True  True  True  True  True\n",
      "  True False  True  True  True  True  True  True  True  True  True  True\n",
      "  True  True  True  True]\n"
     ]
    }
   ],
   "source": [
    "low = np.logical_not(high)\n",
    "print(low)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "including combinations of logical arrays. \n",
    "\n",
    "Suppose we want to know the years after the year 2000 that have 1000 or greater launches. We can form two boolean arrays:\n",
    "    \n",
    "    years > 2000\n",
    "    sum_per_year >= 1000\n",
    "    \n",
    "Since these arrays are of the same shape, we can combine them element-wise:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2006]\n"
     ]
    }
   ],
   "source": [
    "c1 = (years > 2000)\n",
    "c2 = (sum_per_year >= 1000)\n",
    "combined = np.logical_and(c1,c2)\n",
    "print(years[combined])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `where`\n",
    "\n",
    "Sometimes, instead of just applying the filter as above, we want to know the indices of the filtered values.\n",
    "\n",
    "To do this, we can use the `np.where()` method. This takes a `bool` array as its argument (such as our data masks or other conditions) and returns a tuple of the indices where this is set `True`. \n",
    "\n",
    "As an example, lets find month, year pairs where the number of launches is greater than 500. \n",
    "\n",
    "For a final flourish, we load the dataset into `pandas` to print it in a table:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>month</th>\n",
       "      <th>year</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2</td>\n",
       "      <td>1986</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>5</td>\n",
       "      <td>1994</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>5</td>\n",
       "      <td>1999</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>6</td>\n",
       "      <td>1981</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>6</td>\n",
       "      <td>1993</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>6</td>\n",
       "      <td>2006</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>7</td>\n",
       "      <td>1976</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>9</td>\n",
       "      <td>1997</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   month  year\n",
       "0      2  1986\n",
       "1      5  1994\n",
       "2      5  1999\n",
       "3      6  1981\n",
       "4      6  1993\n",
       "5      6  2006\n",
       "6      7  1976\n",
       "7      9  1997"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# find month, year where launches > 500\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "# read data as before\n",
    "filename = 'data/satellites-1957-2021.gz'\n",
    "data=np.loadtxt(filename).astype(np.int)\n",
    "\n",
    "month_index,year_index = np.where(data > 500)\n",
    "# This gives array indices\n",
    "\n",
    "# convert index to real month and year\n",
    "# and *transpose* (swap rows and columns)\n",
    "# using .T\n",
    "high_launches = np.array([month_index+1,year_index+1957]).T\n",
    "\n",
    "# load into pandas data frame \n",
    "df = pd.DataFrame(high_launches,columns=['month','year'])\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simplifying shape: `flatten`, `ravel`, `reshape` and `unravel_index`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have seen that we can build multi-dimensional arrays in `numpy`. Sometimes, for processing though, we need to modify the number of dimensions of an array. There are several ways to do this.\n",
    "\n",
    "First, if we want simply to collapse a multi-dimensional array into a 1D array, we can use `ravel` or `flatten`. A useful case to consider for this is when we process on a grid.\n",
    "\n",
    "We generate a grid of `locations` similar to [previously](031_Numpy.ipynb#np.linspace,-np.arange,-np.mgrid):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "shape of p0 : (21, 21)\n",
      "shape of p1 : (21, 21)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "p0min,p0max,p0step = -1.0,1.0,0.1\n",
    "p1min,p1max,p1step = -1.0,1.0,0.1\n",
    "\n",
    "p0,p1 = np.mgrid[p0min:p0max+p0step:p0step,\\\n",
    "                         p1min:p1max+p1step:p1step]\n",
    "\n",
    "print(f'shape of p0 : {p0.shape}')\n",
    "print(f'shape of p1 : {p1.shape}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we want to calculate a function of the variables `p0` and `p1` and want to find the parameter values at which the function has a local (over the grid) minimum. We will use the function:\n",
    "\n",
    "       y = 1 + 2 * (p0 - 0.5)**2 + 3 * (p1 - 0.4)**2\n",
    " \n",
    "as an example, or the range `[-1,1]` for both parameters. It should be clear that the minimum of this function lies at `(0.5,0.4)`, but we want to show this numerically."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.colorbar.Colorbar at 0x7fa5b0be04d0>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# our function\n",
    "y = 1 + 2 * (p0 - 0.5)**2 + 3 * (p1 - 0.4)**2 \n",
    "\n",
    "# plot it\n",
    "fig, axs = plt.subplots(1,1,figsize=(6,5))\n",
    "im = axs.imshow(y,interpolation='nearest',vmax=2)\n",
    "fig.colorbar(im, ax=axs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "329"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.argmin(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could  use `np.where` to find the index of the minimum point by seeking where it equals the minimum value. That is not always a good idea, as there might be rounding errors involved.\n",
    "\n",
    "A more robust approach is to use `np.argmin` to find the index at which the argument has its minimum."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "index of minimum point: 329\n"
     ]
    }
   ],
   "source": [
    "imin = np.argmin(y)\n",
    "print(f'index of minimum point: {imin}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The index of `329` is returned which might at first seem odd: the array `y` is two dimensional of shape `(21,21)` so how can we have a 1D index of `329`?\n",
    "\n",
    "The answer is that `np.argmin` operates on a 'flattened' version of the array. When we used it [above](032_More_numpy.ipynb#argmin,-argmax) this issue was not apparent because the input array was 1D.\n",
    "\n",
    "If we want to apply the flattened array index, we must first then flatten the array. There are two functions for this: `flatten` and `ravel`. They both have a similar effect, but `flatten` operates of a *copy* of the array. This means it uses more memory. But also any changes we make are not reflected in the original array. Very often we use `ravel` instead then. This takes no more memory, but any changes we make to the ravelled array will also happen to the original array. You should think carefully about which you use in any particular circumstance, but unless you really need to operate on a copy, you might generally use `ravel`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "shape of y    : (21, 21)\n",
      "shape of yrav : (441,)\n",
      "parameter at minimum :  0.500, 0.400\n"
     ]
    }
   ],
   "source": [
    "yrav = y.ravel()\n",
    "print(f'shape of y    : {y.shape}')\n",
    "print(f'shape of yrav : {yrav.shape}')\n",
    "\n",
    "p0min,p1min = p0.ravel()[imin],p1.ravel()[imin]\n",
    "print(f'parameter at minimum : {p0min : .3f},{p1min : .3f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "which matches what we expected. \n",
    "\n",
    "These two functions are an integral part of efficient use of `numpy` for large-dimensional problems. We can recognise in the example above that it makes no difference to the processing whether we search for the `argmin` over a 1D or 2D array. It makes sense then to treat it as a 1D problem.\n",
    "\n",
    "The same sort of issues arise when we are dealing with image processing: although an image is defined over a 2D spatial extent, if the algorithm we are applying is operated independently per pixel, then this can be equally treated as a 1D problem. If we had a problem to solve over an image space and over a parameter space (as we come across see later) then we can simplify our data structure by collapsing unnecessary multi-dimensional arrays into 1D arrays. In that case, it might not always be possible to use `ravel` as we might need to 'flatten' different parts of the dataset in different fashions. For this, more refined control on array shape, we use `reshape`.\n",
    "\n",
    "To illustrate this, we generate a function y over the parameter space `p0`, `p1` that we suppose described our function at different time steps:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "shape of y : (3, 21, 21)\n"
     ]
    }
   ],
   "source": [
    "y0 = 1 + 2 * (p0 - 0.5)**2 + 3 * (p1 - 0.4)**2 \n",
    "y1 = 1 + 4 * (p0 - 0.2)**2 + 3 * (p1 - 0.1)**2 \n",
    "y2 = 1 + 8 * (p0 - 0.7)**2 + 6 * (p1 - 0.3)**2 \n",
    "\n",
    "y = np.array([y0,y1,y2])\n",
    "print(f'shape of y : {y.shape}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`y` is a 3D array with the first axis representing time, and the second and third the parameter space. We can see that the minima should occur at `[0.5 0.2 0.7],[0.4 0.1 0.3]`\n",
    "\n",
    "We wish to find parameters that give the minimum of the function *for each time step* (i.e. solve numerically for `[0.5 0.2 0.7],[0.4 0.1 0.3]`). The result we expect then is that each parameter should be an array of shape `(3,)`.\n",
    "\n",
    "We can use `np.argmin` again for this problem, as we can specify the axis over which to operate for `argmin`. However, it can only operate over a single axis, so we must first re-form the array to one of shape `(3,21 * 21)`. The shape of the first dimension will be simply `y.shape[:1]`. We can multiply the last two elements of the shape array together using `np.prod` as `np.prod(np.array(y.shape[1:]))`, then use the new shape with `np.reshape`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3,)\n",
      "441\n",
      "(3, 441)\n"
     ]
    }
   ],
   "source": [
    "# get the new shape we want\n",
    "firstpart  = y.shape[:1]\n",
    "print(firstpart)\n",
    "\n",
    "secondpart = np.prod(np.array(y.shape[1:]))\n",
    "print(secondpart)\n",
    "\n",
    "# use * to unload the tuple\n",
    "newshape = (*y.shape[:1],np.prod(np.array(y.shape[1:])))\n",
    "print(newshape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "shape of y  : (3, 21, 21)\n",
      "shape of y_ : (3, 441)\n"
     ]
    }
   ],
   "source": [
    "# reshape \n",
    "y_ = y.reshape(newshape)\n",
    "\n",
    "print(f'shape of y  : {y.shape}')\n",
    "print(f'shape of y_ : {y_.shape}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1D index of minimum point: [329 263 370]\n"
     ]
    }
   ],
   "source": [
    "# argmin over axis 1 (the parameters)\n",
    "imin = np.argmin(y_,axis=1)\n",
    "print(f'1D index of minimum point: {imin}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We may want to know the 2D index in the parameter grid for some applications. This can be conveniently calculated with `np.unravel_index`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2D index of minimum point: [15 12 17], [14 11 13]\n",
      "parameter at minimum : [0.5 0.2 0.7],[0.4 0.1 0.3]\n"
     ]
    }
   ],
   "source": [
    "ip0min,ip1min = np.unravel_index(imin,p0.shape)\n",
    "\n",
    "print(f'2D index of minimum point: {ip0min}, {ip1min}')\n",
    "p0min = p0[ip0min,ip1min]\n",
    "p1min = p1[ip0min,ip1min]\n",
    "print(f'parameter at minimum : {p0min},{p1min}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "which corresponds with what we expected."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's great: by appropriate use of `reshape` we have found the flattened-parameter index for each of the time samples where the function is minimum.\n",
    "\n",
    "We could then print the parameters at the minimum as above, using the index array `imin` as indices into the flattened parameter arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "parameter at minimum : [0.5 0.2 0.7],[0.4 0.1 0.3]\n"
     ]
    }
   ],
   "source": [
    "p0min,p1min = p0.ravel()[imin],p1.ravel()[imin]\n",
    "print(f'parameter at minimum : {p0min},{p1min}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reconciling arrays: `np.newaxis`\n",
    "\n",
    "`numpy` is very efficient at array-based processing. This means that for your codes to be efficient, you should avoid any explicit loops when dealing with large datasets. We will come across examples later where this is critical to being able to process data in a reasonable time.\n",
    "\n",
    "Let's consider the case where we have some function that calculates the linear function:\n",
    "\n",
    "    y = c + m*x\n",
    "    \n",
    "where `x` is some `numpy` array of values of `x` and the linear model parameters are `c` (intercept) and `m` (slope). This is efficient in `numpy` and straightforward to do if `c` and `m` are scalar values (i.e. just a float number):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x-shape: (21,)\n",
      "y-shape: (21,)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "def linear_func(c,m,x):\n",
    "    return m * x + c\n",
    "\n",
    "# example parameters\n",
    "c = 0.2\n",
    "m = 0.002\n",
    "\n",
    "# the x values\n",
    "x = np.arange(0,10.5,0.5)\n",
    "\n",
    "y = m* x + c\n",
    "\n",
    "fig, axs = plt.subplots(1,1,figsize=(5,5))\n",
    "axs.plot(x,y,'+')\n",
    "axs.set_xlabel('x')\n",
    "axs.set_ylabel('y')\n",
    "\n",
    "print(f'x-shape: {x.shape}')\n",
    "print(f'y-shape: {y.shape}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's try to calculate the model `y = c + m * x` for these same values of `x`, but for multiple sets of `c` and `m`. We will use [`np.mgrid`](031_Numpy.ipynb#np.linspace,-np.arange,-np.mgrid) as above to generate a grid of pairs of `c` and `m`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "grid_c is [[0.  0.  0.  0.  0.  0. ]\n",
      " [0.5 0.5 0.5 0.5 0.5 0.5]\n",
      " [1.  1.  1.  1.  1.  1. ]]\n",
      "grid_m is [[0.   0.01 0.02 0.03 0.04 0.05]\n",
      " [0.   0.01 0.02 0.03 0.04 0.05]\n",
      " [0.   0.01 0.02 0.03 0.04 0.05]]\n",
      "2d parameter grid: (3, 6)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "# define the min and max and step for the grid we want\n",
    "c_min,c_max,c_step = 0.0,1.,0.5\n",
    "m_min,m_max,m_step = 0.0,0.05,0.01\n",
    "\n",
    "grid_c,grid_m = np.mgrid[c_min:c_max+c_step:c_step,\\\n",
    "                         m_min:m_max+m_step:m_step]\n",
    "\n",
    "print(f'grid_c is {grid_c}')\n",
    "print(f'grid_m is {grid_m}')\n",
    "\n",
    "# plot it\n",
    "fig, axs = plt.subplots(1,1,figsize=(5,5))\n",
    "axs.plot(grid_c,grid_m,'+')\n",
    "axs.set_xlabel('c')\n",
    "axs.set_ylabel('m')\n",
    "\n",
    "print(f'2d parameter grid: {grid_c.shape}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This grid is `(3,6)` and the `x` dataset is shape `(21,)`. \n",
    "\n",
    "We would expect the output dataset `y` that describes `c + m*x` for all `x`, for each value of `c` and `m` to have a shape `(3,6,21)`. Here, axis 0 and 1 refer to the parameter grid dimensions and axis 2 to the variation over `x`. The operation is a simple element-wise manipulation that `numpy` should be efficient at, even for large arrays. We will see that the key to doing this cleanly is to use [`np.newaxis`](https://numpy.org/doc/stable/reference/arrays.indexing.html).\n",
    "\n",
    "An **inefficient** way of calculating `y` for each of the grid parameters would be to use a loop over each value of `x`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "for a single value of x, we get an output of shape (3, 6)\n"
     ]
    }
   ],
   "source": [
    "print(f'for a single value of x, we get an output of shape {linear_func(grid_c,grid_m,0.1).shape}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y shape: (3, 6, 21)\n"
     ]
    }
   ],
   "source": [
    "# generate an output array to pack into\n",
    "newshape = grid_c.shape + x.shape\n",
    "y = np.zeros(newshape)\n",
    "print(f'y shape: {y.shape}')\n",
    "\n",
    "# inifficient: looping over each element of x -> xi\n",
    "# and inserting into grid\n",
    "for i,xi in enumerate(x):\n",
    "    y[:,:,i] = linear_func(grid_c,grid_m,xi)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x360 with 18 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "ymin,ymax = y.min(),y.max()\n",
    "xmin,xmax = x.min(),x.max()\n",
    "\n",
    "# plots:     \n",
    "fig, axs = plt.subplots(*(grid_c.shape),figsize=(12,5))\n",
    "plt.setp(axs, xticks=[], yticks=[])\n",
    "\n",
    "for i in range(y.shape[0]):\n",
    "    for j in range(y.shape[1]):\n",
    "        axs[i,j].plot(x,y[i,j],'k')\n",
    "        axs[i,j].set_title(f'c: {grid_c[i,j]:.2f} m: {grid_m[i,j]:.2f}')\n",
    "        axs[i,j].set_xlim(xmin,xmax)\n",
    "        axs[i,j].set_ylim(ymin,ymax)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, we know the sort of result we are looking for from this, ideally we would do it in a single call to the function with `numpy`.\n",
    "\n",
    "In all of the simple cases above, we have performed operations of arrays of the same shape, so adding an array of shape `(10,2)` to another of the same shape results in an array of shape `(10,2)`. \n",
    "\n",
    "If we have an array of shape `(10,2,1)` and add it to an array of shape `(1,1,5)`, we will get a result of shape (10,2,5):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 2, 5)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "# generate some random numbers\n",
    "\n",
    "a = np.random.random((10,2,1))\n",
    "b = np.random.random((1,1,5))\n",
    "\n",
    "c = a + b\n",
    "print(c.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The 'rule' for combining arrays in this way can be thought of as:\n",
    "\n",
    "* the arrays to be combined must have the same *number of dimensions* (3 here)\n",
    "* the number of samples in any dimension must be *the same* or `1`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we had started out with arrays of different shapes that we want to combine, e.g.:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "# generate some random numbers\n",
    "\n",
    "a = np.random.random((10,2))\n",
    "b = np.random.random((5))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we need to add new axes to the arrays to reconcile their dimensions. One clear way to do this is to use `np.newaxis` to add the new dimensions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a shape: (10, 2)\n",
      "b shape: (5,)\n",
      "a1 shape: (10, 2, 1)\n",
      "b1 shape: (1, 1, 5)\n",
      "c1 shape: (10, 2, 5)\n"
     ]
    }
   ],
   "source": [
    "a = np.random.random((10,2))\n",
    "b = np.random.random((5,))\n",
    "print(f'a shape: {a.shape}')\n",
    "print(f'b shape: {b.shape}')\n",
    "\n",
    "a1 = a[:,:,np.newaxis]\n",
    "b1 = b[np.newaxis,np.newaxis,:]\n",
    "print(f'a1 shape: {a1.shape}')\n",
    "print(f'b1 shape: {b1.shape}')\n",
    "\n",
    "c1 = a1 + b1 \n",
    "print(f'c1 shape: {c1.shape}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we can do element-wise operations of `a` and `b` as required, where the result will be of shape `(10,2,5)` and involve all element-wise combinations of `a` and `b`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "#### Exercise 5\n",
    "\n",
    "    def linear_func(c,m,x):\n",
    "        return m * x + c\n",
    "        \n",
    "    x = np.arange(0,10.5,0.5)\n",
    "\n",
    "    c_min,c_max,c_step = 0.0,1.,0.5\n",
    "    m_min,m_max,m_step = 0.0,0.05,0.01\n",
    "\n",
    "    grid_c,grid_m = np.mgrid[c_min:c_max+c_step:c_step,\\\n",
    "                             m_min:m_max+m_step:m_step]\n",
    "\n",
    "\n",
    "* Use `np.newaxis` to reconcile the shapes of `grid_c`,`grid_m` and `x` \n",
    "* Make a single call to the function `linear_func`  using these reconciled variables\n",
    "* Show how the shape of the output relates to the shape of the inputs \n",
    "* Confirm your result by plotting the results for each (c,m) value pair"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "we are looking for output of shape \n",
      "\n",
      "    grid_c.shape + x.shape\n",
      "    \n",
      "so we add new axes to the final axis of grid_c,grid_m\n",
      "and 2 new axes to the front of x\n",
      "\n",
      "grid_c1 shape: (3, 6, 1)\n",
      "grid_m1 shape: (3, 6, 1)\n",
      "x1 shape:      (1, 1, 21)\n",
      "y shape:       (3, 6, 21)\n",
      "\n",
      "Show how the shape of the output relates to the shape of the inputs \n",
      "\n",
      "The array y is of diemnsion (7, 6, 21)\n",
      "values of c,m are on a grid (7, 6)\n",
      "and x is (21,) so the result here involves\n",
      "efficient element-wise multiplication\n",
      "and addition for each combination of (c,m)\n",
      "and each value of x\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# ANSWER\n",
    "import numpy as np\n",
    "\n",
    "def linear_func(c,m,x):\n",
    "    return m * x + c\n",
    "\n",
    "x = np.arange(0,10.5,0.5)\n",
    "\n",
    "c_min,c_max,c_step = 0.0,1.,0.5\n",
    "m_min,m_max,m_step = 0.0,0.05,0.01\n",
    "\n",
    "grid_c,grid_m = np.mgrid[c_min:c_max+c_step:c_step,\\\n",
    "                         m_min:m_max+m_step:m_step]\n",
    "\n",
    "# Use np.newaxis to reconcile the shapes of grid_c,grid_m and x\n",
    "msg = '''\n",
    "we are looking for output of shape \n",
    "\n",
    "    grid_c.shape + x.shape\n",
    "    \n",
    "so we add new axes to the final axis of grid_c,grid_m\n",
    "and 2 new axes to the front of x\n",
    "'''\n",
    "print(msg)\n",
    "\n",
    "grid_c1 = grid_c[:,:,np.newaxis]\n",
    "grid_m1 = grid_m[:,:,np.newaxis]\n",
    "x1      = x[np.newaxis,np.newaxis,:]\n",
    "print(f'grid_c1 shape: {grid_c1.shape}')\n",
    "print(f'grid_m1 shape: {grid_m1.shape}')\n",
    "print(f'x1 shape:      {x1.shape}')\n",
    "\n",
    "# Make a single call to the function linear_func \n",
    "# using these reconciled variables\n",
    "y = linear_func(grid_c1,grid_m1,x1)\n",
    "\n",
    "print(f'y shape:       {y.shape}')\n",
    "msg = '''\n",
    "Show how the shape of the output relates to the shape of the inputs \n",
    "\n",
    "The array y is of diemnsion (7, 6, 21)\n",
    "values of c,m are on a grid (7, 6)\n",
    "and x is (21,) so the result here involves\n",
    "efficient element-wise multiplication\n",
    "and addition for each combination of (c,m)\n",
    "and each value of x\n",
    "'''\n",
    "print(msg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x360 with 18 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Confirm your result by plotting the results for each (c,m) value pair\n",
    "import matplotlib.pyplot as plt\n",
    "ymin,ymax = y.min(),y.max()\n",
    "xmin,xmax = x.min(),x.max()\n",
    "\n",
    "# plots:     \n",
    "fig, axs = plt.subplots(*(grid_c.shape),figsize=(12,5))\n",
    "plt.setp(axs, xticks=[], yticks=[])\n",
    "\n",
    "for i in range(y.shape[0]):\n",
    "    for j in range(y.shape[1]):\n",
    "        axs[i,j].plot(x,y[i,j],'k')\n",
    "        axs[i,j].set_title(f'c: {grid_c[i,j]:.2f} m: {grid_m[i,j]:.2f}')\n",
    "        axs[i,j].set_xlim(xmin,xmax)\n",
    "        axs[i,j].set_ylim(ymin,ymax)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Formative assessment\n",
    "\n",
    "To get some feedback on how you are doing, you should complete and submit the formative assessment [064 Numpy](064_Numpy.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary\n",
    "\n",
    "In this section, we have expanded our understanding of `numpy` processing to include topics such as finding the array index where some pattern occurs (e.g. `argmin()`, `argsort()` or `where()`) and how to generate and use masks for selecting data. We should now have a good grasp of the role of axes, slicing, and reconciling multi-dimensional grids for efficient processing.\n",
    "\n",
    "Remember:\n",
    "\n",
    "\n",
    "| Function | description   | keywords | \n",
    " |---|---|---|\n",
    " | `np.loadtxt(f)` | Load datra from file `f` into numpy array ||\n",
    " | x[start:stop:step] | 1-D slice of array `x` ||\n",
    " | `slice(start:stop:step)` | function to apply to slice e.g. `x[slice(start:stop:step)]`|\n",
    " | `np.argmin(x)` | return 1D index of minimum value in array (/axis) |  `axis=N` : value taken over axis `N` |\n",
    " | `np.argmax(x)` | return 1D index of maximum value in array (/axis) |  `axis=N` : value taken over axis `N` |\n",
    " | `x > 1` | logical operator resulting in boolean array e.g. to use for masks |\n",
    " | `np.logical_not(x)` | element-wise not over array |\n",
    " | `np.logical_or(x,y)` | element-wise `a` or `b`  over array |\n",
    " | `np.logical_and(x,y)` | element-wise `a` and `b`  over array |\n",
    " | `np.where(x)` |  list of indices where `x` is `True` |\n",
    " | `x.flatten()` | convert copy of ND array `x` into 1D array |\n",
    "  | `x.ravel()` | convert ND array `x` into 1D array |\n",
    "| `x.reshape(shape)` | apply shape `shape` to array `x` |\n",
    "| `np.unravel_index(indices,shape)` | unravel 1D indices `indices` to ND defined by `shape` |\n",
    "| `np.newaxis` | add a new axis to array for reconciling multiple dimensions making a copy. Effectively makes new dimension of size `(1,)` |\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[<img src=\"images/noun_post_2109127.svg\" width=\"50\" align='right'>](040_GDAL_mosaicing_and_masking.ipynb)\n",
    "[<img src=\"images/noun_pre_2109128.svg\" width=\"50\" align='right'>](031_Numpy.ipynb)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "conda env:geog0111-geog0111",
   "language": "python",
   "name": "conda-env-geog0111-geog0111-py"
  },
  "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.7.13"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {
    "height": "438px",
    "left": "10px",
    "top": "150px",
    "width": "165px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}