2a_numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Workshop 2: Numpy and Matplotlib\n",
    "\n",
    "<img src=\"https://media.springernature.com/full/springer-static/image/art%3A10.1038%2Fs41586-020-2649-2/MediaObjects/41586_2020_2649_Fig2_HTML.png\" width=\"600\">\n",
    "(Figure 2 of the Numpy review article (doi:10.1038/s41586-020-2649-2))\n",
    "\n",
    "The NumPy and Matplotlib packages are two of the most fundamental parts of the scientific python \"ecosystem\". Most everything else is built on top of them.\n",
    "\n",
    "# Part I:  NumPy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What did we just do? We __imported__ a package, in particular the NumPy package and gave it a shorter acronym (`np` is arbitrary, but convention).\n",
    "\n",
    "The standard Python library is deliberately kept small, because there are so many different use cases, scientific computing is just one of them.\n",
    "Importing packages brings new variables (mostly functions) into our interpreter which allows us to extend functionality with code written by the community.\n",
    "\n",
    "Specifically, NumPy allows us to operate on (multidimensional) arrays.\n",
    "The NumPy documentation is crucial: http://docs.scipy.org/doc/numpy/reference/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.19.1'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# find out what version we have\n",
    "np.__version__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy NDArrays\n",
    "\n",
    "The core class is the numpy ndarray (n-dimensional array) for which a lot of methods (=functions) are implemented.\n",
    "\n",
    "<img src=\"https://media.springernature.com/full/springer-static/image/art%3A10.1038%2Fs41586-020-2649-2/MediaObjects/41586_2020_2649_Fig1_HTML.png\" width=\"900\">\n",
    "\n",
    "Figure 1 of the NumPy review article with its caption:\n",
    "\n",
    "    a, The NumPy array data structure and its associated metadata fields. b, Indexing an array with slices and steps. These operations return a ‘view’ of the original data. c, Indexing an array with masks, scalar coordinates or other arrays, so that it returns a ‘copy’ of the original data. In the bottom example, an array is indexed with other arrays; this broadcasts the indexing arguments before performing the lookup. d, Vectorization efficiently applies operations to groups of elements. e, Broadcasting in the multiplication of two-dimensional arrays. f, Reduction operations act along one or more axes. In this example, an array is summed along select axes to produce a vector, or along two axes consecutively to produce a scalar. g, Example NumPy code, illustrating some of these concepts.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create an array from a list\n",
    "a = np.array([9,0,2,1,0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([9, 0, 2, 1, 0])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# find out the datatype\n",
    "a.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5,)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# find out the shape\n",
    "a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# what is the shape\n",
    "type(a.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# another array with a different datatype and shape\n",
    "b = np.array([[5,3,1,9],[9,2,3,0]], dtype=np.float64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5., 3., 1., 9.],\n",
       "       [9., 2., 3., 0.]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(dtype('float64'), (2, 4))"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check dtype and shape\n",
    "b.dtype, b.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Important Concept__: The fastest varying dimension is the last dimension! The outer level of the hierarchy is the first dimension. (This is called \"c-style\" indexing)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More array creation ##\n",
    "\n",
    "There are lots of ways to create arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create some uniform arrays\n",
    "c = np.zeros((9,9))\n",
    "d = np.ones((3,6,3), dtype=np.complex128)\n",
    "e = np.full((3,3), np.pi)\n",
    "e = np.ones_like(c)\n",
    "f = np.zeros_like(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1., 1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1., 1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create some ranges\n",
    "np.arange(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2.  , 2.25, 2.5 , 2.75, 3.  , 3.25, 3.5 , 3.75])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# arange is left inclusive, right exclusive\n",
    "np.arange(2,4,0.25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2., 3., 4.])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# linearly spaced\n",
    "np.linspace(2,4,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 10.        ,  12.91549665,  16.68100537,  21.5443469 ,\n",
       "        27.82559402,  35.93813664,  46.41588834,  59.94842503,\n",
       "        77.42636827, 100.        ])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# log spaced\n",
    "np.logspace(1,2,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((5, 10), (5, 10))"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# two dimensional grids\n",
    "x = np.linspace(-2*np.pi, 2*np.pi, 10)\n",
    "y = np.linspace(-np.pi, np.pi, 5)\n",
    "xx, yy = np.meshgrid(x, y)\n",
    "xx.shape, yy.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the meshgrid function can be handy to e.g. create 2D arrays of coordinates\n",
    "# here we look at the 1D coordinates x and y, and 2D fields of them: xx and yy\n",
    "# the following lines and plotting will be explained in the next part of the workshop\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.colorbar.Colorbar at 0x7faee8b31190>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(x)\n",
    "plt.plot(y)\n",
    "\n",
    "plt.figure()\n",
    "plt.imshow(xx, origin='lower')\n",
    "plt.colorbar()\n",
    "\n",
    "plt.figure()\n",
    "plt.imshow(yy, origin='lower')\n",
    "plt.colorbar()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexing ##\n",
    "\n",
    "Basic indexing is similar to lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-6.28318531, -4.88692191, -3.4906585 , -2.0943951 , -0.6981317 ,\n",
       "         0.6981317 ,  2.0943951 ,  3.4906585 ,  4.88692191,  6.28318531],\n",
       "       [-6.28318531, -4.88692191, -3.4906585 , -2.0943951 , -0.6981317 ,\n",
       "         0.6981317 ,  2.0943951 ,  3.4906585 ,  4.88692191,  6.28318531],\n",
       "       [-6.28318531, -4.88692191, -3.4906585 , -2.0943951 , -0.6981317 ,\n",
       "         0.6981317 ,  2.0943951 ,  3.4906585 ,  4.88692191,  6.28318531],\n",
       "       [-6.28318531, -4.88692191, -3.4906585 , -2.0943951 , -0.6981317 ,\n",
       "         0.6981317 ,  2.0943951 ,  3.4906585 ,  4.88692191,  6.28318531],\n",
       "       [-6.28318531, -4.88692191, -3.4906585 , -2.0943951 , -0.6981317 ,\n",
       "         0.6981317 ,  2.0943951 ,  3.4906585 ,  4.88692191,  6.28318531]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "xx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-6.283185307179586, 6.283185307179586, 0.6981317007977319)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get some individual elements of xx\n",
    "xx[0,0], xx[-1,-1], xx[3,-5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((10,), (5,))"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get some whole rows and columns\n",
    "xx[0].shape, xx[:,-1].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 1)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get some ranges\n",
    "xx[3:15,3:4].shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are many advanced ways to index arrays. You can read about them in the manual. Here is one example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(25,)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# use a boolean array as an index\n",
    "idx = xx<0\n",
    "yy[idx].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-6.28318531, -4.88692191, -3.4906585 , -2.0943951 , -0.6981317 ,\n",
       "        0.6981317 ,  2.0943951 ,  3.4906585 ,  4.88692191,  6.28318531,\n",
       "       -6.28318531, -4.88692191, -3.4906585 , -2.0943951 , -0.6981317 ,\n",
       "        0.6981317 ,  2.0943951 ,  3.4906585 ,  4.88692191,  6.28318531,\n",
       "       -6.28318531, -4.88692191, -3.4906585 , -2.0943951 , -0.6981317 ,\n",
       "        0.6981317 ,  2.0943951 ,  3.4906585 ,  4.88692191,  6.28318531,\n",
       "       -6.28318531, -4.88692191, -3.4906585 , -2.0943951 , -0.6981317 ,\n",
       "        0.6981317 ,  2.0943951 ,  3.4906585 ,  4.88692191,  6.28318531,\n",
       "       -6.28318531, -4.88692191, -3.4906585 , -2.0943951 , -0.6981317 ,\n",
       "        0.6981317 ,  2.0943951 ,  3.4906585 ,  4.88692191,  6.28318531])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the array got flattened\n",
    "xx.ravel()#.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;31mSignature:\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mravel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0morder\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'C'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
       "\u001b[0;31mDocstring:\u001b[0m\n",
       "Return a contiguous flattened array.\n",
       "\n",
       "A 1-D array, containing the elements of the input, is returned.  A copy is\n",
       "made only if needed.\n",
       "\n",
       "As of NumPy 1.10, the returned array will have the same type as the input\n",
       "array. (for example, a masked array will be returned for a masked array\n",
       "input)\n",
       "\n",
       "Parameters\n",
       "----------\n",
       "a : array_like\n",
       "    Input array.  The elements in `a` are read in the order specified by\n",
       "    `order`, and packed as a 1-D array.\n",
       "order : {'C','F', 'A', 'K'}, optional\n",
       "\n",
       "    The elements of `a` are read using this index order. 'C' means\n",
       "    to index the elements in row-major, C-style order,\n",
       "    with the last axis index changing fastest, back to the first\n",
       "    axis index changing slowest.  'F' means to index the elements\n",
       "    in column-major, Fortran-style order, with the\n",
       "    first index changing fastest, and the last index changing\n",
       "    slowest. Note that the 'C' and 'F' options take no account of\n",
       "    the memory layout of the underlying array, and only refer to\n",
       "    the order of axis indexing.  'A' means to read the elements in\n",
       "    Fortran-like index order if `a` is Fortran *contiguous* in\n",
       "    memory, C-like order otherwise.  'K' means to read the\n",
       "    elements in the order they occur in memory, except for\n",
       "    reversing the data when strides are negative.  By default, 'C'\n",
       "    index order is used.\n",
       "\n",
       "Returns\n",
       "-------\n",
       "y : array_like\n",
       "    y is an array of the same subtype as `a`, with shape ``(a.size,)``.\n",
       "    Note that matrices are special cased for backward compatibility, if `a`\n",
       "    is a matrix, then y is a 1-D ndarray.\n",
       "\n",
       "See Also\n",
       "--------\n",
       "ndarray.flat : 1-D iterator over an array.\n",
       "ndarray.flatten : 1-D array copy of the elements of an array\n",
       "                  in row-major order.\n",
       "ndarray.reshape : Change the shape of an array without changing its data.\n",
       "\n",
       "Notes\n",
       "-----\n",
       "In row-major, C-style order, in two dimensions, the row index\n",
       "varies the slowest, and the column index the quickest.  This can\n",
       "be generalized to multiple dimensions, where row-major order\n",
       "implies that the index along the first axis varies slowest, and\n",
       "the index along the last quickest.  The opposite holds for\n",
       "column-major, Fortran-style index ordering.\n",
       "\n",
       "When a view is desired in as many cases as possible, ``arr.reshape(-1)``\n",
       "may be preferable.\n",
       "\n",
       "Examples\n",
       "--------\n",
       "It is equivalent to ``reshape(-1, order=order)``.\n",
       "\n",
       ">>> x = np.array([[1, 2, 3], [4, 5, 6]])\n",
       ">>> np.ravel(x)\n",
       "array([1, 2, 3, 4, 5, 6])\n",
       "\n",
       ">>> x.reshape(-1)\n",
       "array([1, 2, 3, 4, 5, 6])\n",
       "\n",
       ">>> np.ravel(x, order='F')\n",
       "array([1, 4, 2, 5, 3, 6])\n",
       "\n",
       "When ``order`` is 'A', it will preserve the array's 'C' or 'F' ordering:\n",
       "\n",
       ">>> np.ravel(x.T)\n",
       "array([1, 4, 2, 5, 3, 6])\n",
       ">>> np.ravel(x.T, order='A')\n",
       "array([1, 2, 3, 4, 5, 6])\n",
       "\n",
       "When ``order`` is 'K', it will preserve orderings that are neither 'C'\n",
       "nor 'F', but won't reverse axes:\n",
       "\n",
       ">>> a = np.arange(3)[::-1]; a\n",
       "array([2, 1, 0])\n",
       ">>> a.ravel(order='C')\n",
       "array([2, 1, 0])\n",
       ">>> a.ravel(order='K')\n",
       "array([2, 1, 0])\n",
       "\n",
       ">>> a = np.arange(12).reshape(2,3,2).swapaxes(1,2); a\n",
       "array([[[ 0,  2,  4],\n",
       "        [ 1,  3,  5]],\n",
       "       [[ 6,  8, 10],\n",
       "        [ 7,  9, 11]]])\n",
       ">>> a.ravel(order='C')\n",
       "array([ 0,  2,  4,  1,  3,  5,  6,  8, 10,  7,  9, 11])\n",
       ">>> a.ravel(order='K')\n",
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])\n",
       "\u001b[0;31mFile:\u001b[0m      ~/miniconda3/envs/teach/lib/python3.8/site-packages/numpy/core/fromnumeric.py\n",
       "\u001b[0;31mType:\u001b[0m      function\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# again, you can always check out the doc string of a function\n",
    "# to see what it does\n",
    "np.ravel?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic Math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.302585092994046"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.log(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 1., 2.])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.log10([1,10,100])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.49975978e-32,  6.03020831e-17,  2.09426937e-17,\n",
       "        -5.30287619e-17, -3.93593894e-17,  3.93593894e-17,\n",
       "         5.30287619e-17, -2.09426937e-17, -6.03020831e-17,\n",
       "        -1.49975978e-32],\n",
       "       [ 1.73191211e-16,  6.96364240e-01,  2.41844763e-01,\n",
       "        -6.12372436e-01, -4.54519478e-01,  4.54519478e-01,\n",
       "         6.12372436e-01, -2.41844763e-01, -6.96364240e-01,\n",
       "        -1.73191211e-16],\n",
       "       [ 2.44929360e-16,  9.84807753e-01,  3.42020143e-01,\n",
       "        -8.66025404e-01, -6.42787610e-01,  6.42787610e-01,\n",
       "         8.66025404e-01, -3.42020143e-01, -9.84807753e-01,\n",
       "        -2.44929360e-16],\n",
       "       [ 1.73191211e-16,  6.96364240e-01,  2.41844763e-01,\n",
       "        -6.12372436e-01, -4.54519478e-01,  4.54519478e-01,\n",
       "         6.12372436e-01, -2.41844763e-01, -6.96364240e-01,\n",
       "        -1.73191211e-16],\n",
       "       [ 1.49975978e-32,  6.03020831e-17,  2.09426937e-17,\n",
       "        -5.30287619e-17, -3.93593894e-17,  3.93593894e-17,\n",
       "         5.30287619e-17, -2.09426937e-17, -6.03020831e-17,\n",
       "        -1.49975978e-32]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = np.sin(xx) * np.cos(0.5*yy)\n",
    "f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Array Operations ##\n",
    "\n",
    "There are a huge number of operations available on arrays. All the familiar arithmetic operators are applied on an element-by-element basis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['ALLOW_THREADS',\n",
       " 'AxisError',\n",
       " 'BUFSIZE',\n",
       " 'CLIP',\n",
       " 'ComplexWarning',\n",
       " 'DataSource',\n",
       " 'ERR_CALL',\n",
       " 'ERR_DEFAULT',\n",
       " 'ERR_IGNORE',\n",
       " 'ERR_LOG',\n",
       " 'ERR_PRINT',\n",
       " 'ERR_RAISE',\n",
       " 'ERR_WARN',\n",
       " 'FLOATING_POINT_SUPPORT',\n",
       " 'FPE_DIVIDEBYZERO',\n",
       " 'FPE_INVALID',\n",
       " 'FPE_OVERFLOW',\n",
       " 'FPE_UNDERFLOW',\n",
       " 'False_',\n",
       " 'Inf',\n",
       " 'Infinity',\n",
       " 'MAXDIMS',\n",
       " 'MAY_SHARE_BOUNDS',\n",
       " 'MAY_SHARE_EXACT',\n",
       " 'MachAr',\n",
       " 'ModuleDeprecationWarning',\n",
       " 'NAN',\n",
       " 'NINF',\n",
       " 'NZERO',\n",
       " 'NaN',\n",
       " 'PINF',\n",
       " 'PZERO',\n",
       " 'RAISE',\n",
       " 'RankWarning',\n",
       " 'SHIFT_DIVIDEBYZERO',\n",
       " 'SHIFT_INVALID',\n",
       " 'SHIFT_OVERFLOW',\n",
       " 'SHIFT_UNDERFLOW',\n",
       " 'ScalarType',\n",
       " 'Tester',\n",
       " 'TooHardError',\n",
       " 'True_',\n",
       " 'UFUNC_BUFSIZE_DEFAULT',\n",
       " 'UFUNC_PYVALS_NAME',\n",
       " 'VisibleDeprecationWarning',\n",
       " 'WRAP',\n",
       " '_NoValue',\n",
       " '_UFUNC_API',\n",
       " '__NUMPY_SETUP__',\n",
       " '__all__',\n",
       " '__builtins__',\n",
       " '__cached__',\n",
       " '__config__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__file__',\n",
       " '__getattr__',\n",
       " '__git_revision__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__path__',\n",
       " '__spec__',\n",
       " '__version__',\n",
       " '_add_newdoc_ufunc',\n",
       " '_distributor_init',\n",
       " '_globals',\n",
       " '_mat',\n",
       " '_pytesttester',\n",
       " 'abs',\n",
       " 'absolute',\n",
       " 'add',\n",
       " 'add_docstring',\n",
       " 'add_newdoc',\n",
       " 'add_newdoc_ufunc',\n",
       " 'alen',\n",
       " 'all',\n",
       " 'allclose',\n",
       " 'alltrue',\n",
       " 'amax',\n",
       " 'amin',\n",
       " 'angle',\n",
       " 'any',\n",
       " 'append',\n",
       " 'apply_along_axis',\n",
       " 'apply_over_axes',\n",
       " 'arange',\n",
       " 'arccos',\n",
       " 'arccosh',\n",
       " 'arcsin',\n",
       " 'arcsinh',\n",
       " 'arctan',\n",
       " 'arctan2',\n",
       " 'arctanh',\n",
       " 'argmax',\n",
       " 'argmin',\n",
       " 'argpartition',\n",
       " 'argsort',\n",
       " 'argwhere',\n",
       " 'around',\n",
       " 'array',\n",
       " 'array2string',\n",
       " 'array_equal',\n",
       " 'array_equiv',\n",
       " 'array_repr',\n",
       " 'array_split',\n",
       " 'array_str',\n",
       " 'asanyarray',\n",
       " 'asarray',\n",
       " 'asarray_chkfinite',\n",
       " 'ascontiguousarray',\n",
       " 'asfarray',\n",
       " 'asfortranarray',\n",
       " 'asmatrix',\n",
       " 'asscalar',\n",
       " 'atleast_1d',\n",
       " 'atleast_2d',\n",
       " 'atleast_3d',\n",
       " 'average',\n",
       " 'bartlett',\n",
       " 'base_repr',\n",
       " 'binary_repr',\n",
       " 'bincount',\n",
       " 'bitwise_and',\n",
       " 'bitwise_not',\n",
       " 'bitwise_or',\n",
       " 'bitwise_xor',\n",
       " 'blackman',\n",
       " 'block',\n",
       " 'bmat',\n",
       " 'bool',\n",
       " 'bool8',\n",
       " 'bool_',\n",
       " 'broadcast',\n",
       " 'broadcast_arrays',\n",
       " 'broadcast_to',\n",
       " 'busday_count',\n",
       " 'busday_offset',\n",
       " 'busdaycalendar',\n",
       " 'byte',\n",
       " 'byte_bounds',\n",
       " 'bytes0',\n",
       " 'bytes_',\n",
       " 'c_',\n",
       " 'can_cast',\n",
       " 'cast',\n",
       " 'cbrt',\n",
       " 'cdouble',\n",
       " 'ceil',\n",
       " 'cfloat',\n",
       " 'char',\n",
       " 'character',\n",
       " 'chararray',\n",
       " 'choose',\n",
       " 'clip',\n",
       " 'clongdouble',\n",
       " 'clongfloat',\n",
       " 'column_stack',\n",
       " 'common_type',\n",
       " 'compare_chararrays',\n",
       " 'compat',\n",
       " 'complex',\n",
       " 'complex128',\n",
       " 'complex256',\n",
       " 'complex64',\n",
       " 'complex_',\n",
       " 'complexfloating',\n",
       " 'compress',\n",
       " 'concatenate',\n",
       " 'conj',\n",
       " 'conjugate',\n",
       " 'convolve',\n",
       " 'copy',\n",
       " 'copysign',\n",
       " 'copyto',\n",
       " 'core',\n",
       " 'corrcoef',\n",
       " 'correlate',\n",
       " 'cos',\n",
       " 'cosh',\n",
       " 'count_nonzero',\n",
       " 'cov',\n",
       " 'cross',\n",
       " 'csingle',\n",
       " 'ctypeslib',\n",
       " 'cumprod',\n",
       " 'cumproduct',\n",
       " 'cumsum',\n",
       " 'datetime64',\n",
       " 'datetime_as_string',\n",
       " 'datetime_data',\n",
       " 'deg2rad',\n",
       " 'degrees',\n",
       " 'delete',\n",
       " 'deprecate',\n",
       " 'deprecate_with_doc',\n",
       " 'diag',\n",
       " 'diag_indices',\n",
       " 'diag_indices_from',\n",
       " 'diagflat',\n",
       " 'diagonal',\n",
       " 'diff',\n",
       " 'digitize',\n",
       " 'disp',\n",
       " 'divide',\n",
       " 'divmod',\n",
       " 'dot',\n",
       " 'double',\n",
       " 'dsplit',\n",
       " 'dstack',\n",
       " 'dtype',\n",
       " 'e',\n",
       " 'ediff1d',\n",
       " 'einsum',\n",
       " 'einsum_path',\n",
       " 'emath',\n",
       " 'empty',\n",
       " 'empty_like',\n",
       " 'equal',\n",
       " 'error_message',\n",
       " 'errstate',\n",
       " 'euler_gamma',\n",
       " 'exp',\n",
       " 'exp2',\n",
       " 'expand_dims',\n",
       " 'expm1',\n",
       " 'extract',\n",
       " 'eye',\n",
       " 'fabs',\n",
       " 'fastCopyAndTranspose',\n",
       " 'fft',\n",
       " 'fill_diagonal',\n",
       " 'find_common_type',\n",
       " 'finfo',\n",
       " 'fix',\n",
       " 'flatiter',\n",
       " 'flatnonzero',\n",
       " 'flexible',\n",
       " 'flip',\n",
       " 'fliplr',\n",
       " 'flipud',\n",
       " 'float',\n",
       " 'float128',\n",
       " 'float16',\n",
       " 'float32',\n",
       " 'float64',\n",
       " 'float_',\n",
       " 'float_power',\n",
       " 'floating',\n",
       " 'floor',\n",
       " 'floor_divide',\n",
       " 'fmax',\n",
       " 'fmin',\n",
       " 'fmod',\n",
       " 'format_float_positional',\n",
       " 'format_float_scientific',\n",
       " 'format_parser',\n",
       " 'frexp',\n",
       " 'frombuffer',\n",
       " 'fromfile',\n",
       " 'fromfunction',\n",
       " 'fromiter',\n",
       " 'frompyfunc',\n",
       " 'fromregex',\n",
       " 'fromstring',\n",
       " 'full',\n",
       " 'full_like',\n",
       " 'fv',\n",
       " 'gcd',\n",
       " 'generic',\n",
       " 'genfromtxt',\n",
       " 'geomspace',\n",
       " 'get_array_wrap',\n",
       " 'get_include',\n",
       " 'get_printoptions',\n",
       " 'getbufsize',\n",
       " 'geterr',\n",
       " 'geterrcall',\n",
       " 'geterrobj',\n",
       " 'gradient',\n",
       " 'greater',\n",
       " 'greater_equal',\n",
       " 'half',\n",
       " 'hamming',\n",
       " 'hanning',\n",
       " 'heaviside',\n",
       " 'histogram',\n",
       " 'histogram2d',\n",
       " 'histogram_bin_edges',\n",
       " 'histogramdd',\n",
       " 'hsplit',\n",
       " 'hstack',\n",
       " 'hypot',\n",
       " 'i0',\n",
       " 'identity',\n",
       " 'iinfo',\n",
       " 'imag',\n",
       " 'in1d',\n",
       " 'index_exp',\n",
       " 'indices',\n",
       " 'inexact',\n",
       " 'inf',\n",
       " 'info',\n",
       " 'infty',\n",
       " 'inner',\n",
       " 'insert',\n",
       " 'int',\n",
       " 'int0',\n",
       " 'int16',\n",
       " 'int32',\n",
       " 'int64',\n",
       " 'int8',\n",
       " 'int_',\n",
       " 'intc',\n",
       " 'integer',\n",
       " 'interp',\n",
       " 'intersect1d',\n",
       " 'intp',\n",
       " 'invert',\n",
       " 'ipmt',\n",
       " 'irr',\n",
       " 'is_busday',\n",
       " 'isclose',\n",
       " 'iscomplex',\n",
       " 'iscomplexobj',\n",
       " 'isfinite',\n",
       " 'isfortran',\n",
       " 'isin',\n",
       " 'isinf',\n",
       " 'isnan',\n",
       " 'isnat',\n",
       " 'isneginf',\n",
       " 'isposinf',\n",
       " 'isreal',\n",
       " 'isrealobj',\n",
       " 'isscalar',\n",
       " 'issctype',\n",
       " 'issubclass_',\n",
       " 'issubdtype',\n",
       " 'issubsctype',\n",
       " 'iterable',\n",
       " 'ix_',\n",
       " 'kaiser',\n",
       " 'kron',\n",
       " 'lcm',\n",
       " 'ldexp',\n",
       " 'left_shift',\n",
       " 'less',\n",
       " 'less_equal',\n",
       " 'lexsort',\n",
       " 'lib',\n",
       " 'linalg',\n",
       " 'linspace',\n",
       " 'little_endian',\n",
       " 'load',\n",
       " 'loads',\n",
       " 'loadtxt',\n",
       " 'log',\n",
       " 'log10',\n",
       " 'log1p',\n",
       " 'log2',\n",
       " 'logaddexp',\n",
       " 'logaddexp2',\n",
       " 'logical_and',\n",
       " 'logical_not',\n",
       " 'logical_or',\n",
       " 'logical_xor',\n",
       " 'logspace',\n",
       " 'long',\n",
       " 'longcomplex',\n",
       " 'longdouble',\n",
       " 'longfloat',\n",
       " 'longlong',\n",
       " 'lookfor',\n",
       " 'ma',\n",
       " 'mafromtxt',\n",
       " 'mask_indices',\n",
       " 'mat',\n",
       " 'math',\n",
       " 'matmul',\n",
       " 'matrix',\n",
       " 'matrixlib',\n",
       " 'max',\n",
       " 'maximum',\n",
       " 'maximum_sctype',\n",
       " 'may_share_memory',\n",
       " 'mean',\n",
       " 'median',\n",
       " 'memmap',\n",
       " 'meshgrid',\n",
       " 'mgrid',\n",
       " 'min',\n",
       " 'min_scalar_type',\n",
       " 'minimum',\n",
       " 'mintypecode',\n",
       " 'mirr',\n",
       " 'mod',\n",
       " 'modf',\n",
       " 'moveaxis',\n",
       " 'msort',\n",
       " 'multiply',\n",
       " 'nan',\n",
       " 'nan_to_num',\n",
       " 'nanargmax',\n",
       " 'nanargmin',\n",
       " 'nancumprod',\n",
       " 'nancumsum',\n",
       " 'nanmax',\n",
       " 'nanmean',\n",
       " 'nanmedian',\n",
       " 'nanmin',\n",
       " 'nanpercentile',\n",
       " 'nanprod',\n",
       " 'nanquantile',\n",
       " 'nanstd',\n",
       " 'nansum',\n",
       " 'nanvar',\n",
       " 'nbytes',\n",
       " 'ndarray',\n",
       " 'ndenumerate',\n",
       " 'ndfromtxt',\n",
       " 'ndim',\n",
       " 'ndindex',\n",
       " 'nditer',\n",
       " 'negative',\n",
       " 'nested_iters',\n",
       " 'newaxis',\n",
       " 'nextafter',\n",
       " 'nonzero',\n",
       " 'not_equal',\n",
       " 'nper',\n",
       " 'npv',\n",
       " 'numarray',\n",
       " 'number',\n",
       " 'obj2sctype',\n",
       " 'object',\n",
       " 'object0',\n",
       " 'object_',\n",
       " 'ogrid',\n",
       " 'oldnumeric',\n",
       " 'ones',\n",
       " 'ones_like',\n",
       " 'os',\n",
       " 'outer',\n",
       " 'packbits',\n",
       " 'pad',\n",
       " 'partition',\n",
       " 'percentile',\n",
       " 'pi',\n",
       " 'piecewise',\n",
       " 'place',\n",
       " 'pmt',\n",
       " 'poly',\n",
       " 'poly1d',\n",
       " 'polyadd',\n",
       " 'polyder',\n",
       " 'polydiv',\n",
       " 'polyfit',\n",
       " 'polyint',\n",
       " 'polymul',\n",
       " 'polynomial',\n",
       " 'polysub',\n",
       " 'polyval',\n",
       " 'positive',\n",
       " 'power',\n",
       " 'ppmt',\n",
       " 'printoptions',\n",
       " 'prod',\n",
       " 'product',\n",
       " 'promote_types',\n",
       " 'ptp',\n",
       " 'put',\n",
       " 'put_along_axis',\n",
       " 'putmask',\n",
       " 'pv',\n",
       " 'quantile',\n",
       " 'r_',\n",
       " 'rad2deg',\n",
       " 'radians',\n",
       " 'random',\n",
       " 'rate',\n",
       " 'ravel',\n",
       " 'ravel_multi_index',\n",
       " 'real',\n",
       " 'real_if_close',\n",
       " 'rec',\n",
       " 'recarray',\n",
       " 'recfromcsv',\n",
       " 'recfromtxt',\n",
       " 'reciprocal',\n",
       " 'record',\n",
       " 'remainder',\n",
       " 'repeat',\n",
       " 'require',\n",
       " 'reshape',\n",
       " 'resize',\n",
       " 'result_type',\n",
       " 'right_shift',\n",
       " 'rint',\n",
       " 'roll',\n",
       " 'rollaxis',\n",
       " 'roots',\n",
       " 'rot90',\n",
       " 'round',\n",
       " 'round_',\n",
       " 'row_stack',\n",
       " 's_',\n",
       " 'safe_eval',\n",
       " 'save',\n",
       " 'savetxt',\n",
       " 'savez',\n",
       " 'savez_compressed',\n",
       " 'sctype2char',\n",
       " 'sctypeDict',\n",
       " 'sctypeNA',\n",
       " 'sctypes',\n",
       " 'searchsorted',\n",
       " 'select',\n",
       " 'set_numeric_ops',\n",
       " 'set_printoptions',\n",
       " 'set_string_function',\n",
       " 'setbufsize',\n",
       " 'setdiff1d',\n",
       " 'seterr',\n",
       " 'seterrcall',\n",
       " 'seterrobj',\n",
       " 'setxor1d',\n",
       " 'shape',\n",
       " 'shares_memory',\n",
       " 'short',\n",
       " 'show_config',\n",
       " 'sign',\n",
       " 'signbit',\n",
       " 'signedinteger',\n",
       " 'sin',\n",
       " 'sinc',\n",
       " 'single',\n",
       " 'singlecomplex',\n",
       " 'sinh',\n",
       " 'size',\n",
       " 'sometrue',\n",
       " 'sort',\n",
       " 'sort_complex',\n",
       " 'source',\n",
       " 'spacing',\n",
       " 'split',\n",
       " 'sqrt',\n",
       " 'square',\n",
       " 'squeeze',\n",
       " 'stack',\n",
       " 'std',\n",
       " 'str',\n",
       " 'str0',\n",
       " 'str_',\n",
       " 'string_',\n",
       " 'subtract',\n",
       " 'sum',\n",
       " 'swapaxes',\n",
       " 'sys',\n",
       " 'take',\n",
       " 'take_along_axis',\n",
       " 'tan',\n",
       " 'tanh',\n",
       " 'tensordot',\n",
       " 'test',\n",
       " 'testing',\n",
       " 'tile',\n",
       " 'timedelta64',\n",
       " 'trace',\n",
       " 'tracemalloc_domain',\n",
       " 'transpose',\n",
       " 'trapz',\n",
       " 'tri',\n",
       " 'tril',\n",
       " 'tril_indices',\n",
       " 'tril_indices_from',\n",
       " 'trim_zeros',\n",
       " 'triu',\n",
       " 'triu_indices',\n",
       " 'triu_indices_from',\n",
       " 'true_divide',\n",
       " 'trunc',\n",
       " 'typeDict',\n",
       " 'typeNA',\n",
       " 'typecodes',\n",
       " 'typename',\n",
       " 'ubyte',\n",
       " 'ufunc',\n",
       " 'uint',\n",
       " 'uint0',\n",
       " 'uint16',\n",
       " 'uint32',\n",
       " 'uint64',\n",
       " 'uint8',\n",
       " 'uintc',\n",
       " 'uintp',\n",
       " 'ulonglong',\n",
       " 'unicode',\n",
       " 'unicode_',\n",
       " 'union1d',\n",
       " 'unique',\n",
       " 'unpackbits',\n",
       " 'unravel_index',\n",
       " 'unsignedinteger',\n",
       " 'unwrap',\n",
       " 'use_hugepage',\n",
       " 'ushort',\n",
       " 'vander',\n",
       " 'var',\n",
       " 'vdot',\n",
       " 'vectorize',\n",
       " 'version',\n",
       " 'void',\n",
       " 'void0',\n",
       " 'vsplit',\n",
       " 'vstack',\n",
       " 'w',\n",
       " 'warnings',\n",
       " 'where',\n",
       " 'who',\n",
       " 'zeros',\n",
       " 'zeros_like']"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# find out what's in numpy, these are mostly functions\n",
    "# you can minimize the output cell by clicking on the bar to the left\n",
    "dir(np)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Broadcasting ##\n",
    "\n",
    "Broadcasting is an efficient way to multiply arrays of different sizes (part (e) in the NumPy figure above)\n",
    "<img src=\"http://scipy-lectures.github.io/_images/numpy_broadcasting.png\" width=\"600\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5, 10) (10,)\n",
      "(5, 10)\n"
     ]
    }
   ],
   "source": [
    "# add f and x  (this is the second row example in the figure above)\n",
    "print(f.shape, x.shape)\n",
    "d = f + x\n",
    "print(d.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5, 10) (10,)\n",
      "(5, 10)\n"
     ]
    }
   ],
   "source": [
    "# multiply f by x\n",
    "print(f.shape, x.shape)\n",
    "g = f * x\n",
    "print(g.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5, 10) (5,)\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "operands could not be broadcast together with shapes (5,10) (5,) ",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-33-664308bc1e7c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;31m# why does this not work?\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mh\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mf\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mh\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (5,10) (5,) "
     ]
    }
   ],
   "source": [
    "# multiply f by y\n",
    "# why does this not work?\n",
    "print(f.shape, y.shape)\n",
    "h = f * y\n",
    "print(h.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5, 10)\n"
     ]
    }
   ],
   "source": [
    "# use newaxis special syntax\n",
    "h = f * y[:,np.newaxis]\n",
    "print(h.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reduction Operation\n",
    "These operation collapse one or more dimensions by performing an operation, for example, summing over an axis or even all axes.\n",
    "(part _f_ of the array operations figure above)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, 10)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-18.077652068817933"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# sum\n",
    "g.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.3615530413763587"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# mean\n",
    "g.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.4544951406053706"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# std\n",
    "g.std()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# apply on just one axis\n",
    "g_ymean = g.mean(axis=0)\n",
    "g_xmean = g.mean(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:blue\">Exercises</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Write a NumPy program to create an array of 10 zeros, 10 ones, 10 fives. Subsequently create a 3x10 array from them. Ultimately compute the sum column-wise (over axis 0)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Create an array of length `N=12` equally spaced between -5 and (including) 3, then compute the square of these values. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Create a two 2D grids of longitudes $\\lambda\\in[0^\\circ,360^\\circ]$ and latitudes $\\varphi\\in[-90^\\circ,90^\\circ]$ every $30^\\circ$. Then calculate $\\sin(30^\\circ)$ and $\\cos(\\pi)$, i.e. find out how to use degrees and radians with numpy functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. Create an array of `N=500` samples of the Normal distribution of mean=3, standard deviation=2. Determine the mean and standard deviation with numpy functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. _Hard:_ Compute an approximation to $\\pi$ using Monte Carlo sampling. Use only the `numpy.random.uniform()` function. These hints may help:\n",
    "- The area of a circle is $area = \\pi \\times radius^2$\n",
    "- Sample the unit square $(0,1)\\times(0,1)$ with $N$ uniformly in $x$ and $y$ distributed points."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:green\">Solutions</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true,
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      "[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]\n",
      "[5. 5. 5. 5. 5. 5. 5. 5. 5. 5.]\n",
      "[[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]\n",
      " [5. 5. 5. 5. 5. 5. 5. 5. 5. 5.]]\n",
      "(3, 10)\n",
      "[6. 6. 6. 6. 6. 6. 6. 6. 6. 6.]\n"
     ]
    }
   ],
   "source": [
    "# 1. Write a NumPy program to create an array of 10 zeros, 10 ones, 10 fives.\n",
    "# Subsequently create a 3x10 array from them.\n",
    "# Ultimately compute the sum column-wise (over axis 0).\n",
    "zeros = np.zeros(10)\n",
    "ones  = np.ones(10)\n",
    "fives = np.ones(10)*5\n",
    "array = np.array([zeros,ones,fives])\n",
    "print(zeros)\n",
    "print(ones)\n",
    "print(fives)\n",
    "print(array)\n",
    "print(array.shape)\n",
    "print(array.sum(axis=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true,
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2.50000000e+01, 1.82561983e+01, 1.25702479e+01, 7.94214876e+00,\n",
       "       4.37190083e+00, 1.85950413e+00, 4.04958678e-01, 8.26446281e-03,\n",
       "       6.69421488e-01, 2.38842975e+00, 5.16528926e+00, 9.00000000e+00])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 2. Create an array of length `N=12` equally spaced between -5 and including 3,\n",
    "# then compute the square of these values. \n",
    "np.linspace(-5,3,12)**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true,
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  0  30  60  90 120 150 180 210 240 270 300 330 360]\n",
      " [  0  30  60  90 120 150 180 210 240 270 300 330 360]\n",
      " [  0  30  60  90 120 150 180 210 240 270 300 330 360]\n",
      " [  0  30  60  90 120 150 180 210 240 270 300 330 360]\n",
      " [  0  30  60  90 120 150 180 210 240 270 300 330 360]\n",
      " [  0  30  60  90 120 150 180 210 240 270 300 330 360]\n",
      " [  0  30  60  90 120 150 180 210 240 270 300 330 360]]\n",
      "[[-90 -90 -90 -90 -90 -90 -90 -90 -90 -90 -90 -90 -90]\n",
      " [-60 -60 -60 -60 -60 -60 -60 -60 -60 -60 -60 -60 -60]\n",
      " [-30 -30 -30 -30 -30 -30 -30 -30 -30 -30 -30 -30 -30]\n",
      " [  0   0   0   0   0   0   0   0   0   0   0   0   0]\n",
      " [ 30  30  30  30  30  30  30  30  30  30  30  30  30]\n",
      " [ 60  60  60  60  60  60  60  60  60  60  60  60  60]\n",
      " [ 90  90  90  90  90  90  90  90  90  90  90  90  90]]\n",
      "-0.9880316240928618\n",
      "0.49999999999999994\n",
      "-1.0\n"
     ]
    }
   ],
   "source": [
    "# 3. Create a two 2D grids of longitudes $\\lambda\\in[0,360]$ and \n",
    "#latitudes $\\varphi\\in[-90,90]$ every $30^\\circ$.\n",
    "lons, lats = np.arange(0,361,30), np.arange(-90,91,30)\n",
    "# I did not specify whether the ranges are including the right values\n",
    "# the square brackets could suggest so, but if you exclude them,\n",
    "# that's fine too\n",
    "lons_grid, lats_grid = np.meshgrid(lons, lats)\n",
    "print(lons_grid)\n",
    "print(lats_grid)\n",
    "\n",
    "# Then calculate $\\sin(30^\\circ)$ and $\\cos(\\pi)$,\n",
    "# i.e. find out how to use degrees and radians with numpy functions.\n",
    "print(np.sin(30))              # this is wrong\n",
    "print(np.sin(np.deg2rad(30)))  # this is correct\n",
    "# --> numpy trigonometric functions want radians, not degrees\n",
    "print(np.cos(np.pi))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true,
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "N =    500, mean = 2.98, std = 1.8533548571586316\n",
      "N =   1200, mean = 2.83, std = 1.9988355896509091\n",
      "N = 100000, mean = 3.00, std = 1.9996856446725715\n"
     ]
    }
   ],
   "source": [
    "# 4. Create an array of `N=[500,1200,1e5]` samples of the Normal\n",
    "# distribution of mean=3, standard deviation=2.\n",
    "# Determine the mean and standard deviation with numpy functions.\n",
    "for N in [500,1200,int(1e5)]:\n",
    "    D = np.random.normal(loc=3, scale=2, size=N)\n",
    "    print(f'N = {N:6d}, mean = {D.mean():.2f}, std = {D.std()}')\n",
    "# again, the numbers and letters after the colon in the f-string \n",
    "# determine the output format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true,
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.14204\n",
      "3.13392\n"
     ]
    }
   ],
   "source": [
    "# 5. _Hard:_ Compute an approximation to $\\pi$ using Monte Carlo sampling.\n",
    "# Use only the `numpy.random.uniform()` function. These hints may help:\n",
    "# - The area of a circle is $area = \\pi \\times radius^2$\n",
    "# - Sample the unit square $(0,1)\\times(0,1)$ with $N$ uniformly in $x$ and $y$ distributed points.\n",
    "\n",
    "# we inscribe a circle with radius 1/2 and center (0.5,0.5) into the unit square\n",
    "# and check whether a randomly selected point is inside the circle or not.\n",
    "N = 100000\n",
    "\n",
    "def loop_estimate(N):\n",
    "    \"\"\" this function estimates pi with a Monte Carlo sampling method\n",
    "    it creates N points by looping over range(N);\n",
    "    loops are relatively slow in python\n",
    "    \n",
    "    input:\n",
    "    N .. number of samples\n",
    "    \"\"\"\n",
    "    count = 0\n",
    "    for i in range(N):\n",
    "        u, v = np.random.uniform(), np.random.uniform()\n",
    "        d = np.sqrt((u - 0.5)**2 + (v - 0.5)**2)\n",
    "        if d < 0.5:\n",
    "            count += 1\n",
    "    area_estimate = count / N\n",
    "    return area_estimate * 4  # dividing by radius**2\n",
    "    \n",
    "def vectorized_estimate(N):\n",
    "    \"\"\" this alterantive function estimates pi with a Monte Carlo sampling method\n",
    "    it uses NumPy vectors to speed up the calculation significantly\n",
    "    \n",
    "    input:\n",
    "    N .. number of samples\n",
    "    \"\"\"\n",
    "    u, v = np.random.uniform(size=N), np.random.uniform(size=N)\n",
    "    d = np.sqrt((u - 0.5)**2 + (v - 0.5)**2)\n",
    "    area_estimate = np.ones_like(d)[d<0.5].sum()/N\n",
    "    return area_estimate * 4  # dividing by radius**2\n",
    "\n",
    "print(loop_estimate(N))\n",
    "print(vectorized_estimate(N)) \n",
    "# the functions are entirely equivalent\n",
    "# any difference in performance with respect to pi's true value is random\n",
    "# just run it again to see the numbers change"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "# let's see how the two functions compare in their performance\n",
    "# here we use an ipython linemagic command to time how long the function takes to run"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true,
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "506 ms ± 9.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "%timeit loop_estimate(N)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true,
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.47 ms ± 75.9 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit vectorized_estimate(N)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true,
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 3.48 ms, sys: 945 µs, total: 4.43 ms\n",
      "Wall time: 3.1 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# another useful (cell)magic command is `%%time` \n",
    "# on an otherwise empty first line\n",
    "# to time the execution of a cell\n",
    "pi_estimate = vectorized_estimate(N)"
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}