2. NumPy Tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:06.794273Z",
     "start_time": "2020-06-24T09:04:06.697856Z"
    }
   },
   "outputs": [],
   "source": [
    "# This line configures matplotlib to show figures embedded in the notebook, \n",
    "# instead of opening a new window for each figure.\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "\n",
    "**NumPy**, short for **Num**erical **Py**thon, is used in almost all numerical computation using Python. The `numpy`package provides high-performance vector, matrix and higher-dimensional data structures for Python. It is implemented in C and Fortran so when calculations are vectorized (formulated with vectors and matrices), performance is very good.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Many users use pandas to perform statistics and analytics over data, especially if rewpresented in tabular format. pandas provides some domain-specific functionalities like time series manipulation, not present in NumPy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To use NumPy, you need to import the `numpy` module, using for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:06.803720Z",
     "start_time": "2020-06-24T09:04:06.797900Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This import style is quite standard; all objects and functions the `numpy` package will now be invoked with the `np.` prefix."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy is designed for efficiency on large arrays of data, as the following code reports."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:07.900793Z",
     "start_time": "2020-06-24T09:04:06.810117Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 17.7 ms, sys: 17.3 ms, total: 35 ms\n",
      "Wall time: 35.3 ms\n",
      "CPU times: user 466 ms, sys: 163 ms, total: 630 ms\n",
      "Wall time: 635 ms\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "np_array = np.arange(1000000)\n",
    "p_list = list(range(1000000))\n",
    "\n",
    "%time for _ in range(10): np_array = np_array * 2\n",
    "%time for _ in range(10): p_list2 = [x * 2 for x in p_list]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating arrays\n",
    "\n",
    "In NumPy the key feature used for vectors, matrices and higher-dimensional data sets is the N-dimensional **array**, or **ndarray**. An array is a multi-dimensional container for homogeneous data, i.e., all elements must have the same type. \n",
    "\n",
    "There are a number of ways to initialize new NumPy arrays, for example\n",
    "* from 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\n",
    "\n",
    "## From lists\n",
    "\n",
    "For example, to create new vector and matrix arrays from Python lists we can use the `numpy.array` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:07.911576Z",
     "start_time": "2020-06-24T09:04:07.905452Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "v = np.array([1,2,3,4])\n",
    "\n",
    "print(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:07.924087Z",
     "start_time": "2020-06-24T09:04:07.915668Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n"
     ]
    }
   ],
   "source": [
    "M = np.array([[1, 2], [3, 4]])\n",
    "\n",
    "print(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": 180,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:07.940406Z",
     "start_time": "2020-06-24T09:04:07.927837Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.ndarray, numpy.ndarray)"
      ]
     },
     "execution_count": 180,
     "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 or, equivalently, by using the function `np.shape`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:07.961021Z",
     "start_time": "2020-06-24T09:04:07.948648Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4,)\n",
      "(4,)\n",
      "(2, 2)\n",
      "(2, 2)\n"
     ]
    }
   ],
   "source": [
    "print(v.shape)\n",
    "print(np.shape(v))\n",
    "\n",
    "print(M.shape)\n",
    "print(np.shape(M))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that a `ndarray` of dimension 1 has a shape `(k,)` but it is considered as a vector with 1 row and k\n",
    "columns.\n",
    "\n",
    "The number of elements in the array is available through the `ndarray.size` property or, equivalently, by using the function `np.size`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:07.987119Z",
     "start_time": "2020-06-24T09:04:07.972241Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "4\n",
      "4\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "print(v.size)\n",
    "print(np.size(v))\n",
    "\n",
    "print(M.size)\n",
    "print(np.size(M))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The number of dimensions in the array is available through the `ndarray.ndim` property or, equivalently, by using the function `np.ndim`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:08.002547Z",
     "start_time": "2020-06-24T09:04:07.994047Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "1\n",
      "2\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "print(v.ndim)\n",
    "print(np.ndim(v))\n",
    "\n",
    "print(M.ndim)\n",
    "print(np.ndim(M))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far an 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",
    "* 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",
    "\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)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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": 184,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:08.018889Z",
     "start_time": "2020-06-24T09:04:08.007929Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int64\n"
     ]
    }
   ],
   "source": [
    "print(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.\n",
    "\n",
    "We can explicitly define the type of the array data when we create it, using the `dtype`keyword argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:08.036074Z",
     "start_time": "2020-06-24T09:04:08.024426Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.+0.j 2.+0.j]\n",
      " [3.+0.j 4.+0.j]]\n"
     ]
    }
   ],
   "source": [
    "M = np.array([[1, 2], [3, 4]], dtype=complex)\n",
    "\n",
    "print(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Common data types that can be used with dtype are: `int`, `float`, `complex`, `bool`, `object`, etc.\n",
    "We can also explicitly define the bit size of the data types, for example: `int64`, `int16`, `float128`, `complex128`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can explicitely convert of *cast* an array from a dtype to anothed using the `np.astype` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:08.052911Z",
     "start_time": "2020-06-24T09:04:08.039480Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int64\n",
      "[1 2 3 4 5]\n",
      "float16\n",
      "[1. 2. 3. 4. 5.]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1, 2, 3, 4, 5])\n",
    "print(a.dtype)\n",
    "print(a)\n",
    "\n",
    "fa = a.astype(np.float16)\n",
    "print(fa.dtype)\n",
    "print(fa)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using array-generating functions\n",
    "\n",
    "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": 187,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:08.071617Z",
     "start_time": "2020-06-24T09:04:08.059883Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n",
      "[-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]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(0, 10, 1) # arguments: start, stop, step\n",
    "print(x)\n",
    "\n",
    "y = np.arange(-1, 1, 0.1)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**linspace** and **logspace**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:08.102512Z",
     "start_time": "2020-06-24T09:04:08.076751Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.          0.41666667  0.83333333  1.25        1.66666667  2.08333333\n",
      "  2.5         2.91666667  3.33333333  3.75        4.16666667  4.58333333\n",
      "  5.          5.41666667  5.83333333  6.25        6.66666667  7.08333333\n",
      "  7.5         7.91666667  8.33333333  8.75        9.16666667  9.58333333\n",
      " 10.        ]\n",
      "[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]\n"
     ]
    }
   ],
   "source": [
    "x = np.linspace(0, 10, 25)\n",
    "print(x)\n",
    "\n",
    "y = np.logspace(0, 10, 10, base=np.e)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**random** data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:08.119774Z",
     "start_time": "2020-06-24T09:04:08.106387Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.93712811 0.74879012 0.38040147 0.539559   0.59775979]\n",
      " [0.63645827 0.26684308 0.7222307  0.25734948 0.06778759]\n",
      " [0.7688009  0.7098656  0.29127684 0.36333113 0.00132204]\n",
      " [0.96079942 0.42408265 0.64480219 0.39604629 0.42748111]\n",
      " [0.92139113 0.06411075 0.20393848 0.19149444 0.42697575]]\n",
      "[[ 0.53384868 -1.77089385  1.47949756]\n",
      " [-0.87517459 -0.09204117 -0.49854636]\n",
      " [ 0.8640698   0.06710405 -0.26366291]]\n"
     ]
    }
   ],
   "source": [
    "from numpy import random\n",
    "\n",
    "# uniform random numbers in [0,1]\n",
    "x = random.rand(5, 5)\n",
    "print(x)\n",
    "\n",
    "# standard normal distributed random numbers\n",
    "y = random.randn(3, 3)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**eye**, **diag**, **zeros** and **ones**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:08.172100Z",
     "start_time": "2020-06-24T09:04:08.124605Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0. 0.]\n",
      " [0. 1. 0.]\n",
      " [0. 0. 1.]]\n",
      "[[1 0 0]\n",
      " [0 2 0]\n",
      " [0 0 3]]\n",
      "[[0. 0. 0.]\n",
      " [0. 0. 0.]\n",
      " [0. 0. 0.]]\n",
      "[[1. 1. 1.]\n",
      " [1. 1. 1.]\n",
      " [1. 1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "x = np.eye(3)\n",
    "print(x)\n",
    "\n",
    "x = np.diag([1,2,3])\n",
    "print(x)\n",
    "\n",
    "y = np.zeros((3,3))\n",
    "print(y)\n",
    "\n",
    "z = np.ones((3,3))\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are several NumPy functions for [creating arrays](https://docs.scipy.org/doc/numpy/user/quickstart.html#array-creation):\n",
    "\n",
    "| Function | Description |\n",
    "| ---: | :--- |\n",
    "| `np.array(a)` | Create $n$-dimensional NumPy array from sequence `a` |\n",
    "| `np.linspace(a,b,N)` | Create 1D NumPy array with `N` equally spaced values from `a` to `b` (inclusively)|\n",
    "| `np.arange(a,b,step)` | Create 1D NumPy array with values from `a` to `b` (exclusively) incremented by `step`|\n",
    "| `np.zeros(N)` | Create 1D NumPy array of zeros of length $N$ |\n",
    "| `np.zeros((n,m))` | Create 2D NumPy array of zeros with $n$ rows and $m$ columns |\n",
    "| `np.ones(N)` | Create 1D NumPy array of ones of length $N$ |\n",
    "| `np.ones((n,m))` | Create 2D NumPy array of ones with $n$ rows and $m$ columns |\n",
    "| `np.eye(N)` | Create 2D NumPy array with $N$ rows and $N$ columns with ones on the diagonal (ie. the identity matrix of size $N$) |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reading data from files\n",
    "\n",
    "A very common file format for data files is *comma-separated values* (CSV), or related formats such as *tab-separated values* (TSV). To read data from such files into `numpy` arrays we can use the `np.genfromtxt` function. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:08.717026Z",
     "start_time": "2020-06-24T09:04:08.177499Z"
    }
   },
   "outputs": [],
   "source": [
    "data = np.genfromtxt('data/stockholm_td_adj.tsv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:08.726208Z",
     "start_time": "2020-06-24T09:04:08.719615Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(77431, 7)\n"
     ]
    }
   ],
   "source": [
    "print(np.shape(data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:09.032268Z",
     "start_time": "2020-06-24T09:04:08.730831Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(14,4))\n",
    "\n",
    "ax.plot(data[:,0] + data[:,1]/12.0 + data[:,2]/365, data[:,5])\n",
    "\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 `np.savetxt` we can store a `numpy` array to a file in CSV format:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:09.043780Z",
     "start_time": "2020-06-24T09:04:09.034741Z"
    }
   },
   "outputs": [],
   "source": [
    "M = random.rand(3,3)\n",
    "\n",
    "np.savetxt(\"data/random-matrix1.csv\", M)\n",
    "\n",
    "np.savetxt(\"data/random-matrix2.csv\", M, fmt='%.5f') # fmt specifies the format"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Manipulating arrays\n",
    "\n",
    "## Indexing\n",
    "\n",
    "We can index elements in an array using square brackets and indices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:09.055146Z",
     "start_time": "2020-06-24T09:04:09.047281Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "0.5091657737884723\n"
     ]
    }
   ],
   "source": [
    "# v is a vector, and has only one dimension, taking one index\n",
    "print(v[0])\n",
    "\n",
    "# M is a matrix, or a 2 dimensional array, taking two indices \n",
    "print(M[1,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we omit an index of a multidimensional array it returns, in general, a N-1 dimensional array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:09.071055Z",
     "start_time": "2020-06-24T09:04:09.061406Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.54637072 0.61035093 0.5347052 ]\n",
      " [0.54705373 0.50916577 0.04862202]\n",
      " [0.63603638 0.87133417 0.41561053]]\n",
      "[0.54705373 0.50916577 0.04862202]\n"
     ]
    }
   ],
   "source": [
    "print(M)\n",
    "\n",
    "print(M[1]) # row 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same thing can be achieved with using `:` instead of an index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:09.108113Z",
     "start_time": "2020-06-24T09:04:09.092285Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.54705373 0.50916577 0.04862202]\n",
      "[0.61035093 0.50916577 0.87133417]\n"
     ]
    }
   ],
   "source": [
    "print(M[1,:]) # row 1\n",
    "print(M[:,1]) # column 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can assign new values to elements in an array using indexing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:09.136940Z",
     "start_time": "2020-06-24T09:04:09.117860Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         0.61035093 0.5347052 ]\n",
      " [0.54705373 0.50916577 0.04862202]\n",
      " [0.63603638 0.87133417 0.41561053]]\n",
      "[[1.         0.61035093 0.5347052 ]\n",
      " [0.         0.         0.        ]\n",
      " [0.63603638 0.87133417 0.41561053]]\n",
      "[[ 1.          0.61035093 -1.        ]\n",
      " [ 0.          0.         -1.        ]\n",
      " [ 0.63603638  0.87133417 -1.        ]]\n"
     ]
    }
   ],
   "source": [
    "M[0,0] = 1\n",
    "print(M)\n",
    "\n",
    "# also works for rows and columns using lists or ndarrays\n",
    "M[1,:] = [0, 0, 0]\n",
    "print(M)\n",
    "\n",
    "M[:,2] = np.array([-1, -1, -1])\n",
    "print(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Index slicing\n",
    "\n",
    "**Index slicing** is the technical name for the syntax `M[lower:upper:step]` to extract parts of an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:09.158930Z",
     "start_time": "2020-06-24T09:04:09.141463Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 3]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([1, 2, 3, 4, 5])\n",
    "\n",
    "print(A[1:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An important distinction between Python's lists and NumPy's arrays is that array slices are **views** on the original array. This means that no data is copied, and any modification to the view will be reflected by the original array. That is, **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": 200,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:09.179671Z",
     "start_time": "2020-06-24T09:04:09.171566Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1 -2 -3  4  5]\n"
     ]
    }
   ],
   "source": [
    "A[1:3] = [-2,-3]\n",
    "\n",
    "print(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": 238,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:25:45.906017Z",
     "start_time": "2020-06-24T09:25:45.895872Z"
    }
   },
   "outputs": [],
   "source": [
    "B = np.copy(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can omit any of the three parameters in `M[lower:upper:step]`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:09.190362Z",
     "start_time": "2020-06-24T09:04:09.183763Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1 -2 -3  4  5]\n",
      "[ 1 -3  5]\n",
      "[ 1 -2 -3]\n",
      "[4 5]\n"
     ]
    }
   ],
   "source": [
    "print(A[::])  # lower, upper, step all take the default values\n",
    "print(A[::2]) # step is 2, lower and upper defaults to the beginning and end of the array\n",
    "print(A[:3])  # first three elements\n",
    "print(A[3:])  # elements from index 3 to the end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Negative indices counts from the end of the array (positive index from the begining):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:09.198651Z",
     "start_time": "2020-06-24T09:04:09.192899Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "[3 4 5]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([1,2,3,4,5])\n",
    "\n",
    "print(A[-1])\n",
    "print(A[-3:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Index slicing works exactly the same way for multidimensional arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:09.209997Z",
     "start_time": "2020-06-24T09:04:09.202128Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3  4]\n",
      " [10 11 12 13 14]\n",
      " [20 21 22 23 24]\n",
      " [30 31 32 33 34]\n",
      " [40 41 42 43 44]]\n",
      "[[11 12 13]\n",
      " [21 22 23]\n",
      " [31 32 33]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[n + m * 10 for n in range(5)] for m in range(5)])\n",
    "\n",
    "print(A)\n",
    "\n",
    "# a block from the original array\n",
    "print(A[1:4, 1:4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fancy indexing\n",
    "\n",
    "**Fancy indexing** is the name for when an integer array or list is used in-place of an index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:09.218407Z",
     "start_time": "2020-06-24T09:04:09.212680Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[10 11 12 13 14]\n",
      " [20 21 22 23 24]\n",
      " [30 31 32 33 34]]\n"
     ]
    }
   ],
   "source": [
    "row_indices = [1, 2, 3]\n",
    "print(A[row_indices])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:09.227058Z",
     "start_time": "2020-06-24T09:04:09.221197Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[11 22 34]\n"
     ]
    }
   ],
   "source": [
    "col_indices = [1, 2, -1] # remember, index -1 means the last element\n",
    "print(A[row_indices, col_indices])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Selecting data from an array by fancy indexing *always creates a copy fo the data*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Boolean indexing\n",
    "\n",
    "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": 206,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:09.239887Z",
     "start_time": "2020-06-24T09:04:09.231122Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4]\n",
      "[0 2]\n",
      "[0 2]\n"
     ]
    }
   ],
   "source": [
    "B = np.array([n for n in range(5)])\n",
    "print(B)\n",
    "\n",
    "row_mask = np.array([True, False, True, False, False])\n",
    "print(B[row_mask])\n",
    "\n",
    "# same thing\n",
    "row_mask = np.array([1,0,1,0,0], dtype=bool)\n",
    "print(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": 207,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:09.248406Z",
     "start_time": "2020-06-24T09:04:09.243146Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.  0.5 1.  1.5 2.  2.5 3.  3.5 4.  4.5 5.  5.5 6.  6.5 7.  7.5 8.  8.5\n",
      " 9.  9.5]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(0, 10, 0.5)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:09.258110Z",
     "start_time": "2020-06-24T09:04:09.251773Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[False False False False False False False False False False False  True\n",
      "  True  True  True False False False False False]\n"
     ]
    }
   ],
   "source": [
    "mask = (5 < x) & (x < 7.5)\n",
    "print(mask)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Selecting data from an array by boolean indexing *always creates a copy fo the data*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> The Python keywords `not`, `and` and `or` do not work with boolean arrays. Use `~`, `&` and `|` instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:09.266339Z",
     "start_time": "2020-06-24T09:04:09.260816Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5.5 6.  6.5 7. ]\n"
     ]
    }
   ],
   "source": [
    "print(x[mask])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions for extracting data from arrays and creating arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**where**: convert index mask to position index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:09.276490Z",
     "start_time": "2020-06-24T09:04:09.269570Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[False False False False False False False False False False False  True\n",
      "  True  True  True False False False False False]\n",
      "[5.5 6.  6.5 7. ]\n",
      "(array([11, 12, 13, 14]),)\n",
      "[5.5 6.  6.5 7. ]\n"
     ]
    }
   ],
   "source": [
    "print(mask)\n",
    "print(x[mask])\n",
    "\n",
    "indices = np.where(mask)\n",
    "\n",
    "print(indices)\n",
    "print(x[indices]) # this indexing is equivalent to the fancy indexing x[mask]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**diag**: extract the diagonal and subdiagonals of an array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:09.287191Z",
     "start_time": "2020-06-24T09:04:09.279855Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0 11 22 33 44]\n",
      "[10 21 32 43]\n"
     ]
    }
   ],
   "source": [
    "print(np.diag(A))\n",
    "print(np.diag(A,-1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**take**: similar to fancy indexing described above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:09.297961Z",
     "start_time": "2020-06-24T09:04:09.291538Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-3 -2 -1  0  1  2]\n",
      "[-2  0  2]\n",
      "[-2  0  2]\n"
     ]
    }
   ],
   "source": [
    "v2 = np.arange(-3,3)\n",
    "print(v2)\n",
    "\n",
    "row_indices = [1, 3, 5]\n",
    "print(v2[row_indices]) # fancy indexing\n",
    "print(v2.take(row_indices))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Linear algebra\n",
    "\n",
    "**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.\n",
    "\n",
    "## Scalar-array operations\n",
    "\n",
    "We can use the usual arithmetic operators to multiply, add, subtract, and divide arrays with scalar numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:09.310160Z",
     "start_time": "2020-06-24T09:04:09.301575Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4]\n",
      "[2 4 6 8]\n",
      "[[ 0  1  2  3  4]\n",
      " [10 11 12 13 14]\n",
      " [20 21 22 23 24]\n",
      " [30 31 32 33 34]\n",
      " [40 41 42 43 44]]\n",
      "[[ 0  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"
     ]
    }
   ],
   "source": [
    "print(v)\n",
    "print(v * 2)\n",
    "\n",
    "print(A)\n",
    "print(2 * A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Element-wise array-array operations\n",
    "\n",
    "When we add, subtract, multiply and divide arrays with each other, **the default behaviour is element-wise operations**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:09.324279Z",
     "start_time": "2020-06-24T09:04:09.316305Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 2 4 6 8]\n",
      "[[   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]]\n"
     ]
    }
   ],
   "source": [
    "v1 = np.arange(0, 5)\n",
    "\n",
    "print(v1 + v1) # element-wise addition\n",
    "print(A * A) # element-wise multiplication"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Broadcasting\n",
    "\n",
    "The term **broadcasting** describes how `numpy` treats arrays with *different shapes* during arithmetic operations. Subject to certain constraints, the smaller array is “broadcast” across the larger array so that they have compatible shapes.\n",
    "\n",
    "`numpy` operations are usually done on pairs of arrays on an element-by-element basis:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:09.339337Z",
     "start_time": "2020-06-24T09:04:09.329340Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3  4]\n",
      " [10 11 12 13 14]\n",
      " [20 21 22 23 24]\n",
      " [30 31 32 33 34]\n",
      " [40 41 42 43 44]]\n",
      "[0 1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "print(A)\n",
    "print(v1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:09.351975Z",
     "start_time": "2020-06-24T09:04:09.344154Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5, 5) (5,)\n"
     ]
    }
   ],
   "source": [
    "print(A.shape, v1.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:09.368213Z",
     "start_time": "2020-06-24T09:04:09.357556Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  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]]\n",
      "[[  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]]\n"
     ]
    }
   ],
   "source": [
    "print(A * v1)\n",
    "print(v1 * A)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When operating on two arrays, `numpy` compares their shapes element-wise. It starts with the **trailing dimension**, and works its way forward. Two dimensions are compatible when:\n",
    "\n",
    "* they are equal, or\n",
    "* one of them is 1.\n",
    "\n",
    "Otherwise a `ValueError: frames are not aligned` exception is thrown.\n",
    "\n",
    "**Examples**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:09.387859Z",
     "start_time": "2020-06-24T09:04:09.376659Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4,)\n",
      "(3, 1)\n",
      "[[11 12 13 14]\n",
      " [11 12 13 14]\n",
      " [11 12 13 14]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([1,2,3,4])\n",
    "print(x.shape)\n",
    "\n",
    "y = np.array([[10],[10],[10]])\n",
    "print(y.shape)\n",
    "\n",
    "print(x + y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-23T16:27:12.126707Z",
     "start_time": "2020-06-23T16:27:11.969734Z"
    }
   },
   "source": [
    "![Broadcasting](images/bc1.png)\n",
    "![Broadcasting](images/bc2.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Matrix Algebra\n",
    "\n",
    "What about matrix mutiplication? There are two ways. We can either use the `np.dot` function, which applies a matrix-matrix, matrix-vector, or inner vector multiplication to its two arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:09.406474Z",
     "start_time": "2020-06-24T09:04:09.393766Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n",
      "[ 30 130 230 330 430]\n",
      "[300 310 320 330 340]\n",
      "[[ 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]]\n"
     ]
    }
   ],
   "source": [
    "print(np.dot(v1, v1))\n",
    "print(np.dot(A, v1))\n",
    "print(np.dot(v1, A))\n",
    "print(np.dot(A, A))"
   ]
  },
  {
   "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": 220,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:09.424877Z",
     "start_time": "2020-06-24T09:04:09.413701Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3  4]\n",
      " [10 11 12 13 14]\n",
      " [20 21 22 23 24]\n",
      " [30 31 32 33 34]\n",
      " [40 41 42 43 44]]\n",
      "[[0]\n",
      " [1]\n",
      " [2]\n",
      " [3]\n",
      " [4]]\n"
     ]
    }
   ],
   "source": [
    "M = np.matrix(A)\n",
    "print(M)\n",
    "\n",
    "v = np.matrix(v1).T # make it a column vector\n",
    "print(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:09.450622Z",
     "start_time": "2020-06-24T09:04:09.438995Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[30]]\n",
      "[[ 30]\n",
      " [130]\n",
      " [230]\n",
      " [330]\n",
      " [430]]\n",
      "[[ 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]]\n"
     ]
    }
   ],
   "source": [
    "print(v.T * v) # v.T denotes the transpose of v\n",
    "print(M * v)\n",
    "print(M * M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we try to add, subtract or multiply objects with incomplatible shapes we get an error."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Array/Matrix transformations\n",
    "\n",
    "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:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:09.483096Z",
     "start_time": "2020-06-24T09:04:09.459112Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.+1.j 0.+2.j]\n",
      " [0.+3.j 0.+4.j]]\n",
      "[[0.-1.j 0.-2.j]\n",
      " [0.-3.j 0.-4.j]]\n",
      "[[0.-1.j 0.-3.j]\n",
      " [0.-2.j 0.-4.j]]\n",
      "[[0. 0.]\n",
      " [0. 0.]]\n",
      "[[1. 2.]\n",
      " [3. 4.]]\n",
      "[[1. 2.]\n",
      " [3. 4.]]\n",
      "[[0.78539816 1.10714872]\n",
      " [1.24904577 1.32581766]]\n"
     ]
    }
   ],
   "source": [
    "C = np.matrix([[1j, 2j], [3j, 4j]])\n",
    "print(C)\n",
    "\n",
    "print(np.conjugate(C))\n",
    "\n",
    "print(C.H)\n",
    "\n",
    "print(np.real(C)) # same as: C.real\n",
    "\n",
    "print(np.imag(C)) # same as: C.imag\n",
    "\n",
    "print(np.abs(C))\n",
    "\n",
    "print(np.angle(1 + C))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matrix computations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**inverse**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:09.495866Z",
     "start_time": "2020-06-24T09:04:09.487871Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.+2.j  0.-1.j ]\n",
      " [0.-1.5j 0.+0.5j]]\n"
     ]
    }
   ],
   "source": [
    "print(np.linalg.inv(C))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**determinant**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:04:09.512789Z",
     "start_time": "2020-06-24T09:04:09.501126Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2.0000000000000004+0j)\n"
     ]
    }
   ],
   "source": [
    "print(np.linalg.det(C))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data processing\n",
    "\n",
    "Often it is useful to store datasets in `numpy` arrays. `numpy` provides a number of functions to calculate statistics of datasets in arrays. These functions are called **universal functions**, or *ufunc*s, and they perform element-wise operations on data in ndarrays."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**sqrt** and **exp**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:06:23.204198Z",
     "start_time": "2020-06-24T09:06:23.193627Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.         1.41421356 1.73205081 2.         2.23606798 2.44948974\n",
      " 2.64575131 2.82842712 3.         3.16227766]\n",
      "[2.71828183e+00 7.38905610e+00 2.00855369e+01 5.45981500e+01\n",
      " 1.48413159e+02 4.03428793e+02 1.09663316e+03 2.98095799e+03\n",
      " 8.10308393e+03 2.20264658e+04]\n"
     ]
    }
   ],
   "source": [
    "print(np.sqrt(data[:10,2]))\n",
    "print(np.exp(data[:10,2]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**mean**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-23T16:41:22.668399Z",
     "start_time": "2020-06-23T16:41:22.659635Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6.197109684751585\n"
     ]
    }
   ],
   "source": [
    "print(np.mean(data[:,3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**standard deviations** and **variance**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-23T16:41:34.178662Z",
     "start_time": "2020-06-23T16:41:34.164735Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8.282271621340573 68.59602320966341\n"
     ]
    }
   ],
   "source": [
    "print(np.std(data[:,3]), np.var(data[:,3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**min** and **max**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:07:57.007785Z",
     "start_time": "2020-06-24T09:07:56.998001Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-25.8\n",
      "28.3\n"
     ]
    }
   ],
   "source": [
    "print(data[:,3].min())\n",
    "print(data[:,3].max())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**argmin** and **argmax**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:22:11.528828Z",
     "start_time": "2020-06-24T09:22:11.518744Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1, 1, 6, 77, 8, 100, 4, 100])\n",
    "print(a.argmax())\n",
    "print(a.argmin())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**sum** and **prod**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-23T16:43:22.050384Z",
     "start_time": "2020-06-23T16:43:22.034406Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n",
      "45\n",
      "3628800\n",
      "[ 0  1  3  6 10 15 21 28 36 45]\n",
      "[      1       2       6      24     120     720    5040   40320  362880\n",
      " 3628800]\n"
     ]
    }
   ],
   "source": [
    "d = np.arange(0, 10)\n",
    "print(d)\n",
    "\n",
    "# sum up all elements\n",
    "print(np.sum(d))\n",
    "# product of all elements\n",
    "print(np.prod(d + 1))\n",
    "# cummulative sum\n",
    "print(np.cumsum(d))\n",
    "# cummulative product\n",
    "print(np.cumprod(d + 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-24T09:09:29.034656Z",
     "start_time": "2020-06-24T09:09:29.025291Z"
    }
   },
   "source": [
    "The following table contains a list of the most important unary ufuncs.\n",
    "\n",
    "|Function| Description |\n",
    "|:-------|:---------|\n",
    "|`abs`|Compute the absolute value element-wise for integer, floating-point, or complex values|\n",
    "|`sqrt`|Compute the square root of each element|\n",
    "|`exp`|Compute the exponent $e^x$ of each element|\n",
    "|`log`, `log10`, `log2`, `log1p`|Natural logarithm (base e), log base 10, log base 2, and log(1 + x), respectively|\n",
    "|`sign`|Compute the sign of each element: 1 (positive), 0 (zero), or –1 (negative)|\n",
    "|`ceil`|Compute the ceiling of each element|\n",
    "|`floor`|Compute the floor of each element|\n",
    "|`modf`|Return fractional and integral parts of array as a separate array|\n",
    "|`isnan`|Return boolean array indicating whether each value is `NaN` (Not a Number)|\n",
    "|`cos`, `cosh`, `sin`, `sinh`, `tan`, `tanh`|Regular and hyperbolic trigonometric functions|\n",
    "|`arccos`, `arccosh`, `arcsin`, `arcsinh`, `arctan`, `arctanh`|Inverse trigonometric functions|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following table contains a list of the most important binary ufuncs.\n",
    "\n",
    "|Function| Description |\n",
    "|:-------|:---------|\n",
    "|`add`|Element-wise addition|\n",
    "|`subtract`|Element-wise subtraction|\n",
    "|`multiply`|Element-wise multiplication|\n",
    "|`divide`|Element-wise division|\n",
    "|`mod`|Element-wise modulus|\n",
    "|`power`|Raise elements in first array to powers indicated in second array |\n",
    "|`maximum`, `fmax`|Element-wise maximum; `fmax` ignores `NaN`|\n",
    "|`minimum`, `fmin`|Element-wise minimum; `fmin` ignores `NaN`|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calculations with higher-dimensional data\n",
    "\n",
    "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": 131,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-23T16:47:01.526274Z",
     "start_time": "2020-06-23T16:47:01.512008Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.75013982 0.25855643 0.20451342]\n",
      " [0.3395779  0.05939731 0.18313579]\n",
      " [0.41019777 0.84448317 0.73466085]]\n",
      "0.8444831703244384\n",
      "[0.75013982 0.84448317 0.73466085]\n",
      "[0.75013982 0.3395779  0.84448317]\n"
     ]
    }
   ],
   "source": [
    "M = np.random.rand(3,3)\n",
    "print(M)\n",
    "\n",
    "# global max\n",
    "print(M.max())\n",
    "\n",
    "# max in each column\n",
    "print(M.max(axis=0))\n",
    "\n",
    "# max in each row\n",
    "print(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.\n",
    "\n",
    "## Reshaping, resizing and stacking arrays\n",
    "\n",
    "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": 135,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-23T16:49:30.833710Z",
     "start_time": "2020-06-23T16:49:30.826817Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 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]]\n"
     ]
    }
   ],
   "source": [
    "print(A)\n",
    "n, m = A.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-23T16:49:35.114441Z",
     "start_time": "2020-06-23T16:49:35.105184Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 5  5  5  5  5 10 11 12 13 14 20 21 22 23 24 30 31 32 33 34 40 41 42 43\n",
      "  44]]\n"
     ]
    }
   ],
   "source": [
    "B = A.reshape((1, n * m))\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-23T16:49:57.541930Z",
     "start_time": "2020-06-23T16:49:57.532230Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 5  5  5  5  5 10 11 12 13 14 20 21 22 23 24 30 31 32 33 34 40 41 42 43\n",
      "  44]]\n"
     ]
    }
   ],
   "source": [
    "B[0, 0:5] = 5 # modify the array\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-23T16:50:04.909981Z",
     "start_time": "2020-06-23T16:50:04.901987Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 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]]\n"
     ]
    }
   ],
   "source": [
    "print(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": 140,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-23T16:50:56.903607Z",
     "start_time": "2020-06-23T16:50:56.895078Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 5  5  5  5  5 10 11 12 13 14 20 21 22 23 24 30 31 32 33 34 40 41 42 43\n",
      " 44]\n"
     ]
    }
   ],
   "source": [
    "B = A.flatten()\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding a new dimension\n",
    "\n",
    "With `np.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": 146,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-23T16:53:15.062564Z",
     "start_time": "2020-06-23T16:53:15.055109Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3,)\n",
      "(3, 1)\n",
      "(1, 3)\n"
     ]
    }
   ],
   "source": [
    "v = np.array([1,2,3])\n",
    "print(v.shape)\n",
    "\n",
    "# make a column matrix of the vector v\n",
    "w = v[:, np.newaxis]\n",
    "print(w.shape)\n",
    "\n",
    "# make a row matrix of the vector v\n",
    "w = v[np.newaxis, :]\n",
    "print(w.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Stacking and repeating arrays\n",
    "\n",
    "Using the functions `repeat`, `tile`, `vstack`, `hstack`, and `concatenate` we can create larger vectors and matrices from smaller ones.\n",
    "\n",
    "**tile** and **repeat**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-23T16:55:44.731052Z",
     "start_time": "2020-06-23T16:55:44.724948Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1, 2], [3, 4]])\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-23T16:55:45.671908Z",
     "start_time": "2020-06-23T16:55:45.659073Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 1 1 2 2 2 3 3 3 4 4 4]\n"
     ]
    }
   ],
   "source": [
    "# repeat each element 3 times\n",
    "print(np.repeat(a, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-23T16:55:46.695374Z",
     "start_time": "2020-06-23T16:55:46.687146Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 1 2 1 2]\n",
      " [3 4 3 4 3 4]]\n"
     ]
    }
   ],
   "source": [
    "# tile the matrix 3 times \n",
    "print(np.tile(a, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**concatenate**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-23T16:56:36.307191Z",
     "start_time": "2020-06-23T16:56:36.300130Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[5 6]]\n"
     ]
    }
   ],
   "source": [
    "b = np.array([[5, 6]])\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-23T16:56:44.848269Z",
     "start_time": "2020-06-23T16:56:44.838116Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n"
     ]
    }
   ],
   "source": [
    "print(np.concatenate((a, b), axis=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-23T16:56:51.248589Z",
     "start_time": "2020-06-23T16:56:51.237734Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 5]\n",
      " [3 4 6]]\n"
     ]
    }
   ],
   "source": [
    "print(np.concatenate((a, b.T), axis=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**hstack** and **vstack**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-23T16:57:06.881587Z",
     "start_time": "2020-06-23T16:57:06.870424Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n"
     ]
    }
   ],
   "source": [
    "print(np.vstack((a, b)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-23T16:57:13.429944Z",
     "start_time": "2020-06-23T16:57:13.416895Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 5]\n",
      " [3 4 6]]\n"
     ]
    }
   ],
   "source": [
    "print(np.hstack((a, b.T)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Iterating over arrays\n",
    "\n",
    "In general, **avoid iterating over the elements of arrays whenever possible (at all costs)**. The reason is that in a interpreted language like Python iterations are really slow compared to vectorized operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}