{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpy -  multidimensional data arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"top\"></a>Contents\n",
    "===\n",
    "- [Introduction](#intro)\n",
    "    - [Create numpy arrays](#create)\n",
    "    - [File I/O](#import)\n",
    "    - [Manipulating arrays](#manipulating)\n",
    "    - [Functions for extracting data from arrays and creating arrays](#functions)\n",
    "    - [Exercises](#exercises1)\n",
    "    \n",
    "- [Linear Algebra](#linear)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"intro\"></a>Introduction\n",
    "==="
   ]
  },
  {
   "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. In some sense, numpy allows to run Matlab numerical computations within the Python environment.\n",
    "\n",
    "To use `numpy` you need to import the module, using for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "\n",
    "# you can check the number of methods of the superclass numpy by typing np. and then hit Tab."
   ]
  },
  {
   "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": [
    "<a name=\"create\"></a>Creating `numpy` arrays\n",
    "---"
   ]
  },
  {
   "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": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a vector: the argument to the array function is a Python list\n",
    "v = np.array([1,2,3,4])\n",
    "\n",
    "type(v)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a matrix: the argument to the array function is a nested Python list\n",
    "M = np.array([[1, 2], [3, 4]])\n",
    "\n",
    "M"
   ]
  },
  {
   "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": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.ndarray, numpy.ndarray)"
      ]
     },
     "execution_count": 16,
     "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": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4,)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The number of elements in the array is available through the `ndarray.size` property:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Equivalently, we could use the function `numpy.shape` and `numpy.size`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.shape(M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.size(M)"
   ]
  },
  {
   "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. Implementing 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 the 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": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 14,
     "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": 15,
   "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-15-e1f336250f69>\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": "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": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([['1', '2'],\n",
       "       ['3', '4']], dtype='<U1')"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = np.array([[1, 2], [3, 4]], dtype=str)\n",
    "\n",
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Common data types 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 generate arrays of different forms. Some of the more common are:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### arange"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2, 4, 6, 8])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a range\n",
    "x = np.arange(0, 10, 2) # arguments: start, stop, step\n",
    "\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "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": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.arange(1, -1, -0.1)\n",
    "\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### linspace and logspace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "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": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# using linspace, both end points ARE included\n",
    "np.linspace(0, 10, 25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "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": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.logspace(0, 10, 10, base=e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### mgrid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y = np.mgrid[0:5, 0:4] # similar to meshgrid in MATLAB\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0, 0],\n",
       "       [1, 1, 1, 1],\n",
       "       [2, 2, 2, 2],\n",
       "       [3, 3, 3, 3],\n",
       "       [4, 4, 4, 4]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2, 3],\n",
       "       [0, 1, 2, 3],\n",
       "       [0, 1, 2, 3],\n",
       "       [0, 1, 2, 3],\n",
       "       [0, 1, 2, 3]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### random data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import random\n",
    "random.seed(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4.17022005e-01 7.20324493e-01 1.14374817e-04 3.02332573e-01\n",
      " 1.46755891e-01 9.23385948e-02 1.86260211e-01 3.45560727e-01\n",
      " 3.96767474e-01 5.38816734e-01]\n",
      "[0.41919451]\n"
     ]
    }
   ],
   "source": [
    "# uniform random numbers in [0,1]\n",
    "random.seed(1)\n",
    "print(random.rand(10))\n",
    "print(random.rand(1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = random.rand(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.65628408, -0.06249159, -1.73865429,  0.103163  , -0.62166685],\n",
       "       [ 0.27571804, -1.09067489, -0.60998525,  0.30641238,  1.69182613],\n",
       "       [-0.74795374, -0.58079722, -0.11075397,  2.04202875,  0.44752069],\n",
       "       [ 0.68338423,  0.02288597,  0.85723427,  0.18393058, -0.41611158],\n",
       "       [ 1.25005005,  1.24829979, -0.75767414,  0.58829416,  0.34685933]])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# standard normal distributed random numbers\n",
    "random.randn(5,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### diag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 0],\n",
       "       [0, 2, 0],\n",
       "       [0, 0, 3]])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a diagonal matrix\n",
    "np.diag([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "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": 52,
     "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": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [0., 0., 0.],\n",
       "       [0., 0., 0.]])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros([3,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1.],\n",
       "       [1., 1., 1.],\n",
       "       [1., 1., 1.]])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones([3,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[top](#top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"import\"></a>File I/O\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comma-separated values (CSV)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A very common file format for data files is comma-separated values (CSV), or related formats such as TSV (tab-separated values). To read data from such files into Numpy arrays we can use the `numpy.genfromtxt` function. For example, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "head: ./data/stockholm_td_adj.dat: No such file or directory\n"
     ]
    }
   ],
   "source": [
    "!head ./data/stockholm_td_adj.dat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = genfromtxt('https://raw.githubusercontent.com/jrjohansson/scientific-python-lectures/master/stockholm_td_adj.dat')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(77431, 7)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 277,
       "width": 839
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%config InlineBackend.figure_format = 'retina'\n",
    "fig, ax = plt.subplots(figsize=(14,4))\n",
    "ax.plot(data[:,0]+data[:,1]/12.0+data[:,2]/365, data[:,5])\n",
    "ax.axis('tight')\n",
    "ax.set_title('tempeatures in Stockholm')\n",
    "ax.set_xlabel('year')\n",
    "ax.set_ylabel('temperature (C)');"
   ]
  },
  {
   "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.04244687,  0.5843886 ,  0.78593853],\n",
       "       [ 0.591315  ,  0.32068757,  0.05731292],\n",
       "       [ 0.47588598,  0.42527834,  0.02396643]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = random.rand(3,3)\n",
    "\n",
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "savetxt(\"./data/random-matrix.csv\", M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.244687472155217467e-02 5.843885962807650047e-01 7.859385272384139531e-01\n",
      "5.913149990281658663e-01 3.206875665468288394e-01 5.731292390226438993e-02\n",
      "4.758859756553327491e-01 4.252783436595454214e-01 2.396642508677548911e-02\n"
     ]
    }
   ],
   "source": [
    "!cat ./data/random-matrix.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.04245 0.58439 0.78594\n",
      "0.59131 0.32069 0.05731\n",
      "0.47589 0.42528 0.02397\n"
     ]
    }
   ],
   "source": [
    "savetxt(\"./data/random-matrix.csv\", M, fmt='%.5f') # fmt specifies the format\n",
    "\n",
    "!cat ./data/random-matrix.csv"
   ]
  },
  {
   "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: cannot open `random-matrix.npy' (No such file or directory)\n"
     ]
    }
   ],
   "source": [
    "save(\"./data/random-matrix.npy\", M)\n",
    "\n",
    "!file random-matrix.npy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.04244687,  0.5843886 ,  0.78593853],\n",
       "       [ 0.591315  ,  0.32068757,  0.05731292],\n",
       "       [ 0.47588598,  0.42527834,  0.02396643]])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "load(\"./data/random-matrix.npy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More properties of the numpy arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.itemsize # bytes per element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "72"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.nbytes # number of bytes"
   ]
  },
  {
   "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": [
    "[top](#top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"manipulating\"></a>Manipulating arrays\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can index elements in an array using square brackets and indices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# v is a vector, and has only one dimension, taking one index\n",
    "v[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2])"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# M is a matrix, or a 2 dimensional array, taking two indices \n",
    "M[0,:]"
   ]
  },
  {
   "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.04244687,  0.5843886 ,  0.78593853],\n",
       "       [ 0.591315  ,  0.32068757,  0.05731292],\n",
       "       [ 0.47588598,  0.42527834,  0.02396643]])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.591315  ,  0.32068757,  0.05731292])"
      ]
     },
     "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.591315  ,  0.32068757,  0.05731292])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[1,:] # row 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[:,1] # column 1\n",
    "\n",
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can assign new values to elements in an array using indexing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [],
   "source": [
    "M[0,:] = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4, 4],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "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.5843886 , -1.        ],\n",
       "       [ 0.        ,  0.        , -1.        ],\n",
       "       [ 0.47588598,  0.42527834, -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": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = array([1,2,3,4,5])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3])"
      ]
     },
     "execution_count": 59,
     "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": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2, -3,  4,  5])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[1:3] = [-2,-3]\n",
    "\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": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2, -3,  4,  5])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[::] # lower, upper, step all take the default values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -3,  5])"
      ]
     },
     "execution_count": 133,
     "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": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2, -3])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[:3] # first three elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 5])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[3:] # elements from index 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Negative indices counts from the end of the array (positive index from the begining):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = array([1,2,3,4,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[-1] # the last element in the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4, 5])"
      ]
     },
     "execution_count": 63,
     "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": 67,
   "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": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = array([[n+m*10 for n in range(5)] for m in range(5)])\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[11, 12, 13],\n",
       "       [21, 22, 23],\n",
       "       [31, 32, 33]])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a block from the original array\n",
    "A[1:4, 1:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  2,  4],\n",
       "       [20, 22, 24],\n",
       "       [40, 42, 44]])"
      ]
     },
     "execution_count": 66,
     "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": 72,
   "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": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "row_indices = [1, 2, 3]\n",
    "A[row_indices]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([11, 22, 34])"
      ]
     },
     "execution_count": 73,
     "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": "markdown",
   "metadata": {},
   "source": [
    "We can also use index masks: If the index mask is an Numpy array of data type `bool`, then an element is selected (True) or not (False) depending on the value of the index mask at the position of each element: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = array([n for n in range(5)])\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4])"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "row_index = B > 2\n",
    "B[row_index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "row_mask = array([True, False, True, False, False])\n",
    "B[row_mask]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# same thing\n",
    "row_mask = 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": 79,
   "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": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = arange(0, 10, 0.5)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "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": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mask = (5 < x) * (x < 7.5)\n",
    "\n",
    "mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5.5, 6. , 6.5, 7. ])"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[mask]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[top](#top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"functions\"></a>Functions for extracting data from arrays and creating arrays\n",
    "---"
   ]
  },
  {
   "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": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([11, 12, 13, 14]),)"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "indices = np.where(mask)\n",
    "\n",
    "indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5.5,  6. ,  6.5,  7. ])"
      ]
     },
     "execution_count": 76,
     "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": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0, 11, 22, 33, 44])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diag(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 21, 32, 43])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "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": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-3, -2, -1,  0,  1,  2])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v2 = arange(-3,3)\n",
    "v2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2,  0,  2])"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "row_indices = [1, 3, 5]\n",
    "v2[row_indices] # fancy indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2,  0,  2])"
      ]
     },
     "execution_count": 81,
     "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": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2,  0,  2])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "take([-3, -2, -1,  0,  1,  2], row_indices)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### choose"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Constructs an array by picking elements from several arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5, -2,  5, -2])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "which = [1, 0, 1, 0]\n",
    "choices = [[-2,-2,-2,-2], [5,5,5,5]]\n",
    "\n",
    "choose(which, choices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3., 3.],\n",
       "       [7., 7.]])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([[1,2], [3,4]])\n",
    "A*2\n",
    "\n",
    "B = np.ones((2,2))\n",
    "\n",
    "B\n",
    "\n",
    "np.dot(A,B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[top](#top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"exercises1\"></a>Exercises\n",
    "---\n",
    "#### Ex 10.1: Creating and manipulating arrays\n",
    "   - Create a null vector of size 10.\n",
    "   - Create a null vector of size 10 but the fifth value which is 1.\n",
    "   - Create a vector with values ranging from 10 to 49\n",
    "   - Create a 3x3 identity matrix \n",
    "   - Create a 3x3x3 array with random values\n",
    "   - Create a vector of size 10 with values ranging from 0 to 1, both excluded"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"linear\"></a>Linear algebra\n",
    "==="
   ]
  },
  {
   "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": [],
   "source": [
    "v1 = np.arange(0, 5)"
   ]
  },
  {
   "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]]),\n",
       " 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": 160,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  4,  9, 16])"
      ]
     },
     "execution_count": 160,
     "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": 161,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((5, 5), (5,))"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.shape, v1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  0,   1,   4,   9,  16],\n",
       "       [  0,  11,  24,  39,  56],\n",
       "       [  0,  21,  44,  69,  96],\n",
       "       [  0,  31,  64,  99, 136],\n",
       "       [  0,  41,  84, 129, 176]])"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A * v1"
   ]
  },
  {
   "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": 93,
   "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": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(A, A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 30, 130, 230, 330, 430])"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(A, v1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(v1, v1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatively, we can cast the array objects to the type `matrix`. This changes the behavior of the standard arithmetic operators `+, -, *` to use matrix algebra."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.matrix"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = np.matrix(A)\n",
    "v = np.matrix(v1).T # make it a column vector\n",
    "\n",
    "type(M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0],\n",
       "        [1],\n",
       "        [2],\n",
       "        [3],\n",
       "        [4]])"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 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": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M * M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 30],\n",
       "        [130],\n",
       "        [230],\n",
       "        [330],\n",
       "        [430]])"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M * v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[30]])"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# inner product\n",
    "v.T * v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 30],\n",
       "        [131],\n",
       "        [232],\n",
       "        [333],\n",
       "        [434]])"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# with matrix objects, standard matrix algebra applies\n",
    "v + M*v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we try to add, subtract or multiply objects with incomplatible shapes we get an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = matrix([1,2,3,4,5,6]).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((5, 5), (6, 1))"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shape(M), shape(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "shapes (5,5) and (6,1) not aligned: 5 (dim 1) != 6 (dim 0)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-104-995fb48ad0cc>\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[0mv\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m/home/williamgrimes/anaconda3/lib/python3.5/site-packages/numpy/matrixlib/defmatrix.py\u001b[0m in \u001b[0;36m__mul__\u001b[0;34m(self, other)\u001b[0m\n\u001b[1;32m    341\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mother\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mN\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndarray\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtuple\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    342\u001b[0m             \u001b[0;31m# This promotes 1-D vectors to row vectors\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 343\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mN\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0masmatrix\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    344\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0misscalar\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mother\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'__rmul__'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    345\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mN\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: shapes (5,5) and (6,1) not aligned: 5 (dim 1) != 6 (dim 0)"
     ]
    }
   ],
   "source": [
    "M * v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See also the related functions: `inner`, `outer`, `cross`, `kron`, `tensordot`. Try for example `help(kron)`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Array/Matrix transformations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above we have used the `.T` to transpose the matrix object `v`. We could also have used the `transpose` function to accomplish the same thing. \n",
    "\n",
    "Other mathematical functions that transform matrix objects are:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0.+1.j, 0.+2.j],\n",
       "        [0.+3.j, 0.+4.j]])"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C = matrix([[1j, 2j], [3j, 4j]])\n",
    "C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 0.-1.j,  0.-2.j],\n",
       "        [ 0.-3.j,  0.-4.j]])"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conjugate(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hermitian conjugate: transpose + conjugate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 0.-1.j,  0.-3.j],\n",
       "        [ 0.-2.j,  0.-4.j]])"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C.H"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can extract the real and imaginary parts of complex-valued arrays using `real` and `imag`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 0.,  0.],\n",
       "        [ 0.,  0.]])"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "real(C) # same as: C.real"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 1.,  2.],\n",
       "        [ 3.,  4.]])"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imag(C) # same as: C.imag"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or the complex argument and absolute value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.78539816,  1.10714872],\n",
       "       [ 1.24904577,  1.32581766]])"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "angle(C+1) # heads up MATLAB Users, angle is used instead of arg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 1.,  2.],\n",
       "        [ 3.,  4.]])"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrix computations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Inverse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0.+2.j , 0.-1.j ],\n",
       "        [0.-1.5j, 0.+0.5j]])"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linalg.inv(C) # equivalent to C.I "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[  1.00000000e+00+0.j,   0.00000000e+00+0.j],\n",
       "        [  1.11022302e-16+0.j,   1.00000000e+00+0.j]])"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C.I * C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Determinant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linalg.det(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.49999999999999967+0j)"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linalg.det(C.I)"
   ]
  },
  {
   "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. \n",
    "\n",
    "For example, let's calculate some properties from the Stockholm temperature dataset used above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(77431, 7)"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# reminder, the tempeature dataset is stored in the data variable:\n",
    "shape(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.1971096847515854"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the temperature data is in column 3\n",
    "mean(data[:,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The daily mean temperature in Stockholm over the last 200 years has been about 6.2 C."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### standard deviations and variance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8.2822716213405734, 68.596023209663414)"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "std(data[:,3]), var(data[:,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### min and max"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-25.800000000000001"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# lowest daily average temperature\n",
    "data[:,3].min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "28.300000000000001"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# highest daily average temperature\n",
    "data[:,3].max()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### sum, prod, and trace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = arange(0, 10)\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# sum up all elements\n",
    "sum(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3628800"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# product of all elements\n",
    "prod(d+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  3,  6, 10, 15, 21, 28, 36, 45])"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# cummulative sum\n",
    "cumsum(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([      1,       2,       6,      24,     120,     720,    5040,\n",
       "         40320,  362880, 3628800])"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# cummulative product\n",
    "cumprod(d+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "110"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# same as: diag(A).sum()\n",
    "trace(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Computations on subsets of arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can compute with subsets of the data in an array using indexing, fancy indexing, and the other methods of extracting data from an array (described above).\n",
    "\n",
    "For example, let's go back to the temperature dataset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "head: cannot open 'stockholm_td_adj.dat' for reading: No such file or directory\n"
     ]
    }
   ],
   "source": [
    "!head -n 3 stockholm_td_adj.dat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The dataformat is: year, month, day, daily average temperature, low, high, location.\n",
    "\n",
    "If we are interested in the average temperature only in a particular month, say February, then we can create a index mask and use it to select only the data for that month using:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.,   9.,  10.,  11.,\n",
       "        12.])"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unique(data[:,1]) # the month column takes values from 1 to 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [],
   "source": [
    "mask_feb = data[:,1] == 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-3.2121095707365961"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the temperature data is in column 3\n",
    "mean(data[mask_feb,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With these tools we have very powerful data processing capabilities at our disposal. For example, to extract the average monthly average temperatures for each month of the year only takes a few lines of code: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEKCAYAAAAFJbKyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f22a6302eb8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "months = arange(1,13)\n",
    "monthly_mean = [mean(data[data[:,1] == month, 3]) for month in months]\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "ax.bar(months, monthly_mean)\n",
    "ax.set_xlabel(\"Month\")\n",
    "ax.set_ylabel(\"Monthly avg. temp.\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculations with higher-dimensional data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When functions such as `min`, `max`, etc. are 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": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.34476653,  0.98790145,  0.61264231],\n",
       "       [ 0.15284341,  0.15822474,  0.17950592],\n",
       "       [ 0.4216338 ,  0.51174378,  0.07453565]])"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m = random.rand(3,3)\n",
    "m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.98790145013656216"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# global max\n",
    "m.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.4216338 ,  0.98790145,  0.61264231])"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# max in each column\n",
    "m.max(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.98790145,  0.17950592,  0.51174378])"
      ]
     },
     "execution_count": 135,
     "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": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, 5)"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "n, m = A.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "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": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = A.reshape((1,n*m))\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "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": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B[0,0:5] = 5 # modify the array\n",
    "\n",
    "B.reshape(5,5)\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "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": 140,
     "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": 141,
   "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": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = A.flatten()\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "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": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B[0:5] = 10\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "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": 143,
     "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": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = array([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3,)"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shape(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1],\n",
       "       [2],\n",
       "       [3]])"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# make a column matrix of the vector v\n",
    "v[:, newaxis]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 1)"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# column matrix\n",
    "v[:,newaxis].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 3)"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# row matrix\n",
    "v[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:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### tile and repeat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = array([[1, 2], [3, 4]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4])"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# repeat each element 3 times\n",
    "repeat(a, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 1, 2, 1, 2],\n",
       "       [3, 4, 3, 4, 3, 4]])"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# tile the matrix 3 times \n",
    "tile(a, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### concatenate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = array([[5, 6]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "concatenate((a, b), axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 5],\n",
       "       [3, 4, 6]])"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "concatenate((a, b.T), axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### hstack and vstack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vstack((a,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 5],\n",
       "       [3, 4, 6]])"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "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 (technical term: pass by reference). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = array([[1, 2], [3, 4]])\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [],
   "source": [
    "# now B is referring to the same array data as A \n",
    "B = A "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# changing B affects A\n",
    "B[0,0] = 10\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "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": 161,
   "metadata": {},
   "outputs": [],
   "source": [
    "B = copy(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-5,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 162,
     "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": 163,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 163,
     "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": 164,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "v = array([1,2,3,4])\n",
    "\n",
    "for element in v:\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "M = array([[1,2], [3,4]])\n",
    "\n",
    "for i in range(0,2):\n",
    "    for j in range(0,2):\n",
    "        print(M[i,j])\n",
    "    \n",
    "    \n",
    "    \n",
    "#for element in M:\n",
    " #   print(element)\n",
    "    \n",
    "    #for element in row:\n",
    "        #print(element)\n"
   ]
  },
  {
   "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": 166,
   "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": 167,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  4],\n",
       "       [ 9, 16]])"
      ]
     },
     "execution_count": 167,
     "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,for example `if` statements and other boolean expressions, one needs to use `any` or `all`, which requires that any or all elements in the array evalutes to `True`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  4],\n",
       "       [ 9, 16]])"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "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": 174,
   "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": 175,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  1.,   4.],\n",
       "       [  9.,  16.]])"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M2 = M.astype(float)\n",
    "\n",
    "M2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M2.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True,  True],\n",
       "       [ True,  True]], dtype=bool)"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M3 = M.astype(bool)\n",
    "\n",
    "M3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[top](#top)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"exercises1\"></a>Exercises\n",
    "---\n",
    "#### Ex 10.2: Linear Algrebra\n",
    "   - Create a 5x5 matrix with values 1,2,3,4 just below the diagonal.\n",
    "   - Multiply a 5x3 matrix by a 3x2 matrix (real matrix product)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1., 1.],\n",
       "       [1., 0., 0., 0., 1.],\n",
       "       [0., 2., 0., 0., 1.],\n",
       "       [0., 0., 3., 0., 1.],\n",
       "       [0., 0., 0., 4., 1.]])"
      ]
     },
     "execution_count": 232,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.ones([5,5])\n",
    "A[1:5, 0:4]  =np.diag([1,2,3,4])\n",
    "\n",
    "A\n"
   ]
  },
  {
   "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."
   ]
  }
 ],
 "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.3"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}