tools_numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Tools - NumPy**\n",
    "\n",
    "*NumPy is the fundamental library for scientific computing with Python. NumPy is centered around a powerful N-dimensional array object, and it also contains useful linear algebra, Fourier transform, and random number functions.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table align=\"left\">\n",
    "  <td>\n",
    "    <a href=\"https://colab.research.google.com/github/ageron/handson-ml3/blob/main/tools_numpy.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
    "  </td>\n",
    "  <td>\n",
    "    <a target=\"_blank\" href=\"https://kaggle.com/kernels/welcome?src=https://github.com/ageron/handson-ml3/blob/main/tools_numpy.ipynb\"><img src=\"https://kaggle.com/static/images/open-in-kaggle.svg\" /></a>\n",
    "  </td>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's import `numpy`. Most people import it as `np`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `np.zeros`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `zeros` function creates an array containing any number of zeros:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's just as easy to create a 2D array (i.e. a matrix) by providing a tuple with the desired number of rows and columns. For example, here's a 3x4 matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((3,4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Some vocabulary\n",
    "\n",
    "* In NumPy, each dimension is called an **axis**.\n",
    "* The number of axes is called the **rank**.\n",
    "    * For example, the above 3x4 matrix is an array of rank 2 (it is 2-dimensional).\n",
    "    * The first axis has length 3, the second has length 4.\n",
    "* An array's list of axis lengths is called the **shape** of the array.\n",
    "    * For example, the above matrix's shape is `(3, 4)`.\n",
    "    * The rank is equal to the shape's length.\n",
    "* The **size** of an array is the total number of elements, which is the product of all axis lengths (e.g. 3*4=12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.zeros((3,4))\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 4)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.ndim  # equal to len(a.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## N-dimensional arrays\n",
    "You can also create an N-dimensional array of arbitrary rank. For example, here's a 3D array (rank=3), with shape `(2,3,4)`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0., 0., 0., 0.],\n",
       "        [0., 0., 0., 0.],\n",
       "        [0., 0., 0., 0.]],\n",
       "\n",
       "       [[0., 0., 0., 0.],\n",
       "        [0., 0., 0., 0.],\n",
       "        [0., 0., 0., 0.]]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((2,3,4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Array type\n",
    "NumPy arrays have the type `ndarray`s:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(np.zeros((3,4)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `np.ones`\n",
    "Many other NumPy functions create `ndarray`s.\n",
    "\n",
    "Here's a 3x4 matrix full of ones:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones((3,4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `np.full`\n",
    "Creates an array of the given shape initialized with the given value. Here's a 3x4 matrix full of `π`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3.14159265, 3.14159265, 3.14159265, 3.14159265],\n",
       "       [3.14159265, 3.14159265, 3.14159265, 3.14159265],\n",
       "       [3.14159265, 3.14159265, 3.14159265, 3.14159265]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.full((3,4), np.pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `np.empty`\n",
    "An uninitialized 2x3 array (its content is not predictable, as it is whatever is in memory at that point):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-1.28822975e-231, -3.11108662e+231,  1.48219694e-323],\n",
       "       [ 0.00000000e+000,  0.00000000e+000,  4.17201348e-309]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.empty((2,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## np.array\n",
    "Of course, you can initialize an `ndarray` using a regular python array. Just call the `array` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3,  4],\n",
       "       [10, 20, 30, 40]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([[1,2,3,4], [10, 20, 30, 40]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `np.arange`\n",
    "You can create an `ndarray` using NumPy's `arange` function, which is similar to python's built-in `range` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(1, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It also works with floats:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 2., 3., 4.])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(1.0, 5.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, you can provide a step parameter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1. , 1.5, 2. , 2.5, 3. , 3.5, 4. , 4.5])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(1, 5, 0.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, when dealing with floats, the exact number of elements in the array is not always predictable. For example, consider this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.         0.33333333 0.66666667 1.         1.33333333 1.66666667]\n",
      "[0.         0.33333333 0.66666667 1.         1.33333333 1.66666667]\n",
      "[0.         0.33333333 0.66666667 1.         1.33333334]\n"
     ]
    }
   ],
   "source": [
    "print(np.arange(0, 5/3, 1/3)) # depending on floating point errors, the max value is 4/3 or 5/3.\n",
    "print(np.arange(0, 5/3, 0.333333333))\n",
    "print(np.arange(0, 5/3, 0.333333334))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `np.linspace`\n",
    "For this reason, it is generally preferable to use the `linspace` function instead of `arange` when working with floats. The `linspace` function returns an array containing a specific number of points evenly distributed between two values (note that the maximum value is *included*, contrary to `arange`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.         0.33333333 0.66666667 1.         1.33333333 1.66666667]\n"
     ]
    }
   ],
   "source": [
    "print(np.linspace(0, 5/3, 6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `np.rand` and `np.randn`\n",
    "A number of functions are available in NumPy's `random` module to create `ndarray`s initialized with random values.\n",
    "For example, here is a 3x4 matrix initialized with random floats between 0 and 1 (uniform distribution):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.31506811, 0.9962061 , 0.22576662, 0.90354811],\n",
       "       [0.75222452, 0.76662349, 0.1099069 , 0.98423873],\n",
       "       [0.83335318, 0.35623138, 0.67330209, 0.23273007]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.rand(3,4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's a 3x4 matrix containing random floats sampled from a univariate [normal distribution](https://en.wikipedia.org/wiki/Normal_distribution) (Gaussian distribution) of mean 0 and variance 1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.56110261e+00,  2.43164383e-01, -7.35871062e-01,\n",
       "         3.70101675e-04],\n",
       "       [ 1.86890564e-01,  6.30621790e-01,  7.30944692e-01,\n",
       "        -2.12995795e+00],\n",
       "       [-5.61847627e-01, -8.63385596e-01, -3.25545246e-01,\n",
       "         7.48875396e-01]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.randn(3,4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To give you a feel of what these distributions look like, let's use matplotlib (see the [matplotlib tutorial](tools_matplotlib.ipynb) for more details):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.hist(np.random.rand(100000), density=True, bins=100, histtype=\"step\", color=\"blue\", label=\"rand\")\n",
    "plt.hist(np.random.randn(100000), density=True, bins=100, histtype=\"step\", color=\"red\", label=\"randn\")\n",
    "plt.axis([-2.5, 2.5, 0, 1.1])\n",
    "plt.legend(loc = \"upper left\")\n",
    "plt.title(\"Random distributions\")\n",
    "plt.xlabel(\"Value\")\n",
    "plt.ylabel(\"Density\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## np.fromfunction\n",
    "You can also initialize an `ndarray` using a function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[  0.,   1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.,   9.],\n",
       "        [ 10.,  11.,  12.,  13.,  14.,  15.,  16.,  17.,  18.,  19.]],\n",
       "\n",
       "       [[100., 101., 102., 103., 104., 105., 106., 107., 108., 109.],\n",
       "        [110., 111., 112., 113., 114., 115., 116., 117., 118., 119.]],\n",
       "\n",
       "       [[200., 201., 202., 203., 204., 205., 206., 207., 208., 209.],\n",
       "        [210., 211., 212., 213., 214., 215., 216., 217., 218., 219.]]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def my_function(z, y, x):\n",
    "    return x + 10 * y + 100 * z\n",
    "\n",
    "np.fromfunction(my_function, (3, 2, 10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy first creates three `ndarray`s (one per dimension), each of shape `(3, 2, 10)`. Each array has values equal to the coordinate along a specific axis. For example, all elements in the `z` array are equal to their z-coordinate:\n",
    "\n",
    "    [[[ 0.  0.  0.  0.  0.  0.  0.  0.  0.  0.]\n",
    "      [ 0.  0.  0.  0.  0.  0.  0.  0.  0.  0.]]\n",
    "    \n",
    "     [[ 1.  1.  1.  1.  1.  1.  1.  1.  1.  1.]\n",
    "      [ 1.  1.  1.  1.  1.  1.  1.  1.  1.  1.]]\n",
    "    \n",
    "     [[ 2.  2.  2.  2.  2.  2.  2.  2.  2.  2.]\n",
    "      [ 2.  2.  2.  2.  2.  2.  2.  2.  2.  2.]]]\n",
    "\n",
    "So the terms `x`, `y` and `z` in the expression `x + 10 * y + 100 * z` above are in fact `ndarray`s (we will discuss arithmetic operations on arrays below).  The point is that the function `my_function` is only called *once*, instead of once per element. This makes initialization very efficient."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Array data\n",
    "## `dtype`\n",
    "NumPy's `ndarray`s are also efficient in part because all their elements must have the same type (usually numbers).\n",
    "You can check what the data type is by looking at the `dtype` attribute:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int64 [1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "c = np.arange(1, 5)\n",
    "print(c.dtype, c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "float64 [1. 2. 3. 4.]\n"
     ]
    }
   ],
   "source": [
    "c = np.arange(1.0, 5.0)\n",
    "print(c.dtype, c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instead of letting NumPy guess what data type to use, you can set it explicitly when creating an array by setting the `dtype` parameter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "complex64 [1.+0.j 2.+0.j 3.+0.j 4.+0.j]\n"
     ]
    }
   ],
   "source": [
    "d = np.arange(1, 5, dtype=np.complex64)\n",
    "print(d.dtype, d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Available data types include signed `int8`, `int16`, `int32`, `int64`, unsigned `uint8`|`16`|`32`|`64`, `float16`|`32`|`64` and `complex64`|`128`. Check out the documentation for the [basic types](https://numpy.org/doc/stable/user/basics.types.html) and [sized aliases](https://numpy.org/doc/stable/reference/arrays.scalars.html#sized-aliases) for the full list.\n",
    "\n",
    "## `itemsize`\n",
    "The `itemsize` attribute returns the size (in bytes) of each item:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e = np.arange(1, 5, dtype=np.complex64)\n",
    "e.itemsize"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `data` buffer\n",
    "An array's data is actually stored in memory as a flat (one dimensional) byte buffer. It is available *via* the `data` attribute (you will rarely need it, though)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<memory at 0x7fb409690ad0>"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = np.array([[1,2],[1000, 2000]], dtype=np.int32)\n",
    "f.data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In python 2, `f.data` is a buffer. In python 3, it is a memoryview."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b'\\x01\\x00\\x00\\x00\\x02\\x00\\x00\\x00\\xe8\\x03\\x00\\x00\\xd0\\x07\\x00\\x00'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "if hasattr(f.data, \"tobytes\"):\n",
    "    data_bytes = f.data.tobytes() # python 3\n",
    "else:\n",
    "    data_bytes = memoryview(f.data).tobytes() # python 2\n",
    "\n",
    "data_bytes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Several `ndarray`s can share the same data buffer, meaning that modifying one will also modify the others. We will see an example in a minute."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reshaping an array\n",
    "## In place\n",
    "Changing the shape of an `ndarray` is as simple as setting its `shape` attribute. However, the array's size must remain the same."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]\n",
      "Rank: 1\n"
     ]
    }
   ],
   "source": [
    "g = np.arange(24)\n",
    "print(g)\n",
    "print(\"Rank:\", g.ndim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]\n",
      " [12 13 14 15]\n",
      " [16 17 18 19]\n",
      " [20 21 22 23]]\n",
      "Rank: 2\n"
     ]
    }
   ],
   "source": [
    "g.shape = (6, 4)\n",
    "print(g)\n",
    "print(\"Rank:\", g.ndim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 0  1  2  3]\n",
      "  [ 4  5  6  7]\n",
      "  [ 8  9 10 11]]\n",
      "\n",
      " [[12 13 14 15]\n",
      "  [16 17 18 19]\n",
      "  [20 21 22 23]]]\n",
      "Rank: 3\n"
     ]
    }
   ],
   "source": [
    "g.shape = (2, 3, 4)\n",
    "print(g)\n",
    "print(\"Rank:\", g.ndim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `reshape`\n",
    "The `reshape` function returns a new `ndarray` object pointing at the *same* data. This means that modifying one array will also modify the other."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3  4  5]\n",
      " [ 6  7  8  9 10 11]\n",
      " [12 13 14 15 16 17]\n",
      " [18 19 20 21 22 23]]\n",
      "Rank: 2\n"
     ]
    }
   ],
   "source": [
    "g2 = g.reshape(4,6)\n",
    "print(g2)\n",
    "print(\"Rank:\", g2.ndim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set item at row 1, col 2 to 999 (more about indexing below)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  0,   1,   2,   3,   4,   5],\n",
       "       [  6,   7, 999,   9,  10,  11],\n",
       "       [ 12,  13,  14,  15,  16,  17],\n",
       "       [ 18,  19,  20,  21,  22,  23]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g2[1, 2] = 999\n",
    "g2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The corresponding element in `g` has been modified."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[  0,   1,   2,   3],\n",
       "        [  4,   5,   6,   7],\n",
       "        [999,   9,  10,  11]],\n",
       "\n",
       "       [[ 12,  13,  14,  15],\n",
       "        [ 16,  17,  18,  19],\n",
       "        [ 20,  21,  22,  23]]])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `ravel`\n",
    "Finally, the `ravel` function returns a new one-dimensional `ndarray` that also points to the same data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  0,   1,   2,   3,   4,   5,   6,   7, 999,   9,  10,  11,  12,\n",
       "        13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.ravel()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Arithmetic operations\n",
    "All the usual arithmetic operators (`+`, `-`, `*`, `/`, `//`, `**`, etc.) can be used with `ndarray`s. They apply *elementwise*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a + b  = [19 27 35 43]\n",
      "a - b  = [ 9 19 29 39]\n",
      "a * b  = [70 92 96 82]\n",
      "a / b  = [ 2.8         5.75       10.66666667 20.5       ]\n",
      "a // b  = [ 2  5 10 20]\n",
      "a % b  = [4 3 2 1]\n",
      "a ** b = [537824 279841  32768   1681]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([14, 23, 32, 41])\n",
    "b = np.array([5,  4,  3,  2])\n",
    "print(\"a + b  =\", a + b)\n",
    "print(\"a - b  =\", a - b)\n",
    "print(\"a * b  =\", a * b)\n",
    "print(\"a / b  =\", a / b)\n",
    "print(\"a // b  =\", a // b)\n",
    "print(\"a % b  =\", a % b)\n",
    "print(\"a ** b =\", a ** b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the multiplication is *not* a matrix multiplication. We will discuss matrix operations below.\n",
    "\n",
    "The arrays must have the same shape. If they do not, NumPy will apply the *broadcasting rules*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Broadcasting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In general, when NumPy expects arrays of the same shape but finds that this is not the case, it applies the so-called *broadcasting* rules:\n",
    "\n",
    "## First rule\n",
    "*If the arrays do not have the same rank, then a 1 will be prepended to the smaller ranking arrays until their ranks match.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0, 1, 2, 3, 4]]])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h = np.arange(5).reshape(1, 1, 5)\n",
    "h"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's try to add a 1D array of shape `(5,)` to this 3D array of shape `(1,1,5)`. Applying the first rule of broadcasting!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[10, 21, 32, 43, 54]]])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h + [10, 20, 30, 40, 50]  # same as: h + [[[10, 20, 30, 40, 50]]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Second rule\n",
    "*Arrays with a 1 along a particular dimension act as if they had the size of the array with the largest shape along that dimension. The value of the array element is repeated along that dimension.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [3, 4, 5]])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k = np.arange(6).reshape(2, 3)\n",
    "k"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's try to add a 2D array of shape `(2,1)` to this 2D `ndarray` of shape `(2, 3)`. NumPy will apply the second rule of broadcasting:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[100, 101, 102],\n",
       "       [203, 204, 205]])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k + [[100], [200]]  # same as: k + [[100, 100, 100], [200, 200, 200]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Combining rules 1 & 2, we can do this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[100, 201, 302],\n",
       "       [103, 204, 305]])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k + [100, 200, 300]  # after rule 1: [[100, 200, 300]], and after rule 2: [[100, 200, 300], [100, 200, 300]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And also, very simply:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1000, 1001, 1002],\n",
       "       [1003, 1004, 1005]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k + 1000  # same as: k + [[1000, 1000, 1000], [1000, 1000, 1000]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Third rule\n",
    "*After rules 1 & 2, the sizes of all arrays must match.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "operands could not be broadcast together with shapes (2,3) (2,) \n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    k + [33, 44]\n",
    "except ValueError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Broadcasting rules are used in many NumPy operations, not just arithmetic operations, as we will see below.\n",
    "For more details about broadcasting, check out [the documentation](https://numpy.org/doc/stable/user/basics.broadcasting.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Upcasting\n",
    "When trying to combine arrays with different `dtype`s, NumPy will *upcast* to a type capable of handling all possible values (regardless of what the *actual* values are)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "uint8 [0 1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "k1 = np.arange(0, 5, dtype=np.uint8)\n",
    "print(k1.dtype, k1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int16 [ 5  7  9 11 13]\n"
     ]
    }
   ],
   "source": [
    "k2 = k1 + np.array([5, 6, 7, 8, 9], dtype=np.int8)\n",
    "print(k2.dtype, k2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that `int16` is required to represent all *possible* `int8` and `uint8` values (from -128 to 255), even though in this case a `uint8` would have sufficed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "float64 [1.5 2.5 3.5 4.5 5.5]\n"
     ]
    }
   ],
   "source": [
    "k3 = k1 + 1.5\n",
    "print(k3.dtype, k3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conditional operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The conditional operators also apply elementwise:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False,  True,  True, False])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m = np.array([20, -5, 30, 40])\n",
    "m < [15, 16, 35, 36]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And using broadcasting:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True,  True, False, False])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m < 25  # equivalent to m < [25, 25, 25, 25]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is most useful in conjunction with boolean indexing (discussed below)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([20, -5])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m[m < 25]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mathematical and statistical functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Many mathematical and statistical functions are available for `ndarray`s.\n",
    "\n",
    "## `ndarray` methods\n",
    "Some functions are simply `ndarray` methods, for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-2.5  3.1  7. ]\n",
      " [10.  11.  12. ]]\n",
      "mean = 6.766666666666667\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[-2.5, 3.1, 7], [10, 11, 12]])\n",
    "print(a)\n",
    "print(\"mean =\", a.mean())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that this computes the mean of all elements in the `ndarray`, regardless of its shape.\n",
    "\n",
    "Here are a few more useful `ndarray` methods:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "min = -2.5\n",
      "max = 12.0\n",
      "sum = 40.6\n",
      "prod = -71610.0\n",
      "std = 5.084835843520964\n",
      "var = 25.855555555555554\n"
     ]
    }
   ],
   "source": [
    "for func in (a.min, a.max, a.sum, a.prod, a.std, a.var):\n",
    "    print(func.__name__, \"=\", func())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These functions accept an optional argument `axis` which lets you ask for the operation to be performed on elements along the given axis. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1,  2,  3],\n",
       "        [ 4,  5,  6,  7],\n",
       "        [ 8,  9, 10, 11]],\n",
       "\n",
       "       [[12, 13, 14, 15],\n",
       "        [16, 17, 18, 19],\n",
       "        [20, 21, 22, 23]]])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c=np.arange(24).reshape(2,3,4)\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[12, 14, 16, 18],\n",
       "       [20, 22, 24, 26],\n",
       "       [28, 30, 32, 34]])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c.sum(axis=0)  # sum across matrices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[12, 15, 18, 21],\n",
       "       [48, 51, 54, 57]])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c.sum(axis=1)  # sum across rows"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also sum over multiple axes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 60,  92, 124])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c.sum(axis=(0,2))  # sum across matrices and columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60, 92, 124)"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0+1+2+3 + 12+13+14+15, 4+5+6+7 + 16+17+18+19, 8+9+10+11 + 20+21+22+23"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Universal functions\n",
    "NumPy also provides fast elementwise functions called *universal functions*, or **ufunc**. They are vectorized wrappers of simple functions. For example `square` returns a new `ndarray` which is a copy of the original `ndarray` except that each element is squared:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  6.25,   9.61,  49.  ],\n",
       "       [100.  , 121.  , 144.  ]])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[-2.5, 3.1, 7], [10, 11, 12]])\n",
    "np.square(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here are a few more useful unary ufuncs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original ndarray\n",
      "[[-2.5  3.1  7. ]\n",
      " [10.  11.  12. ]]\n",
      "\n",
      " absolute\n",
      "[[ 2.5  3.1  7. ]\n",
      " [10.  11.  12. ]]\n",
      "\n",
      " sqrt\n",
      "[[       nan 1.76068169 2.64575131]\n",
      " [3.16227766 3.31662479 3.46410162]]\n",
      "\n",
      " exp\n",
      "[[8.20849986e-02 2.21979513e+01 1.09663316e+03]\n",
      " [2.20264658e+04 5.98741417e+04 1.62754791e+05]]\n",
      "\n",
      " log\n",
      "[[       nan 1.13140211 1.94591015]\n",
      " [2.30258509 2.39789527 2.48490665]]\n",
      "\n",
      " sign\n",
      "[[-1.  1.  1.]\n",
      " [ 1.  1.  1.]]\n",
      "\n",
      " ceil\n",
      "[[-2.  4.  7.]\n",
      " [10. 11. 12.]]\n",
      "\n",
      " modf\n",
      "(array([[-0.5,  0.1,  0. ],\n",
      "       [ 0. ,  0. ,  0. ]]), array([[-2.,  3.,  7.],\n",
      "       [10., 11., 12.]]))\n",
      "\n",
      " isnan\n",
      "[[False False False]\n",
      " [False False False]]\n",
      "\n",
      " cos\n",
      "[[-0.80114362 -0.99913515  0.75390225]\n",
      " [-0.83907153  0.0044257   0.84385396]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/wy/h39t6kb11pnbb0pzhksd_fqh0000gq/T/ipykernel_88441/2634842825.py:5: RuntimeWarning: invalid value encountered in sqrt\n",
      "  print(func(a))\n",
      "/var/folders/wy/h39t6kb11pnbb0pzhksd_fqh0000gq/T/ipykernel_88441/2634842825.py:5: RuntimeWarning: invalid value encountered in log\n",
      "  print(func(a))\n"
     ]
    }
   ],
   "source": [
    "print(\"Original ndarray\")\n",
    "print(a)\n",
    "for func in (np.abs, np.sqrt, np.exp, np.log, np.sign, np.ceil, np.modf, np.isnan, np.cos):\n",
    "    print(\"\\n\", func.__name__)\n",
    "    print(func(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The two warnings are due to the fact that `sqrt()` and `log()` are undefined for negative numbers, which is why there is a `np.nan` value in the first cell of the output of these two functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Binary ufuncs\n",
    "There are also many binary ufuncs, that apply elementwise on two `ndarray`s.  Broadcasting rules are applied if the arrays do not have the same shape:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3,  6,  2, 11])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([1, -2, 3, 4])\n",
    "b = np.array([2, 8, -1, 7])\n",
    "np.add(a, b)  # equivalent to a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False,  True, False])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.greater(a, b)  # equivalent to a > b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 8, 3, 7])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.maximum(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.,  2., -3.,  4.])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.copysign(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Array indexing\n",
    "## One-dimensional arrays\n",
    "One-dimensional NumPy arrays can be accessed more or less like regular python arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "19"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([1, 5, 3, 19, 13, 7, 3])\n",
    "a[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3, 19, 13])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[2:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3, 19, 13,  7])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[2:-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 5])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3, 13,  3])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[2::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3,  7, 13, 19,  3,  5,  1])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, you can modify elements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  1,   5,   3, 999,  13,   7,   3])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[3]=999\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also modify an `ndarray` slice:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  1,   5, 997, 998, 999,   7,   3])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[2:5] = [997, 998, 999]\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Differences with regular python arrays\n",
    "Contrary to regular python arrays, if you assign a single value to an `ndarray` slice, it is copied across the whole slice, thanks to broadcasting rules discussed above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  5, -1, -1, -1,  7,  3])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[2:5] = -1\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also, you cannot grow or shrink `ndarray`s this way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cannot copy sequence with size 6 to array axis with dimension 3\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    a[2:5] = [1,2,3,4,5,6]  # too long\n",
    "except ValueError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You cannot delete elements either:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cannot delete array elements\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    del a[2:5]\n",
    "except ValueError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Last but not least, `ndarray` **slices are actually *views*** on the same data buffer. This means that if you create a slice and modify it, you are actually going to modify the original `ndarray` as well!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([   1,    5,   -1, 1000,   -1,    7,    3])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_slice = a[2:6]\n",
    "a_slice[1] = 1000\n",
    "a  # the original array was modified!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  -1, 2000,   -1,    7])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[3] = 2000\n",
    "a_slice  # similarly, modifying the original array modifies the slice!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want a copy of the data, you need to use the `copy` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([   1,    5,   -1, 2000,   -1,    7,    3])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "another_slice = a[2:6].copy()\n",
    "another_slice[1] = 3000\n",
    "a  # the original array is untouched"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  -1, 3000,   -1,    7])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[3] = 4000\n",
    "another_slice  # similarly, modifying the original array does not affect the slice copy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multidimensional arrays\n",
    "Multidimensional arrays can be accessed in a similar way by providing an index or slice for each axis, separated by commas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11],\n",
       "       [12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23],\n",
       "       [24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35],\n",
       "       [36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47]])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.arange(48).reshape(4, 12)\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[1, 2]  # row 1, col 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23])"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[1, :]  # row 1, all columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, 13, 25, 37])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[:, 1]  # all rows, column 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Caution**: note the subtle difference between these two expressions: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[1, :]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23]])"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[1:2, :]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first expression returns row 1 as a 1D array of shape `(12,)`, while the second returns that same row as a 2D array of shape `(1, 12)`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fancy indexing\n",
    "You may also specify a list of indices that you are interested in. This is referred to as *fancy indexing*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  3,  4],\n",
       "       [26, 27, 28]])"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[(0,2), 2:5]  # rows 0 and 2, columns 2 to 4 (5-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[11,  2, 11],\n",
       "       [23, 14, 23],\n",
       "       [35, 26, 35],\n",
       "       [47, 38, 47]])"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[:, (-1, 2, -1)]  # all rows, columns -1 (last), 2 and -1 (again, and in this order)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you provide multiple index arrays, you get a 1D `ndarray` containing the values of the elements at the specified coordinates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([41, 33, 37, 33])"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[(-1, 2, -1, 2), (5, 9, 1, 9)]  # returns a 1D array with b[-1, 5], b[2, 9], b[-1, 1] and b[2, 9] (again)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Higher dimensions\n",
    "Everything works just as well with higher dimensional arrays, but it's useful to look at a few examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1,  2,  3,  4,  5],\n",
       "        [ 6,  7,  8,  9, 10, 11]],\n",
       "\n",
       "       [[12, 13, 14, 15, 16, 17],\n",
       "        [18, 19, 20, 21, 22, 23]],\n",
       "\n",
       "       [[24, 25, 26, 27, 28, 29],\n",
       "        [30, 31, 32, 33, 34, 35]],\n",
       "\n",
       "       [[36, 37, 38, 39, 40, 41],\n",
       "        [42, 43, 44, 45, 46, 47]]])"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = b.reshape(4,2,6)\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "34"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c[2, 1, 4]  # matrix 2, row 1, col 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([27, 33])"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c[2, :, 3]  # matrix 2, all rows, col 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you omit coordinates for some axes, then all elements in these axes are returned:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([30, 31, 32, 33, 34, 35])"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c[2, 1]  # Return matrix 2, row 1, all columns.  This is equivalent to c[2, 1, :]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ellipsis (`...`)\n",
    "You may also write an ellipsis (`...`) to ask that all non-specified axes be entirely included."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[24, 25, 26, 27, 28, 29],\n",
       "       [30, 31, 32, 33, 34, 35]])"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c[2, ...]  #  matrix 2, all rows, all columns.  This is equivalent to c[2, :, :]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([30, 31, 32, 33, 34, 35])"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c[2, 1, ...]  # matrix 2, row 1, all columns.  This is equivalent to c[2, 1, :]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([27, 33])"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c[2, ..., 3]  # matrix 2, all rows, column 3.  This is equivalent to c[2, :, 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 3,  9],\n",
       "       [15, 21],\n",
       "       [27, 33],\n",
       "       [39, 45]])"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c[..., 3]  # all matrices, all rows, column 3.  This is equivalent to c[:, :, 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Boolean indexing\n",
    "You can also provide an `ndarray` of boolean values on one axis to specify the indices that you want to access."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11],\n",
       "       [12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23],\n",
       "       [24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35],\n",
       "       [36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47]])"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.arange(48).reshape(4, 12)\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11],\n",
       "       [24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35]])"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rows_on = np.array([True, False, True, False])\n",
    "b[rows_on, :]  # Rows 0 and 2, all columns. Equivalent to b[(0, 2), :]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  4,  7, 10],\n",
       "       [13, 16, 19, 22],\n",
       "       [25, 28, 31, 34],\n",
       "       [37, 40, 43, 46]])"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cols_on = np.array([False, True, False] * 4)\n",
    "b[:, cols_on]  # All rows, columns 1, 4, 7 and 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `np.ix_`\n",
    "You cannot use boolean indexing this way on multiple axes, but you can work around this by using the `ix_` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  4,  7, 10],\n",
       "       [25, 28, 31, 34]])"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[np.ix_(rows_on, cols_on)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[0],\n",
       "        [2]]),\n",
       " array([[ 1,  4,  7, 10]]))"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ix_(rows_on, cols_on)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you use a boolean array that has the same shape as the `ndarray`, then you get in return a 1D array containing all the values that have `True` at their coordinate. This is generally used along with conditional operators:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  4,  7, 10, 13, 16, 19, 22, 25, 28, 31, 34, 37, 40, 43, 46])"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[b % 3 == 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Iterating\n",
    "Iterating over `ndarray`s is very similar to iterating over regular python arrays. Note that iterating over multidimensional arrays is done with respect to the first axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1,  2,  3],\n",
       "        [ 4,  5,  6,  7],\n",
       "        [ 8,  9, 10, 11]],\n",
       "\n",
       "       [[12, 13, 14, 15],\n",
       "        [16, 17, 18, 19],\n",
       "        [20, 21, 22, 23]]])"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = np.arange(24).reshape(2, 3, 4)  # A 3D array (composed of two 3x4 matrices)\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Item:\n",
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]]\n",
      "Item:\n",
      "[[12 13 14 15]\n",
      " [16 17 18 19]\n",
      " [20 21 22 23]]\n"
     ]
    }
   ],
   "source": [
    "for m in c:\n",
    "    print(\"Item:\")\n",
    "    print(m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Item:\n",
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]]\n",
      "Item:\n",
      "[[12 13 14 15]\n",
      " [16 17 18 19]\n",
      " [20 21 22 23]]\n"
     ]
    }
   ],
   "source": [
    "for i in range(len(c)):  # Note that len(c) == c.shape[0]\n",
    "    print(\"Item:\")\n",
    "    print(c[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to iterate on *all* elements in the `ndarray`, simply iterate over the `flat` attribute:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Item: 0\n",
      "Item: 1\n",
      "Item: 2\n",
      "Item: 3\n",
      "Item: 4\n",
      "Item: 5\n",
      "Item: 6\n",
      "Item: 7\n",
      "Item: 8\n",
      "Item: 9\n",
      "Item: 10\n",
      "Item: 11\n",
      "Item: 12\n",
      "Item: 13\n",
      "Item: 14\n",
      "Item: 15\n",
      "Item: 16\n",
      "Item: 17\n",
      "Item: 18\n",
      "Item: 19\n",
      "Item: 20\n",
      "Item: 21\n",
      "Item: 22\n",
      "Item: 23\n"
     ]
    }
   ],
   "source": [
    "for i in c.flat:\n",
    "    print(\"Item:\", i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Stacking arrays\n",
    "It is often useful to stack together different arrays. NumPy offers several functions to do just that. Let's start by creating a few arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q1 = np.full((3,4), 1.0)\n",
    "q1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2., 2., 2., 2.],\n",
       "       [2., 2., 2., 2.],\n",
       "       [2., 2., 2., 2.],\n",
       "       [2., 2., 2., 2.]])"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q2 = np.full((4,4), 2.0)\n",
    "q2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3., 3., 3., 3.],\n",
       "       [3., 3., 3., 3.],\n",
       "       [3., 3., 3., 3.]])"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q3 = np.full((3,4), 3.0)\n",
    "q3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `vstack`\n",
    "Now let's stack them vertically using `vstack`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [2., 2., 2., 2.],\n",
       "       [2., 2., 2., 2.],\n",
       "       [2., 2., 2., 2.],\n",
       "       [2., 2., 2., 2.],\n",
       "       [3., 3., 3., 3.],\n",
       "       [3., 3., 3., 3.],\n",
       "       [3., 3., 3., 3.]])"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q4 = np.vstack((q1, q2, q3))\n",
    "q4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10, 4)"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q4.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It was possible because q1, q2 and q3 all have the same shape (except for the vertical axis, but that's ok since we are stacking on that axis).\n",
    "\n",
    "## `hstack`\n",
    "We can also stack arrays horizontally using `hstack`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1., 3., 3., 3., 3.],\n",
       "       [1., 1., 1., 1., 3., 3., 3., 3.],\n",
       "       [1., 1., 1., 1., 3., 3., 3., 3.]])"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q5 = np.hstack((q1, q3))\n",
    "q5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 8)"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q5.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is possible because q1 and q3 both have 3 rows. But since q2 has 4 rows, it cannot be stacked horizontally with q1 and q3:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "all the input array dimensions for the concatenation axis must match exactly, but along dimension 0, the array at index 0 has size 3 and the array at index 1 has size 4\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    q5 = np.hstack((q1, q2, q3))\n",
    "except ValueError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `concatenate`\n",
    "The `concatenate` function stacks arrays along any given existing axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [2., 2., 2., 2.],\n",
       "       [2., 2., 2., 2.],\n",
       "       [2., 2., 2., 2.],\n",
       "       [2., 2., 2., 2.],\n",
       "       [3., 3., 3., 3.],\n",
       "       [3., 3., 3., 3.],\n",
       "       [3., 3., 3., 3.]])"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q7 = np.concatenate((q1, q2, q3), axis=0)  # Equivalent to vstack\n",
    "q7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10, 4)"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q7.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you might guess, `hstack` is equivalent to calling `concatenate` with `axis=1`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `stack`\n",
    "The `stack` function stacks arrays along a new axis. All arrays have to have the same shape."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[1., 1., 1., 1.],\n",
       "        [1., 1., 1., 1.],\n",
       "        [1., 1., 1., 1.]],\n",
       "\n",
       "       [[3., 3., 3., 3.],\n",
       "        [3., 3., 3., 3.],\n",
       "        [3., 3., 3., 3.]]])"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q8 = np.stack((q1, q3))\n",
    "q8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3, 4)"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q8.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Splitting arrays\n",
    "Splitting is the opposite of stacking. For example, let's use the `vsplit` function to split a matrix vertically.\n",
    "\n",
    "First let's create a 6x4 matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11],\n",
       "       [12, 13, 14, 15],\n",
       "       [16, 17, 18, 19],\n",
       "       [20, 21, 22, 23]])"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r = np.arange(24).reshape(6,4)\n",
    "r"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's split it in three equal parts, vertically:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2, 3],\n",
       "       [4, 5, 6, 7]])"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r1, r2, r3 = np.vsplit(r, 3)\n",
    "r1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 8,  9, 10, 11],\n",
       "       [12, 13, 14, 15]])"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[16, 17, 18, 19],\n",
       "       [20, 21, 22, 23]])"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is also a `split` function which splits an array along any given axis. Calling `vsplit` is equivalent to calling `split` with `axis=0`. There is also an `hsplit` function, equivalent to calling `split` with `axis=1`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1],\n",
       "       [ 4,  5],\n",
       "       [ 8,  9],\n",
       "       [12, 13],\n",
       "       [16, 17],\n",
       "       [20, 21]])"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r4, r5 = np.hsplit(r, 2)\n",
    "r4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  3],\n",
       "       [ 6,  7],\n",
       "       [10, 11],\n",
       "       [14, 15],\n",
       "       [18, 19],\n",
       "       [22, 23]])"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Transposing arrays\n",
    "The `transpose` method creates a new view on an `ndarray`'s data, with axes permuted in the given order.\n",
    "\n",
    "For example, let's create a 3D array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1,  2],\n",
       "        [ 3,  4,  5]],\n",
       "\n",
       "       [[ 6,  7,  8],\n",
       "        [ 9, 10, 11]],\n",
       "\n",
       "       [[12, 13, 14],\n",
       "        [15, 16, 17]],\n",
       "\n",
       "       [[18, 19, 20],\n",
       "        [21, 22, 23]]])"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = np.arange(24).reshape(4,2,3)\n",
    "t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's create an `ndarray` such that the axes `0, 1, 2` (depth, height, width) are re-ordered to `1, 2, 0` (depth→width, height→depth, width→height):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  6, 12, 18],\n",
       "        [ 1,  7, 13, 19],\n",
       "        [ 2,  8, 14, 20]],\n",
       "\n",
       "       [[ 3,  9, 15, 21],\n",
       "        [ 4, 10, 16, 22],\n",
       "        [ 5, 11, 17, 23]]])"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t1 = t.transpose((1,2,0))\n",
    "t1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3, 4)"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t1.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default, `transpose` reverses the order of the dimensions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  6, 12, 18],\n",
       "        [ 3,  9, 15, 21]],\n",
       "\n",
       "       [[ 1,  7, 13, 19],\n",
       "        [ 4, 10, 16, 22]],\n",
       "\n",
       "       [[ 2,  8, 14, 20],\n",
       "        [ 5, 11, 17, 23]]])"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t2 = t.transpose()  # equivalent to t.transpose((2, 1, 0))\n",
    "t2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 2, 4)"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t2.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy provides a convenience function `swapaxes` to swap two axes. For example, let's create a new view of `t` with depth and height swapped:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1,  2],\n",
       "        [ 6,  7,  8],\n",
       "        [12, 13, 14],\n",
       "        [18, 19, 20]],\n",
       "\n",
       "       [[ 3,  4,  5],\n",
       "        [ 9, 10, 11],\n",
       "        [15, 16, 17],\n",
       "        [21, 22, 23]]])"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t3 = t.swapaxes(0,1)  # equivalent to t.transpose((1, 0, 2))\n",
    "t3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 4, 3)"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t3.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Linear algebra\n",
    "NumPy 2D arrays can be used to represent matrices efficiently in python. We will just quickly go through some of the main matrix operations available. For more details about Linear Algebra, vectors and matrices, go through the [Linear Algebra tutorial](math_linear_algebra.ipynb).\n",
    "\n",
    "## Matrix transpose\n",
    "The `T` attribute is equivalent to calling `transpose()` when the rank is ≥2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2, 3, 4],\n",
       "       [5, 6, 7, 8, 9]])"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m1 = np.arange(10).reshape(2,5)\n",
    "m1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 5],\n",
       "       [1, 6],\n",
       "       [2, 7],\n",
       "       [3, 8],\n",
       "       [4, 9]])"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m1.T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `T` attribute has no effect on rank 0 (empty) or rank 1 arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m2 = np.arange(5)\n",
    "m2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m2.T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can get the desired transposition by first reshaping the 1D array to a single-row matrix (2D):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2, 3, 4]])"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m2r = m2.reshape(1,5)\n",
    "m2r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0],\n",
       "       [1],\n",
       "       [2],\n",
       "       [3],\n",
       "       [4]])"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m2r.T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matrix multiplication\n",
    "Let's create two matrices and execute a [matrix multiplication](https://en.wikipedia.org/wiki/Matrix_multiplication) using the `dot()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2, 3, 4],\n",
       "       [5, 6, 7, 8, 9]])"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n1 = np.arange(10).reshape(2, 5)\n",
    "n1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2],\n",
       "       [ 3,  4,  5],\n",
       "       [ 6,  7,  8],\n",
       "       [ 9, 10, 11],\n",
       "       [12, 13, 14]])"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n2 = np.arange(15).reshape(5,3)\n",
    "n2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 90, 100, 110],\n",
       "       [240, 275, 310]])"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n1.dot(n2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Caution**: as mentioned previously, `n1*n2` is *not* a matrix multiplication, it is an elementwise product (also called a [Hadamard product](https://en.wikipedia.org/wiki/Hadamard_product_(matrices)))."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matrix inverse and pseudo-inverse\n",
    "Many of the linear algebra functions are available in the `numpy.linalg` module, in particular the `inv` function to compute a square matrix's inverse:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3],\n",
       "       [ 5,  7, 11],\n",
       "       [21, 29, 31]])"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy.linalg as linalg\n",
    "\n",
    "m3 = np.array([[1,2,3],[5,7,11],[21,29,31]])\n",
    "m3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-2.31818182,  0.56818182,  0.02272727],\n",
       "       [ 1.72727273, -0.72727273,  0.09090909],\n",
       "       [-0.04545455,  0.29545455, -0.06818182]])"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linalg.inv(m3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also compute the [pseudoinverse](https://en.wikipedia.org/wiki/Moore%E2%80%93Penrose_pseudoinverse) using `pinv`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-2.31818182,  0.56818182,  0.02272727],\n",
       "       [ 1.72727273, -0.72727273,  0.09090909],\n",
       "       [-0.04545455,  0.29545455, -0.06818182]])"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linalg.pinv(m3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Identity matrix\n",
    "The product of a matrix by its inverse returns the identity matrix (with small floating point errors):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.00000000e+00, -1.66533454e-16,  0.00000000e+00],\n",
       "       [ 6.31439345e-16,  1.00000000e+00, -1.38777878e-16],\n",
       "       [ 5.21110932e-15, -2.38697950e-15,  1.00000000e+00]])"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m3.dot(linalg.inv(m3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can create an identity matrix of size NxN by calling `eye(N)` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0.],\n",
       "       [0., 1., 0.],\n",
       "       [0., 0., 1.]])"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.eye(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## QR decomposition\n",
    "The `qr` function computes the [QR decomposition](https://en.wikipedia.org/wiki/QR_decomposition) of a matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.04627448,  0.98786672,  0.14824986],\n",
       "       [-0.23137241,  0.13377362, -0.96362411],\n",
       "       [-0.97176411, -0.07889213,  0.22237479]])"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q, r = linalg.qr(m3)\n",
    "q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-21.61018278, -29.89331494, -32.80860727],\n",
       "       [  0.        ,   0.62427688,   1.9894538 ],\n",
       "       [  0.        ,   0.        ,  -3.26149699]])"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  2.,  3.],\n",
       "       [ 5.,  7., 11.],\n",
       "       [21., 29., 31.]])"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q.dot(r)  # q.r equals m3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Determinant\n",
    "The `det` function computes the [matrix determinant](https://en.wikipedia.org/wiki/Determinant):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "43.99999999999997"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linalg.det(m3)  # Computes the matrix determinant"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Eigenvalues and eigenvectors\n",
    "The `eig` function computes the [eigenvalues and eigenvectors](https://en.wikipedia.org/wiki/Eigenvalues_and_eigenvectors) of a square matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([42.26600592, -0.35798416, -2.90802176])"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eigenvalues, eigenvectors = linalg.eig(m3)\n",
    "eigenvalues # λ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.08381182, -0.76283526, -0.18913107],\n",
       "       [-0.3075286 ,  0.64133975, -0.6853186 ],\n",
       "       [-0.94784057, -0.08225377,  0.70325518]])"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eigenvectors # v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 6.66133815e-15,  1.66533454e-15, -3.10862447e-15],\n",
       "       [ 7.10542736e-15,  5.16253706e-15, -5.32907052e-15],\n",
       "       [ 3.55271368e-14,  4.94743135e-15, -9.76996262e-15]])"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m3.dot(eigenvectors) - eigenvalues * eigenvectors  # m3.v - λ*v = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Singular Value Decomposition\n",
    "The `svd` function takes a matrix and returns its [singular value decomposition](https://en.wikipedia.org/wiki/Singular_value_decomposition):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 0, 0, 2],\n",
       "       [0, 0, 3, 0, 0],\n",
       "       [0, 0, 0, 0, 0],\n",
       "       [0, 2, 0, 0, 0]])"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m4 = np.array([[1,0,0,0,2], [0,0,3,0,0], [0,0,0,0,0], [0,2,0,0,0]])\n",
    "m4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.,  1.,  0.,  0.],\n",
       "       [ 1.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0., -1.],\n",
       "       [ 0.,  0.,  1.,  0.]])"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "U, S_diag, V = linalg.svd(m4)\n",
    "U"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3.        , 2.23606798, 2.        , 0.        ])"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S_diag"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `svd` function just returns the values in the diagonal of Σ, but we want the full Σ matrix, so let's create it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3.        , 0.        , 0.        , 0.        , 0.        ],\n",
       "       [0.        , 2.23606798, 0.        , 0.        , 0.        ],\n",
       "       [0.        , 0.        , 2.        , 0.        , 0.        ],\n",
       "       [0.        , 0.        , 0.        , 0.        , 0.        ]])"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S = np.zeros((4, 5))\n",
    "S[np.diag_indices(4)] = S_diag\n",
    "S  # Σ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.        ,  0.        ,  1.        , -0.        ,  0.        ],\n",
       "       [ 0.4472136 ,  0.        ,  0.        ,  0.        ,  0.89442719],\n",
       "       [-0.        ,  1.        ,  0.        , -0.        ,  0.        ],\n",
       "       [ 0.        ,  0.        ,  0.        ,  1.        ,  0.        ],\n",
       "       [-0.89442719,  0.        ,  0.        ,  0.        ,  0.4472136 ]])"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "V"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0., 0., 2.],\n",
       "       [0., 0., 3., 0., 0.],\n",
       "       [0., 0., 0., 0., 0.],\n",
       "       [0., 2., 0., 0., 0.]])"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "U.dot(S).dot(V) # U.Σ.V == m4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Diagonal and trace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  7, 31])"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.diag(m3)  # the values in the diagonal of m3 (top left to bottom right)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "39"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m3.trace()  # equivalent to np.diag(m3).sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Solving a system of linear scalar equations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `solve` function solves a system of linear scalar equations, such as:\n",
    "\n",
    "* $2x + 6y = 6$\n",
    "* $5x + 3y = -9$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-3.,  2.])"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "coeffs  = np.array([[2, 6], [5, 3]])\n",
    "depvars = np.array([6, -9])\n",
    "solution = linalg.solve(coeffs, depvars)\n",
    "solution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's check the solution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([ 6., -9.]), array([ 6, -9]))"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "coeffs.dot(solution), depvars  # yep, it's the same"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looks good! Another way to check the solution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.allclose(coeffs.dot(solution), depvars)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Vectorization\n",
    "Instead of executing operations on individual array items, one at a time, your code is much more efficient if you try to stick to array operations. This is called *vectorization*. This way, you can benefit from NumPy's many optimizations.\n",
    "\n",
    "For example, let's say we want to generate a 768x1024 array based on the formula $sin(xy/40.5)$. A **bad** option would be to do the math in python using nested loops:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "data = np.empty((768, 1024))\n",
    "for y in range(768):\n",
    "    for x in range(1024):\n",
    "        data[y, x] = math.sin(x * y / 40.5)  # BAD! Very inefficient."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sure, this works, but it's terribly inefficient since the loops are taking place in pure python. Let's vectorize this algorithm. First, we will use NumPy's `meshgrid` function which generates coordinate matrices from coordinate vectors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[   0,    1,    2, ..., 1021, 1022, 1023],\n",
       "       [   0,    1,    2, ..., 1021, 1022, 1023],\n",
       "       [   0,    1,    2, ..., 1021, 1022, 1023],\n",
       "       ...,\n",
       "       [   0,    1,    2, ..., 1021, 1022, 1023],\n",
       "       [   0,    1,    2, ..., 1021, 1022, 1023],\n",
       "       [   0,    1,    2, ..., 1021, 1022, 1023]])"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_coords = np.arange(0, 1024)  # [0, 1, 2, ..., 1023]\n",
    "y_coords = np.arange(0, 768)   # [0, 1, 2, ..., 767]\n",
    "X, Y = np.meshgrid(x_coords, y_coords)\n",
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  0,   0,   0, ...,   0,   0,   0],\n",
       "       [  1,   1,   1, ...,   1,   1,   1],\n",
       "       [  2,   2,   2, ...,   2,   2,   2],\n",
       "       ...,\n",
       "       [765, 765, 765, ..., 765, 765, 765],\n",
       "       [766, 766, 766, ..., 766, 766, 766],\n",
       "       [767, 767, 767, ..., 767, 767, 767]])"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, both `X` and `Y` are 768x1024 arrays, and all values in `X` correspond to the horizontal coordinate, while all values in `Y` correspond to the vertical coordinate.\n",
    "\n",
    "Now we can simply compute the result using array operations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = np.sin(X * Y / 40.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can plot this data using matplotlib's `imshow` function (see the [matplotlib tutorial](tools_matplotlib.ipynb))."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "fig = plt.figure(1, figsize=(7, 6))\n",
    "plt.imshow(data, cmap=\"hot\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Saving and loading\n",
    "NumPy makes it easy to save and load `ndarray`s in binary or text format.\n",
    "\n",
    "## Binary `.npy` format\n",
    "Let's create a random array and save it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.61340716, 0.6785629 , 0.07091271],\n",
       "       [0.60611491, 0.76189645, 0.2167531 ]])"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.random.rand(2,3)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.save(\"my_array\", a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Done! Since the file name contains no file extension, NumPy automatically added `.npy`. Let's take a peek at the file content:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b\"\\x93NUMPY\\x01\\x00v\\x00{'descr': '<f8', 'fortran_order': False, 'shape': (2, 3), }                                                          \\nEB\\x17\\x0e\\x08\\xa1\\xe3?O^\\xcc\\x8b\\xc9\\xb6\\xe5?\\x90(\\r\\xc6U'\\xb2?r\\xcf\\n\\x19Ke\\xe3?\\xf8/q\\xaata\\xe8?H#\\xae\\xbf\\x90\\xbe\\xcb?\""
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "with open(\"my_array.npy\", \"rb\") as f:\n",
    "    content = f.read()\n",
    "\n",
    "content"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To load this file into a NumPy array, simply call `load`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.61340716, 0.6785629 , 0.07091271],\n",
       "       [0.60611491, 0.76189645, 0.2167531 ]])"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_loaded = np.load(\"my_array.npy\")\n",
    "a_loaded"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Text format\n",
    "Let's try saving the array in text format:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savetxt(\"my_array.csv\", a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's look at the file content:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6.134071612560282327e-01 6.785629015384503360e-01 7.091270528067838974e-02\n",
      "6.061149109941494917e-01 7.618964508960734960e-01 2.167530952395060329e-01\n",
      "\n"
     ]
    }
   ],
   "source": [
    "with open(\"my_array.csv\", \"rt\") as f:\n",
    "    print(f.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a CSV file with tabs as delimiters. You can set a different delimiter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savetxt(\"my_array.csv\", a, delimiter=\",\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To load this file, just use `loadtxt`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.61340716, 0.6785629 , 0.07091271],\n",
       "       [0.60611491, 0.76189645, 0.2167531 ]])"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_loaded = np.loadtxt(\"my_array.csv\", delimiter=\",\")\n",
    "a_loaded"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Zipped `.npz` format\n",
    "It is also possible to save multiple arrays in one zipped file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1,  2,  3],\n",
       "        [ 4,  5,  6,  7],\n",
       "        [ 8,  9, 10, 11]],\n",
       "\n",
       "       [[12, 13, 14, 15],\n",
       "        [16, 17, 18, 19],\n",
       "        [20, 21, 22, 23]]], dtype=uint8)"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.arange(24, dtype=np.uint8).reshape(2, 3, 4)\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savez(\"my_arrays\", my_a=a, my_b=b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, let's take a peek at the file content. Note that the `.npz` file extension was automatically added."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'b\"PK\\\\x03\\\\x04\\\\x14\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00!\\\\x00\\\\xe5\\\\x92\\\\xa1\\\\xfc\\\\xb0\\\\x00\\\\x00\\\\x00\\\\xb0\\\\x00\\\\x00\\\\x00\\\\x08\\\\x00\\\\x14\\\\x00my_a.npy\\\\x01\\\\x00\\\\x10\\\\x00\\\\xb0\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\xb0\\\\x00\\\\x0[...]'"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "with open(\"my_arrays.npz\", \"rb\") as f:\n",
    "    content = f.read()\n",
    "\n",
    "repr(content)[:180] + \"[...]\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You then load this file like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<numpy.lib.npyio.NpzFile at 0x7fb3d823fa90>"
      ]
     },
     "execution_count": 179,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_arrays = np.load(\"my_arrays.npz\")\n",
    "my_arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a dict-like object which loads the arrays lazily:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "KeysView(<numpy.lib.npyio.NpzFile object at 0x7fb3d823fa90>)"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_arrays.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.61340716, 0.6785629 , 0.07091271],\n",
       "       [0.60611491, 0.76189645, 0.2167531 ]])"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_arrays[\"my_a\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# What's next?\n",
    "Now you know all the fundamentals of NumPy, but there are many more options available. The best way to learn more is to experiment with NumPy, and go through the excellent [reference documentation](https://numpy.org/doc/stable/reference/index.html) to find more functions and features you may be interested in."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.12"
  },
  "toc": {
   "toc_cell": false,
   "toc_number_sections": true,
   "toc_section_display": "block",
   "toc_threshold": 6,
   "toc_window_display": false
  },
  "toc_position": {
   "height": "677px",
   "left": "1195.02px",
   "right": "20px",
   "top": "78px",
   "width": "238px"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}