0b-Intro_Numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpy -  multidimensional data arrays\n",
    "# ... with some Matplotlib\n",
    "\n",
    "`\n",
    "Alexandre Gramfort\n",
    "`\n",
    "\n",
    "based on the work of J.R. Johansson (robert@riken.jp) http://dml.riken.jp/~rob/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# what is this line all about?!? Answer later\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `numpy` package (module) is used in almost all numerical computation using Python. It is a package that provide high-performance vector, matrix and higher-dimensional data structures for Python. It is implemented in C and Fortran so when calculations are vectorized (formulated with vectors and matrices), performance is very good. \n",
    "\n",
    "To use `numpy` first import the module:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np  # np is the most common import name for numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the `numpy` package the terminology used for vectors, matrices and higher-dimensional data sets is *array*. \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating `numpy` arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are a number of ways to initialize new numpy arrays, for example from\n",
    "\n",
    "* a Python list or tuples\n",
    "* using functions that are dedicated to generating numpy arrays, such as `arange`, `linspace`, etc.\n",
    "* reading data from files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### From lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example, to create new vector and matrix arrays from Python lists we can use the `numpy.array` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4]\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "# a vector: the argument to the array function is a Python list\n",
    "v = np.array([1, 2, 3, 4])\n",
    "print(v)\n",
    "print(type(v))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n"
     ]
    }
   ],
   "source": [
    "# a matrix (or better a 2d array): the argument to the array function is a nested Python list\n",
    "M = np.array([[1, 2], [3, 4]])\n",
    "print(M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mm = [[1, 2], [3, 4]]\n",
    "mm[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `v` and `M` objects are both of the type `ndarray` that the `numpy` module provides."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.ndarray, numpy.ndarray)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(v), type(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The difference between the `v` and `M` arrays is only their shapes. We can get information about the shape of an array by using the `ndarray.shape` property."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4,)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(v.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4,)\n"
     ]
    }
   ],
   "source": [
    "a = (4,)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The number of elements in the array is available through the `ndarray.size` property:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.size  # be careful matlab size is shape with Numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far the `numpy.ndarray` looks awefully much like a Python list (or nested list). Why not simply use Python lists for computations instead of creating a new array type? \n",
    "\n",
    "There are several reasons:\n",
    "\n",
    "* Python lists are very general. They can contain any kind of object. They are dynamically typed. They do not support mathematical functions such as matrix and dot multiplications, etc. Implementating such functions for Python lists would not be very efficient because of the dynamic typing.\n",
    "* Numpy arrays are **statically typed** and **homogeneous**. The type of the elements is determined when array is created.\n",
    "* Numpy arrays are memory efficient.\n",
    "* Because of the static typing, fast implementation of mathematical functions such as multiplication and addition of `numpy` arrays can be implemented in a compiled language (C and Fortran is used).\n",
    "\n",
    "Using the `dtype` (data type) property of an `ndarray`, we can see what type the data of an array has:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We get an error if we try to assign a value of the wrong type to an element in a numpy array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: 'hello'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-13-d137d88031df>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mM\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"hello\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: 'hello'"
     ]
    }
   ],
   "source": [
    "M[0, 0] = \"hello\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n"
     ]
    }
   ],
   "source": [
    "M[0, 0] = 1.5\n",
    "print(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want, we can explicitly define the type of the array data when we create it, using the `dtype` keyword argument: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.+0.j, 2.+0.j],\n",
       "       [3.+0.j, 4.+0.j]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = np.array([[1, 2], [3, 4]], dtype=complex)\n",
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Common type that can be used with `dtype` are: `int`, `float`, `complex`, `bool`, `object`, etc.\n",
    "\n",
    "We can also explicitly define the bit size of the data types, for example: `int64`, `int16`, `float128`, `complex128`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using array-generating functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For larger arrays it is inpractical to initialize the data manually, using explicit python lists. Instead we can use one of the many functions in `numpy` that generates arrays of different forms. Some of the more common are:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### arange"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a range\n",
    "\n",
    "x = np.arange(0, 10, 1) # arguments: start, stop, step\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1.00000000e+00, -9.00000000e-01, -8.00000000e-01, -7.00000000e-01,\n",
       "       -6.00000000e-01, -5.00000000e-01, -4.00000000e-01, -3.00000000e-01,\n",
       "       -2.00000000e-01, -1.00000000e-01, -2.22044605e-16,  1.00000000e-01,\n",
       "        2.00000000e-01,  3.00000000e-01,  4.00000000e-01,  5.00000000e-01,\n",
       "        6.00000000e-01,  7.00000000e-01,  8.00000000e-01,  9.00000000e-01])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.arange(-1, 1, 0.1)\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### linspace and logspace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.        ,  0.41666667,  0.83333333,  1.25      ,  1.66666667,\n",
       "        2.08333333,  2.5       ,  2.91666667,  3.33333333,  3.75      ,\n",
       "        4.16666667,  4.58333333,  5.        ,  5.41666667,  5.83333333,\n",
       "        6.25      ,  6.66666667,  7.08333333,  7.5       ,  7.91666667,\n",
       "        8.33333333,  8.75      ,  9.16666667,  9.58333333, 10.        ])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# using linspace, both end points ARE included\n",
    "np.linspace(0, 10, 25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.00000000e+00, 3.03773178e+00, 9.22781435e+00, 2.80316249e+01,\n",
       "       8.51525577e+01, 2.58670631e+02, 7.85771994e+02, 2.38696456e+03,\n",
       "       7.25095809e+03, 2.20264658e+04])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.logspace(0, 10, 10, base=np.e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### First demo of Matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First import"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "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": [
    "x = np.arange(10)\n",
    "y = np.linspace(0, 1, 10)\n",
    "plt.plot(x, y, 'r-')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### mgrid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x, y = np.mgrid[0:5, 0:5] # similar to meshgrid in MATLAB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0, 0, 0],\n",
       "       [1, 1, 1, 1, 1],\n",
       "       [2, 2, 2, 2, 2],\n",
       "       [3, 3, 3, 3, 3],\n",
       "       [4, 4, 4, 4, 4]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2, 3, 4],\n",
       "       [0, 1, 2, 3, 4],\n",
       "       [0, 1, 2, 3, 4],\n",
       "       [0, 1, 2, 3, 4],\n",
       "       [0, 1, 2, 3, 4]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### random data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from numpy import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.8019913 , 0.12867921, 0.73667356, 0.16623208, 0.57337484],\n",
       "       [0.01079214, 0.41482305, 0.16044965, 0.64856491, 0.29044114],\n",
       "       [0.68986744, 0.74809578, 0.86103506, 0.9980464 , 0.8199836 ],\n",
       "       [0.0196086 , 0.84912719, 0.07240831, 0.28901989, 0.79031895],\n",
       "       [0.15259278, 0.4728237 , 0.37617847, 0.8176771 , 0.7531961 ]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# uniform random numbers in [0,1]\n",
    "random.rand(5, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.13810503, -0.74729929,  0.6391931 ,  0.14084113, -0.25278633],\n",
       "       [ 1.17625278, -0.04252503, -0.57741977, -1.68887619, -0.2862335 ],\n",
       "       [-0.04151536,  0.39331337, -0.00639902,  0.16246305, -0.14067499],\n",
       "       [-0.35482019,  0.22860154,  1.58742068,  1.10277974, -0.14265197],\n",
       "       [ 0.3470518 ,  0.25528565, -1.27224728, -0.37828419,  1.11002397]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# standard normal distributed random numbers\n",
    "random.randn(5, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More on matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "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": [
    "x = random.randn(100000)\n",
    "plt.hist(x, 20)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "x = random.randn(10, 10)\n",
    "# plt.matshow(x, cmap=plt.cm.Spectral)\n",
    "plt.imshow(x, cmap=plt.cm.Spectral, interpolation='nearest')\n",
    "plt.colorbar()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### diag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 0],\n",
       "       [0, 2, 0],\n",
       "       [0, 0, 3]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a diagonal matrix\n",
    "np.diag([1, 2, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 0, 0],\n",
       "       [0, 0, 2, 0],\n",
       "       [0, 0, 0, 3],\n",
       "       [0, 0, 0, 0]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# diagonal with offset from the main diagonal\n",
    "np.diag([1, 2, 3], k=1) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### zeros and ones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0],\n",
       "       [0, 0, 0],\n",
       "       [0, 0, 0]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((3, 3), dtype=np.int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1.],\n",
       "       [1., 1., 1.],\n",
       "       [1., 1., 1.]])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones((3, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## File I/O"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using `numpy.savetxt` we can store a Numpy array to a file in CSV format:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.15632484, 0.2663512 , 0.81482867],\n",
       "       [0.05977765, 0.33470015, 0.13211154],\n",
       "       [0.46574473, 0.51214122, 0.5760917 ]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = random.rand(3,3)\n",
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "np.savetxt(\"random-matrix.txt\", M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.563248403652525154e-01 2.663511953087497330e-01 8.148286746019455240e-01\r\n",
      "5.977764810744923274e-02 3.347001451128295280e-01 1.321115408587504314e-01\r\n",
      "4.657447269910540699e-01 5.121412210665665654e-01 5.760916956596584537e-01\r\n"
     ]
    }
   ],
   "source": [
    "!cat random-matrix.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.15632, 0.26635, 0.81483\r\n",
      "0.05978, 0.33470, 0.13211\r\n",
      "0.46574, 0.51214, 0.57609\r\n"
     ]
    }
   ],
   "source": [
    "np.savetxt(\"random-matrix.csv\", M, fmt='%.5f', delimiter=', ') # fmt specifies the format\n",
    "\n",
    "!cat random-matrix.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.15632, 0.26635, 0.81483],\n",
       "       [0.05978, 0.3347 , 0.13211],\n",
       "       [0.46574, 0.51214, 0.57609]])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.loadtxt(\"random-matrix.csv\", delimiter=', ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numpy's native file format"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Useful when storing and reading back numpy array data. Use the functions `numpy.save` and `numpy.load`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "random-matrix.npy: data\r\n"
     ]
    }
   ],
   "source": [
    "np.save(\"random-matrix.npy\", M)\n",
    "\n",
    "!file random-matrix.npy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.15632484, 0.2663512 , 0.81482867],\n",
       "       [0.05977765, 0.33470015, 0.13211154],\n",
       "       [0.46574473, 0.51214122, 0.5760917 ]])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.load(\"random-matrix.npy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More properties of the numpy arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "float64\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(M.dtype)\n",
    "M.itemsize # bytes per element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "72\n",
      "72\n"
     ]
    }
   ],
   "source": [
    "print(M.nbytes) # number of bytes\n",
    "print(M.size * M.itemsize)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.ndim # number of dimensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Manipulating arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can index elements in an array using the square bracket and indices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# v is a vector, and has only one dimension, taking one index\n",
    "v[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.33470014511282953"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# M is a matrix, or a 2 dimensional array, taking two indices \n",
    "M[1, 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we omit an index of a multidimensional array it returns the whole row (or, in general, a N-1 dimensional array) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.15632484, 0.2663512 , 0.81482867],\n",
       "       [0.05977765, 0.33470015, 0.13211154],\n",
       "       [0.46574473, 0.51214122, 0.5760917 ]])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.05977765, 0.33470015, 0.13211154])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same thing can be achieved with using `:` instead of an index: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.05977765, 0.33470015, 0.13211154])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[1, :] # row 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.2663512 , 0.33470015, 0.51214122])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[:, 1] # column 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can assign new values to elements in an array using indexing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "M[0, 0] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.        , 0.2663512 , 0.81482867],\n",
       "       [0.05977765, 0.33470015, 0.13211154],\n",
       "       [0.46574473, 0.51214122, 0.5760917 ]])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# also works for rows and columns\n",
    "M[1, :] = 0\n",
    "M[:, 2] = -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.        ,  0.2663512 , -1.        ],\n",
       "       [ 0.        ,  0.        , -1.        ],\n",
       "       [ 0.46574473,  0.51214122, -1.        ]])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Index slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Index slicing is the technical name for the syntax `M[lower:upper:step]` to extract part of an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([1, 2, 3, 4, 5])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5,)\n"
     ]
    }
   ],
   "source": [
    "print(A.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Array slices are *mutable*: if they are assigned a new value the original array from which the slice was extracted is modified:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2, -3,  4,  5])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[1:3] = [-2, -3]\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can omit any of the three parameters in `M[lower:upper:step]`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2, -3,  4,  5])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[::] # lower, upper, step all take the default values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -3,  5])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[::2] # step is 2, lower and upper defaults to the beginning and end of the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2, -3])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[:3] # first three elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 5])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[3:] # elements from index 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0. 0.]\n",
      " [1. 1. 1. 1.]\n",
      " [0. 0. 0. 0.]\n",
      " [0. 0. 0. 0.]]\n",
      "[[0. 0.]\n",
      " [1. 1.]\n",
      " [0. 0.]\n",
      " [0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "B = np.zeros((4, 4))\n",
    "B[1] = 1\n",
    "print(B)\n",
    "print(B[:, ::2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Negative indices counts from the end of the array (positive index from the begining):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "A = np.array([1, 2, 3, 4, 5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[-2] # the last element in the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4, 5])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[-3:] # the last three elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Index slicing works exactly the same way for multidimensional arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34],\n",
       "       [40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([[n+m*10 for n in range(5)] for m in range(5)])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[11, 12, 13],\n",
       "       [21, 22, 23],\n",
       "       [31, 32, 33]])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a block from the original array\n",
    "A[1:4, 1:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  2,  4],\n",
       "       [20, 22, 24],\n",
       "       [40, 42, 44]])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# strides\n",
    "A[::2, ::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fancy indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fancy indexing is the name for when an array or list is used in-place of an index: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34]])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "row_indices = [1, 2, 3]\n",
    "A[row_indices]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([11, 22, 34])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "col_indices = [1, 2, -1] # remember, index -1 means the last element\n",
    "A[row_indices, col_indices]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3  4]\n",
      " [10 11 12 13 14]\n",
      " [20 21 22 23 24]\n",
      " [30 31 32 33 34]\n",
      " [40 41 42 43 44]]\n",
      "[[ 0  1  2  3  4]\n",
      " [10  0 12  0  0]\n",
      " [20  0 22  0  0]\n",
      " [30  0 32  0  0]\n",
      " [40 41 42 43 44]]\n"
     ]
    }
   ],
   "source": [
    "print(A)\n",
    "# print(A[np.ix_([1, 2, 3], [1, 3, 4])])\n",
    "B = A.copy()\n",
    "B[np.ix_([1, 2, 3], [1, 3, 4])] = 0\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3  4]\n",
      " [10 11 12 13 14]\n",
      " [20 21 22 23 24]\n",
      " [30 31 32 33 34]\n",
      " [40 41 42 43 44]]\n"
     ]
    }
   ],
   "source": [
    "B = A.copy()\n",
    "B[[1, 2, 3]][: , [1, 3, 4]] = 0\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also index masks: If the index mask is an Numpy array of with data type `bool`, then an element is selected (True) or not (False) depending on the value of the index mask at the position each element: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = np.arange(5)\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ True False  True False  True]\n",
      "[0 2 4]\n",
      "[0 2 4]\n"
     ]
    }
   ],
   "source": [
    "even_idx = (B % 2) == 0\n",
    "print(even_idx)\n",
    "print(B[even_idx])\n",
    "print(B[(B % 2) == 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ True False  True False False]\n",
      "[0 2]\n"
     ]
    }
   ],
   "source": [
    "row_mask = np.array([True, False, True, False, False])\n",
    "print(row_mask)\n",
    "print(B[row_mask])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# same thing\n",
    "row_mask = np.array([1, 0, 1, 0, 0], dtype=bool)\n",
    "B[row_mask]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This feature is very useful to conditionally select elements from an array, using for example comparison operators:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0. , 0.5, 1. , 1.5, 2. , 2.5, 3. , 3.5, 4. , 4.5, 5. , 5.5, 6. ,\n",
       "       6.5, 7. , 7.5, 8. , 8.5, 9. , 9.5])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.arange(0, 10, 0.5)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, False, False, False, False, False, False,\n",
       "       False, False,  True,  True,  True,  True, False, False, False,\n",
       "       False, False])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mask = (5 < x) * (x < 7.5)\n",
    "mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5.5, 6. , 6.5, 7. ])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[mask]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions for extracting data from arrays and creating arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### where"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The index mask can be converted to position index using the `where` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([11, 12, 13, 14])"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "indices = np.where(mask)[0]\n",
    "indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5.5, 6. , 6.5, 7. ])"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[indices] # this indexing is equivalent to the fancy indexing x[mask]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### diag"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the diag function we can also extract the diagonal and subdiagonals of an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0, 11, 22, 33, 44])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.diag(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 21, 32, 43])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.diag(A, -1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### take"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `take` function is similar to fancy indexing described above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-3, -2, -1,  0,  1,  2])"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v2 = np.arange(-3,3)\n",
    "v2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2,  0,  2])"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "row_indices = [1, 3, 5]\n",
    "v2[row_indices] # fancy indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2,  0,  2])"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v2.take(row_indices)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But `take` also works on lists and other objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2,  0,  2])"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.take([-3, -2, -1,  0,  1,  2], row_indices)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Array oriented algebra"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vectorizing code is the key to writing efficient numerical calculation with Python/Numpy. That means that as much as possible of a program should be formulated in terms of matrix and vector operations, like matrix-matrix multiplication."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scalar-array operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the usual arithmetic operators to multiply, add, subtract, and divide arrays with scalar numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "v1 = np.arange(5)\n",
    "print(v1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2, 4, 6, 8])"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[ 0,  2,  4,  6,  8],\n",
       "        [20, 22, 24, 26, 28],\n",
       "        [40, 42, 44, 46, 48],\n",
       "        [60, 62, 64, 66, 68],\n",
       "        [80, 82, 84, 86, 88]]), array([[ 2,  3,  4,  5,  6],\n",
       "        [12, 13, 14, 15, 16],\n",
       "        [22, 23, 24, 25, 26],\n",
       "        [32, 33, 34, 35, 36],\n",
       "        [42, 43, 44, 45, 46]]))"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A * 2, A + 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Element-wise array-array operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we add, subtract, multiply and divide arrays with each other, the default behaviour is **element-wise** operations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[   0,    1,    4,    9,   16],\n",
       "       [ 100,  121,  144,  169,  196],\n",
       "       [ 400,  441,  484,  529,  576],\n",
       "       [ 900,  961, 1024, 1089, 1156],\n",
       "       [1600, 1681, 1764, 1849, 1936]])"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A * A # element-wise multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  4,  9, 16])"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 * v1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we multiply arrays with compatible shapes, we get an element-wise multiplication of each row:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((5, 5), (5,))"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.shape, v1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2, 3, 4],\n",
       "       [0, 1, 2, 3, 4],\n",
       "       [0, 1, 2, 3, 4],\n",
       "       [0, 1, 2, 3, 4],\n",
       "       [0, 1, 2, 3, 4]])"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.tile(v1, (5, 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0],\n",
       "       [1],\n",
       "       [2],\n",
       "       [3],\n",
       "       [4]])"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1[:, np.newaxis]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3  4]\n",
      " [10 11 12 13 14]\n",
      " [20 21 22 23 24]\n",
      " [30 31 32 33 34]\n",
      " [40 41 42 43 44]] [0 1 2 3 4]\n",
      "[[  0   0   0   0   0]\n",
      " [ 10  11  12  13  14]\n",
      " [ 40  42  44  46  48]\n",
      " [ 90  93  96  99 102]\n",
      " [160 164 168 172 176]]\n",
      "[[  0   0   0   0   0]\n",
      " [ 10  11  12  13  14]\n",
      " [ 40  42  44  46  48]\n",
      " [ 90  93  96  99 102]\n",
      " [160 164 168 172 176]]\n",
      "[[  0   0   0   0   0]\n",
      " [ 10  11  12  13  14]\n",
      " [ 40  42  44  46  48]\n",
      " [ 90  93  96  99 102]\n",
      " [160 164 168 172 176]]\n"
     ]
    }
   ],
   "source": [
    "print(A, v1)\n",
    "print((A.T * v1).T)\n",
    "print(A * v1[:, np.newaxis])\n",
    "print(A * np.tile(v1, (5, 1)).T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  0,  0,  0,  0],\n",
       "       [ 0,  1,  2,  3,  4],\n",
       "       [ 0,  2,  4,  6,  8],\n",
       "       [ 0,  3,  6,  9, 12],\n",
       "       [ 0,  4,  8, 12, 16]])"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1[:, np.newaxis] * v1[np.newaxis, :]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0],\n",
       "       [1],\n",
       "       [2],\n",
       "       [3],\n",
       "       [4]])"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1.reshape(-1, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrix algebra"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What about matrix mutiplication? There are two ways. We can either use the `dot` function, which applies a matrix-matrix, matrix-vector, or inner vector multiplication to its two arguments: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 300,  310,  320,  330,  340],\n",
       "       [1300, 1360, 1420, 1480, 1540],\n",
       "       [2300, 2410, 2520, 2630, 2740],\n",
       "       [3300, 3460, 3620, 3780, 3940],\n",
       "       [4300, 4510, 4720, 4930, 5140]])"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(A, A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 30, 130, 230, 330, 430])"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(A, v1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(v1, v1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data processing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Often it is useful to store datasets in Numpy arrays. Numpy provides a number of functions to calculate statistics of datasets in arrays. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, 5)"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.shape(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23.0"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean(A[:, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2., 12., 22., 32., 42.])"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean(A, axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### standard deviations and variance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(14.142135623730951, 200.0)"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.std(A[:, 3]), np.var(A[:, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### min and max"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# lowest value\n",
    "A[:, 3].min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "43"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# highest value\n",
    "A[:, 3].max()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### sum, prod, and trace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = np.arange(0, 10)\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# sum up all elements\n",
    "np.sum(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3628800"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# product of all elements\n",
    "np.prod(d + 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  3,  6, 10, 15, 21, 28, 36, 45])"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# cummulative sum\n",
    "np.cumsum(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([      1,       2,       6,      24,     120,     720,    5040,\n",
       "         40320,  362880, 3628800])"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# cummulative product\n",
    "np.cumprod(d + 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "110"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# same as: diag(A).sum()\n",
    "np.trace(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## EXERCISE :\n",
    "\n",
    "Compute an approximation of $\\pi$ using Wallis' formula (no loop just using Numpy):\n",
    "\n",
    "$$\n",
    "{\\displaystyle \\pi = 2 \\prod _{n=1}^{N}{\\frac {4n^{2}}{4n^{2}-1}}}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculations with higher-dimensional data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When functions such as `min`, `max`, etc., is applied to a multidimensional arrays, it is sometimes useful to apply the calculation to the entire array, and sometimes only on a row or column basis. Using the `axis` argument we can specify how these functions should behave: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.20253071, 0.08462284, 0.78809944],\n",
       "       [0.92859535, 0.36578188, 0.80791547],\n",
       "       [0.62032943, 0.68123428, 0.25107269]])"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m = np.random.rand(3, 3)\n",
    "m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9285953546449118"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# global max\n",
    "m.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.92859535, 0.68123428, 0.80791547])"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# max in each column\n",
    "m.max(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.78809944, 0.92859535, 0.68123428])"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# max in each row\n",
    "m.max(axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Many other functions and methods in the `array` and `matrix` classes accept the same (optional) `axis` keyword argument."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reshaping, resizing and stacking arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The shape of an Numpy array can be modified without copying the underlaying data, which makes it a fast operation even for large arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34],\n",
       "       [40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "n, m = A.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30,\n",
       "        31, 32, 33, 34, 40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = A.reshape((1, n*m))\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5,  5,  5,  5,  5, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30,\n",
       "        31, 32, 33, 34, 40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B[0,0:5] = 5 # modify the array\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5,  5,  5,  5,  5],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34],\n",
       "       [40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A # and the original variable is also changed. B is only a different view of the same data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use the function `flatten` to make a higher-dimensional array into a vector. But this function create a copy of the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5,  5,  5,  5,  5, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31,\n",
       "       32, 33, 34, 40, 41, 42, 43, 44])"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = A.flatten()\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 10, 10, 10, 10, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31,\n",
       "       32, 33, 34, 40, 41, 42, 43, 44])"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B[0:5] = 10\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5,  5,  5,  5,  5],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34],\n",
       "       [40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A # now A has not changed, because B's data is a copy of A's, not refering to the same data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding a new dimension: newaxis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With `newaxis`, we can insert new dimensions in an array, for example converting a vector to a column or row matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "v = np.array([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3,)"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1],\n",
       "       [2],\n",
       "       [3]])"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# make a column matrix of the vector v\n",
    "v[:, np.newaxis]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 1)"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# column matrix\n",
    "v[:, np.newaxis].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 3)"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# row matrix\n",
    "v[np.newaxis, :].shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Stacking and repeating arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using function `repeat`, `tile`, `vstack`, `hstack`, and `concatenate` we can create larger vectors and matrices from smaller ones.\n",
    "\n",
    "**But in practice they are almost always possible to avoid**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### tile and repeat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = np.array([[1, 2], [3, 4]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4])"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# repeat each element 3 times\n",
    "np.repeat(a, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 1, 2, 1, 2],\n",
       "       [3, 4, 3, 4, 3, 4]])"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# tile the matrix 3 times \n",
    "np.tile(a, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### concatenate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "b = np.array([[5, 6]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate((a, b), axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 5],\n",
       "       [3, 4, 6]])"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate((a, b.T), axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### hstack and vstack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.vstack((a, b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 5],\n",
       "       [3, 4, 6]])"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.hstack((a, b.T))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Copy and \"deep copy\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To achieve high performance, assignments in Python usually do not copy the underlaying objects. This is important for example when objects are passed between functions, to avoid an excessive amount of memory copying when it is not necessary (techincal term: pass by reference). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([[1, 2], [3, 4]])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# now B is referring to the same array data as A \n",
    "B = A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# changing B affects A\n",
    "B[0, 0] = 10\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 4]\n",
      "[[100]\n",
      " [  4]]\n",
      "[100   4]\n"
     ]
    }
   ],
   "source": [
    "B = A[:, 1]\n",
    "print(B)\n",
    "B[0] = 100\n",
    "print(A[:, [1]])\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to avoid this behavior, so that when we get a new completely independent object `B` copied from `A`, then we need to do a so-called \"deep copy\" using the function `copy`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "B = A.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ -5, 100],\n",
       "       [  3,   4]])"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# now, if we modify B, A is not affected\n",
    "B[0,0] = -5\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 10, 100],\n",
       "       [  3,   4]])"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterating over array elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generally, we want to avoid iterating over the elements of arrays whenever we can (at all costs). The reason is that in a interpreted language like Python (or MATLAB), iterations are really slow compared to vectorized operations. \n",
    "\n",
    "However, sometimes iterations are unavoidable. For such cases, the Python `for` loop is the most convenient way to iterate over an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "v = np.array([1, 2, 3, 4])\n",
    "\n",
    "for element in v:\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "row [1 2]\n",
      "1\n",
      "2\n",
      "row [3 4]\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "M = np.array([[1,2], [3,4]])\n",
    "\n",
    "for row in M:\n",
    "    print(\"row\", row)\n",
    "    \n",
    "    for element in row:\n",
    "        print(element)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we need to iterate over each element of an array and modify its elements, it is convenient to use the `enumerate` function to obtain both the element and its index in the `for` loop: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "row_idx 0 row [1 2]\n",
      "col_idx 0 element 1\n",
      "col_idx 1 element 2\n",
      "row_idx 1 row [3 4]\n",
      "col_idx 0 element 3\n",
      "col_idx 1 element 4\n"
     ]
    }
   ],
   "source": [
    "for row_idx, row in enumerate(M):\n",
    "    print(\"row_idx\", row_idx, \"row\", row)\n",
    "    \n",
    "    for col_idx, element in enumerate(row):\n",
    "        print(\"col_idx\", col_idx, \"element\", element)\n",
    "       \n",
    "        # update the matrix M: square each element\n",
    "        M[row_idx, col_idx] = element ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  4],\n",
       "       [ 9, 16]])"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# each element in M is now squared\n",
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using arrays in conditions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When using arrays in conditions in for example `if` statements and other boolean expressions, one need to use one of `any` or `all`, which requires that any or all elements in the array evalutes to `True`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  4],\n",
       "       [ 9, 16]])"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "at least one element in M is larger than 5\n"
     ]
    }
   ],
   "source": [
    "if (M > 5).any():\n",
    "    print(\"at least one element in M is larger than 5\")\n",
    "else:\n",
    "    print(\"no element in M is larger than 5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "all elements in M are not larger than 5\n"
     ]
    }
   ],
   "source": [
    "if (M > 5).all():\n",
    "    print(\"all elements in M are larger than 5\")\n",
    "else:\n",
    "    print(\"all elements in M are not larger than 5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Type casting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since Numpy arrays are *statically typed*, the type of an array does not change once created. But we can explicitly cast an array of some type to another using the `astype` functions (see also the similar `asarray` function). This always create a new array of new type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  4.],\n",
       "       [ 9., 16.]])"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M2 = M.astype(float)\n",
    "\n",
    "M2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M2.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True,  True],\n",
       "       [ True,  True]])"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M3 = M.astype(bool)\n",
    "\n",
    "M3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Further reading"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* http://numpy.scipy.org\n",
    "* http://scipy.org/Tentative_NumPy_Tutorial\n",
    "* http://scipy.org/NumPy_for_Matlab_Users - A Numpy guide for MATLAB users.\n",
    "* https://jakevdp.github.io/PythonDataScienceHandbook/ - Good book on full scientific Python packages"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  },
  "widgets": {
   "state": {},
   "version": "1.1.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}