Notebooks/Numerical_Computing___Numpy_Arrays.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numerical Computing - Numpy Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Author**: [Gabriele Pompa](https://www.linkedin.com/in/gabrielepompa/): gabriele.pompa@unisi.com"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Table of contents\n",
    "\n",
    "[Executive Summary](#summary)\n",
    "1. [Introduction: from Lists to Arrays](#intro)\\\n",
    "    1.1. [`numpy.ndarray` $\\mu \\epsilon \\tau \\alpha$-informations](#meta_info)\n",
    "2. [1-dim arrays](#1_dim)\\\n",
    "    2.1. [Array Creation](#creation_1d)\\\n",
    "&nbsp; &nbsp; &nbsp; &nbsp; 2.1.1. [From Lists or Tuples](#from_lists_1d)\\\n",
    "&nbsp; &nbsp; &nbsp; &nbsp; 2.1.2. [From sequences of numbers: `np.arange()`](#arange_linspace)\\\n",
    "&nbsp; &nbsp; &nbsp; &nbsp; 2.1.3. [Using placeholder content: `np.zeros()`, `np.ones()`, `np.empty()`](#arange_linspace_1d)\\\n",
    "2.2. [Indexing, Slicing, Assigning and Iterating](#index_slice_iter_1d)\\\n",
    "&nbsp; &nbsp; &nbsp; &nbsp; 2.2.1. [Indexing](#ind_1d)\\\n",
    "&nbsp; &nbsp; &nbsp; &nbsp; 2.2.2. [Slicing](#slice_1d)\\\n",
    "&nbsp; &nbsp; &nbsp; &nbsp; 2.2.3. [Assigning new values](#assign_1d)\\\n",
    "&nbsp; &nbsp; &nbsp; &nbsp; 2.2.4. [Iterating over arrays](#iter_1d)\\\n",
    "    2.3. [Basic operations (are _element-wise_ )](#indexing_slicing_iterating)\\\n",
    "&nbsp; &nbsp; &nbsp; &nbsp; 2.3.1. [_Focus on:_ `*` operator on lists](#*elementwise)\\\n",
    "&nbsp; &nbsp; &nbsp; &nbsp; 2.3.2. [Built-in methods: `.min()`, `.max()`, `.sum()` and more](#built_in_methods_1d)\\\n",
    "&nbsp; &nbsp; &nbsp; &nbsp; 2.3.3. [Universal functions](#univ_func_1d)\n",
    "3. [N-dim arrays](#N_dim)\\\n",
    "    3.1. [Array Creation](#creation_ndim)\\\n",
    "&nbsp; &nbsp; &nbsp; &nbsp; 3.1.1. [From Lists or Tuples](#from_lists_ndim)\\\n",
    "&nbsp; &nbsp; &nbsp; &nbsp; 3.1.2. [_Focus on:_ printing arrays](#print_array_ndim)\\\n",
    "&nbsp; &nbsp; &nbsp; &nbsp; 3.1.1. [Using placeholder content: role of the `shape` parameter](#arange_linspace_ndim)\\\n",
    "    3.2. [Indexing, Slicing, Assigning and Iterating](#indexing_slicing_iterating_ndim)\\\n",
    "&nbsp; &nbsp; &nbsp; &nbsp; 3.2.1. [Indexing](#ind_nd)\\\n",
    "&nbsp; &nbsp; &nbsp; &nbsp; 3.2.2. [Slicing](#slice_nd)\\\n",
    "&nbsp; &nbsp; &nbsp; &nbsp; 3.2.3. [Assigning new values](#assign_nd)\\\n",
    "&nbsp; &nbsp; &nbsp; &nbsp; 3.2.4. [Iterating over N-dim arrays](#iter_nd)\\\n",
    "    3.3. [Basic operations (are _element-wise_ )](#basic_op_nd)\\\n",
    "&nbsp; &nbsp; &nbsp; &nbsp; 3.3.1. [_Focus on:_ Matrix Operations](#matrix_operations_nd)\\\n",
    "&nbsp; &nbsp; &nbsp; &nbsp; 3.3.2. [Built-in methods: role of the `axis` parameter](#built_in_methods_nd)\\\n",
    "&nbsp; &nbsp; &nbsp; &nbsp; 3.3.3. [Universal functions](#univ_func_nd)\\\n",
    "    3.4. [Shape Manipulation](#shape_manipulation)\\\n",
    "&nbsp; &nbsp; &nbsp; &nbsp; 3.4.1. [Changing the shape: `.reshape()`](#reshape)\\\n",
    "&nbsp; &nbsp; &nbsp; &nbsp; 3.4.2. [_Focus on:_ Matrix Transpose `.T`](#mat_T)\\\n",
    "&nbsp; &nbsp; &nbsp; &nbsp; 3.4.3. [Changing the size: `.resize()`](#resize)\\\n",
    "&nbsp; &nbsp; &nbsp; &nbsp; 3.4.4. [From N-dim to 1-dim: `.flatten()`](#flatten)\\\n",
    "    3.5. [Stacking Arrays together: `.hstack()` and `.vstack()`](#stacking)\\\n",
    "    3.6. [Indexing with Boolean Arrays](#cond_ind)\\\n",
    "&nbsp; &nbsp; &nbsp; &nbsp; 3.6.1. [Boolean Arrays](#bool_arrays)\\\n",
    "&nbsp; &nbsp; &nbsp; &nbsp; 3.6.2. [Conditional Selection](#ind_with_bool_arrays)\n",
    "4. [Lists Vs Arrays](#list_vs_arrays)\\\n",
    "    4.1. [Speed-comparison: Lists 0 - 1 Arrays](#speed_comp)\\\n",
    "    4.2. [_Vectorization_ of code: Lists 0 - 2 Arrays](#vectorization)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Resources**: \n",
    "\n",
    "- [_Python for Finance (2nd ed.)_](http://shop.oreilly.com/product/0636920117728.do): Sec. 4.Numpy Arrays, 4.Basic Vectorization\n",
    "\n",
    "\n",
    "- _[Numpy Quickstart Tutorial - The Basics](https://docs.scipy.org/doc/numpy/user/quickstart.html#the-basics)_ (An Example; Array Creation; Printing Arrays; Basic Operations; Universal Functions; Indexing, Slicing and Iterating), _[Numpy Quickstart Tutorial - Shape Manipulation](https://docs.scipy.org/doc/numpy/user/quickstart.html#shape-manipulation)_ (Changing the shape of an array; Stacking together different arrays), _[Numpy Quickstart Tutorial - Indexing with Boolean Arrays](https://docs.scipy.org/doc/numpy/user/quickstart.html#indexing-with-boolean-arrays)._"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Executive Summary <a name=\"summary\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following sections are organized as follows: \n",
    "- In Sec. [1](#intro) we provide the motivation for a more specialized data-structure to model sequences of numbers w.r.t. lists.\n",
    "- In Sec. [2](1_dim) we introduce 1-dimensional NumPy's arrays, describing their similarities with lists (indexing, slicing, ...) and their peculiarities (element-wise operations).\n",
    "- In Sec. [3](N_dim) we generalize to multi-dimensional NumPy's arrays and their smart methods and universal functions that make them a great asset for numerical analysis.\n",
    "- In Sec. [4](list_vs_arrays) we conclude comparing Lists and NumPy's arrays in terms of speed of code and efficiency."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Introduction: from Lists to Arrays <a name=\"intro\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll keep this discussion as intuitive as possible and as informal as possible too.\n",
    "The concept of _array_ belongs to two knowledge domains (at least):\n",
    "\n",
    "- **Mathematics**: an array is a sequence of numbers of the same type (Naturals, Rationals, Reals,...). It can be:\n",
    "\n",
    "    - a 1-dimensional vector $v$. That is, the sequence of elements indexed by the one integer $i$;\n",
    "    - a 2-dimensional matrix $M$. That is, the sequence of elements indexed by the couple of integers $(i,j)$;\n",
    "    - a N>2-dimensional tensor $T$. That is, the sequence of elements indexed by n-tuple of n integers $(i_1, \\cdots, i_n)$. (*)\n",
    "    \n",
    "(*) Feel lost? Ok, no problem. Let's make an example with a 3-dimensional Tensor. So, if $N=3$, a 3-dimensional sequence of numbers can be visualized as a  _cube_ of numbers indexed by the 3 indexes $(i,j,k)$ where indexes $i$ and $j$ run along _height_ (rows axes) and _width_ (columns axes) of the cube, respectively. While index $k$ runs along the depth (say the _pages_ axes) of the cube. Therefore, each page is distinguished by the value of index $k=0,1,2,...$, whereas numbers on the same page differ by the values of $(i,j)$ indexes (yes, you can think each page as a matrix of numbers). For example, the $\\color{red}{\\text{red 1}}$ in the front page has indexes $(i,j,k) = (3,2,0)$, wherease the three $\\color{green}{\\text{green 2}}$ on the bottom right corner have share same $i=4$ and $j=4$ indexes and differ by the value of $k=0$ (front-page), $k=1$ (second page) and $k=2$ (back page). See picture. \n",
    "\n",
    "<img src=\"../images/tensor3d.png\" width=\"500\">\n",
    "\n",
    "- **Informatics**: an array is a sequence of data of the same data-type. The fact that all data stored in an array are of the same data-type is important because it allows to allocate the same amount of memory (bits) for each item in the array. Moreover, being a _sequence,_ translates into the fact that consecutive items are stored in consecutive portions of memory, which are thus easily to be indexed and therefore quicker to be accessed. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have already seen a great example of sequence-like data-structure in basic Python: the `list`. In particular Lists feature the following key facts:\n",
    "\n",
    "**a**: _Lists are sequences._ Therefore, consecutive elements of the lists can be allocated in consecutive slots of memory.\n",
    "\n",
    "**b**: _Lists can store simultaneously data of heterogeneous data-type._ Therefore, it's not known _a priori_ whether we can reserve the same amount of memory to each element of the list.\n",
    "\n",
    "**c**: _Lists are mutable (e.g. think to `.append()` method)._ Therefore, the totale amount of memory to be reserved for the allocation of the whole list is not known _a priori_ or, at most, is not fixed.\n",
    "\n",
    "Points **b** and **c**, though they make lists very flexible, they also represent bottlenecks in terms of memory usage and performance. Lists are somehow too _general_ to be excell excel in performance too. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is the need of a more _specialized_ data-structure, sharing with lists the sequentiality of data, but compromising on some flexibility in the name of performance. That's why we have [NumPy](https://docs.scipy.org/doc/numpy/user/quickstart.html#quickstart-tutorial) and its data-structure `numpy.ndarray` has been created."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Key-facts of Numpy's arrays:\n",
    "\n",
    "**a**: arrays extend the sequentiality of lists, introducing a built-in notion of dimensions (called _axes_ );\n",
    "\n",
    "**b**: array's length ( _size_ ) is constrained to be immutable;\n",
    "\n",
    "**c**: array's items are constrained to have the same data-type;\n",
    "\n",
    "The built-in notion of dimensions allows to easily map the mathematical concepts of vectors, matrices and N-dimensional tensors into 1-dim, 2-dim and N-dim Numpy's arrays, respectively. Moreover, the constraints on array size ( **b** ) and same data-type **c** allow several speed improvements and _vectorization_ of code. That is, those allow to have fast(er) memory access and to write functions that work on all the elements of an array \"at once\".  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.1. `numpy.ndarray` $\\mu \\epsilon \\tau \\alpha$-informations <a name=\"meta_info\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These key-facts translates into the following meta-informations that can be accessed as [attributes of any array](https://docs.scipy.org/doc/numpy/user/quickstart.html#the-basics):\n",
    "\n",
    "Attribute | Meaning | Constraints (if any)\n",
    ":---: | :---: | :---:\n",
    "`.ndim`  | The number of axes (dimensions) of an array: 1 for a vector, 2 for a matrix.... | -  |\n",
    "`.shape` | The dimensions of the array: a Tuple `(n,m)` for a matrix of `n` rows and `m` cols| -  |\n",
    "`.size` | The number of elements of the array: `n` $\\times$ `m` for a matrix of shape `(n,m)` | fixed (*)  |\n",
    "`.dtype` | The data-type of array's elements | fixed for all elements  |\n",
    "\n",
    "We'll use these attributes to explore arrays that we'll introduce.\n",
    "\n",
    "(*) the `.resize()` method allows to actually re-size an array, but creating a new array. See section [2.4.3. Changing the size: `.resize()`](#reshape).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function `type()` returns `numpy.ndarray` for NumPy's arrays. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As preliminary import we import `numpy` modulus and give to it the `np` alias"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we have access to all the contents of NumPy module. Let's start!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. 1-dim arrays <a name=\"1_dim\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We start with one-dimensional arrays (i.e. vectors). That is, a sequence of elements (usually numbers), all of the same data-type. As said, in NumPy, dimensions are called _axes_ and 1-dim arrays have 1 dimension."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1. Array Creation <a name=\"creation_1d\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Array can be created:\n",
    "- from Lists or Tuples;\n",
    "- from sequences of numbers;\n",
    "- using placeholder functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1.1. From Lists or Tuples  <a name=\"from_lists_1d\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We define a list of the first 0,...,9 integers squared"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lis = [i**2 for i in range(10)]\n",
    "lis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(lis)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and we can define a 1-dim array `vec` accordingly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  4,  9, 16, 25, 36, 49, 64, 81])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec = np.array(lis)\n",
    "vec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(vec)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that I defined separately the list `lis` just for clarity. The above definition is equivalent to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  4,  9, 16, 25, 36, 49, 64, 81])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec = np.array([i**2 for i in range(10)])\n",
    "vec"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take a look at `vec` meta-informations:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`vec` is 1-dimensional:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec.ndim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "altough not very significant in the 1-dim case, let's take a look at its shape: it has all the 10 values arranged along its unique dimension "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10,)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The number of elements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "observe that in the 1-dim case, you can retrieve the number of elements also using the `len()` function..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(vec)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "...but we'll see this is not the case in the N-dimensional case, so please use `vec.size` if you want to know how many numbers your array holds. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, having defined our vector as the array of the first 10 integers squared, it is created with elements of integer data-type and its `.dtype` is inferred accordingly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int32')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Don't be scared by the fact that what is returned is `dtype('int32')` and not simply `int`, it's just that NumPy that has chosen to have it's own data-types. Anyway, you can read `dtype('int32')` as `int` peacefully."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice, that we could also have chosen explicitly to define our array as an array of Floats, instead of integers, using the `dtype` parameter of `np.array()` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.,  1.,  4.,  9., 16., 25., 36., 49., 64., 81.])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec_float = np.array(lis, dtype='float')\n",
    "vec_float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec_float.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and as you can see `vec_float` is the same of `vec` but its elements are all casted as decimal numbers and its data-type is then `dtype('float64')` (NumPy's version for `float`)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A possible _signature_ for the creational function `np.array()` would be \n",
    "\n",
    "`np.array(sequence[, dtype])` \n",
    "\n",
    "where `sequence` could be a list and `dtype` - if not provided - is inferred by the data-type of `sequence`'s elements, as we have just seen. The syntax `[, optionalArgument]` is conventional. Get familiar with it. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### What if we mix data-types? <a name=\"mixing_types\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recall that all the elements of a NumPy's array must share the same data-type, therefore if we mix (intentionally or unintentionally) types, it's `np.array` internals that take care of the required homogeneization of elements data-types. It's of course your duty to be aware of it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can distinguish a couple of relevant cases:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `int` and `float`: NumPy promotes integers to floats and define the array as float `dtype`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lis:  [1, 2.5, 5, 6, 7.5]\n",
      "dtype:  float64\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([1. , 2.5, 5. , 6. , 7.5])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lis = [1, 2.5, 5, 6, 7.5]\n",
    "print(\"lis: \", lis)\n",
    "\n",
    "vec = np.array(lis)\n",
    "print(\"dtype: \", vec.dtype)\n",
    "vec"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- numbers and `str`: NumPy casts all the numbers as Strings and define the array as Unicode-encoded characters `dtype` (the `U` stands for Unicode), that is an array of string-like characters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lis:  [1, 2.5, 'EUR']\n",
      "dtype:  <U32\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array(['1', '2.5', 'EUR'], dtype='<U32')"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lis = [1, 2.5, \"EUR\"]\n",
    "print(\"lis: \", lis)\n",
    "\n",
    "vec = np.array(lis)\n",
    "print(\"dtype: \", vec.dtype)\n",
    "vec"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, in these examples, lists are separately defined just for clarity. You could equivalently do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dtype:  <U32\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array(['1', '2.5', 'EUR'], dtype='<U32')"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec = np.array(lis)\n",
    "print(\"dtype: \", vec.dtype)\n",
    "vec"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Take-home message**: do not mix data-types in `np.array()` (unless you have a strong reason to do it)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1.2. From sequences of numbers: `np.arange()`  <a name=\"arange_linspace\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to create an array from a sequence of numbers, you can use \n",
    "\n",
    "`np.arange([start,] stop[, step])` \n",
    "\n",
    "which creates a 1-dim array of numbers from `start` to `stop-1`, each `step` numbers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As suggested by the use of `[]` conventional syntax in `arange`'s signature, the parameters `start` and `step` are optional and - if not specified - default values are `start=0` and `step=1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec = np.arange(10)\n",
    "vec"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "which is equal to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "vec = np.arange(0,11,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In general we can write"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.  , 1.25, 1.5 , 1.75, 2.  , 2.25, 2.5 , 2.75, 3.  , 3.25, 3.5 ,\n",
       "       3.75, 4.  , 4.25, 4.5 , 4.75, 5.  , 5.25, 5.5 , 5.75, 6.  , 6.25,\n",
       "       6.5 , 6.75])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec = np.arange(1, 7, 0.25)\n",
    "vec"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When working with floating point values, the finite-precision may cause impredictability of the number of elements returned by `np.arange()`. Therefore, where the size is something we want to control for, it's better to use\n",
    "\n",
    "`np.linspace([start,] stop[, num])` \n",
    "\n",
    "which returns a 1-dimensional array of `num` numbers from `start`(included) to `stop` included "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 0.10344828, 0.20689655, 0.31034483, 0.4137931 ,\n",
       "       0.51724138, 0.62068966, 0.72413793, 0.82758621, 0.93103448,\n",
       "       1.03448276, 1.13793103, 1.24137931, 1.34482759, 1.44827586,\n",
       "       1.55172414, 1.65517241, 1.75862069, 1.86206897, 1.96551724,\n",
       "       2.06896552, 2.17241379, 2.27586207, 2.37931034, 2.48275862,\n",
       "       2.5862069 , 2.68965517, 2.79310345, 2.89655172, 3.        ])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(0,3,30)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is typically used when one wants to evaluate a function at a lot of points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import pi # importing pi constant\n",
    "\n",
    "x = np.linspace(0,2*pi,1000)\n",
    "y = np.sin(x) # this is another example of universal function, see later dedicated section"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "let's plot it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pylab as plt\n",
    "\n",
    "plt.plot(x,y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1.3. Using placeholder content: `np.zeros()`, `np.ones()`, `np.empty()`  <a name=\"arange_linspace_1d\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you know how long your vector should be but you don't know which values to input in advance, you can use one of these initialized functions:\n",
    "\n",
    "- `np.ones(shape[, dtype])`: creates an array of ones;\n",
    "- `np.zeros(shape[, dtype])`: creates an array of zeros;\n",
    "- `np.empty(shape[, dtype])`: creates an empty array, where the actual values depend on the state of memory.\n",
    "\n",
    "In each of these, \n",
    "\n",
    "- `dtype` is optional and, default set to `float64` (NumPy's ``float` type);\n",
    "- `shape`, in the 1-dim case, is an `int` number representing the number of values the vector will holds.\n",
    "\n",
    "These functions are used in their full generality in the multi-dimensional case. We'll see this later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dtype:  float64\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec = np.ones(10)\n",
    "print(\"dtype: \", vec.dtype)\n",
    "vec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dtype:  int32\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec = np.ones(10, dtype=\"int\")\n",
    "print(\"dtype: \", vec.dtype)\n",
    "vec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dtype:  float64\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec = np.zeros(10)\n",
    "print(\"dtype: \", vec.dtype)\n",
    "vec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dtype:  int32\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec = np.zeros(10, dtype=\"int\")\n",
    "print(\"dtype: \", vec.dtype)\n",
    "vec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dtype:  float64\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec = np.empty(10)\n",
    "print(\"dtype: \", vec.dtype)\n",
    "vec"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "these values filled by `.empty()` could have been whatever depending on the current state of the memory"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2. Indexing, Slicing, Assigning and Iterating <a name=\"index_slice_iter_1d\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One-dimensional arrays can be _zero-based_ indexed, sliced and iterated over, much like lists and other Python sequences."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2.1. Indexing <a name=\"ind_1d\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's re-define our `vec` friend"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  4,  9, 16, 25, 36, 49, 64, 81])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec = np.array([i**2 for i in range(10)])\n",
    "vec"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The one-dimensional array `vec` can be indexed as\n",
    "\n",
    "`vec[i]`\n",
    "\n",
    "where `i` is the index of the $(i+1)$-th element of `vec`. Notice that:\n",
    "\n",
    "- positive indexing starts from `i == 0` up to `i == len(vec) - 1`\n",
    "- negative indexing starts from `i == -1` down to `i == -len(vec)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "numpy.int32"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 0 is the index of the first element of the array (positive indexing)\n",
    "print(vec[0])\n",
    "type(vec[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "81\n"
     ]
    }
   ],
   "source": [
    "# len(vec) -1 is the index of the last element of the array (positive indexing)\n",
    "print(vec[len(vec) - 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "81\n"
     ]
    }
   ],
   "source": [
    "# -1 is the index of the last element of the array (negative indexing)\n",
    "print(vec[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "# -len(vec) is the index of the last element of the array (negative indexing)\n",
    "print(vec[-len(vec)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2.2. Slicing <a name=\"slice_1d\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The one-dimensional array `vec` can be sliced as\n",
    "\n",
    "`vec[i:j:k]`\n",
    "\n",
    "where:\n",
    "\n",
    "- `i` is the starting index (included) of the slice. It is optional: if not provided is set to `i == 0` (slice from the start)\n",
    "- `j` is the starting index (excluded) of the slice, It is optional: if not provided is set to `j == len(vec)` (slice to the end)\n",
    "- `k` is the step of the slice. It is optional: if not provided is set to `k == 1` (each element). If negative, reads the array from the last element.\n",
    "\n",
    "That is, `vec[i:j:k]` slice `vec` from `vec[i]` to `vec[j-1]`, each `k` elements."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The role of the `:` (colon) is that of range selector. Here is the full range `vec[:]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  4,  9, 16, 25, 36, 49, 64, 81])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  4,  9, 16, 25, 36, 49, 64, 81])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec[:] # equivalent to simply vec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec_slice = vec[0:2] # elements from position 0 (included) to 2 (excluded)\n",
    "vec_slice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 4,  9, 16])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec[2:5] # elements from position 2 (included) to 5 (excluded)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec[:2]   # elements from the beginning to position 2 (excluded) --- equivalent to vec[0:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([64, 81])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec[-2:]  # elements from the second-last (included) to the end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The role of the step:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  9, 25])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec[1:7:2] # from position 1 (included) to 7 (excluded), each 2 elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  4, 16, 36, 64])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec[::2] # from the beginning to the end of vec, each 2 elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and this is how to revert the vector:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  4,  9, 16, 25, 36, 49, 64, 81])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([81, 64, 49, 36, 25, 16,  9,  4,  1,  0])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec[::-1] # literally from the beginning to the end of vec, each element starting from the last one"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2.3. Assigning new values <a name=\"assign_1d\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  4,  9, 16, 25, 36, 49, 64, 81])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To change a single value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  0,   1, -17,   9,  16,  25,  36,  49,  64,  81])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec[2] = -17\n",
    "vec"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To change a whole slice:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([16, 25, 36])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec[4:7] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([   0,    1,  -17,    9, 1000, 1000, 1000,   49,   64,   81])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec[4:7] = 1000\n",
    "vec"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2.4. Iterating over arrays <a name=\"iter_1d\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Iteration happen as in Python lists:\n",
    "\n",
    "- over the array;\n",
    "- counter-based (using `np.arange`)\n",
    "- using the `enumerate()` function\n",
    "\n",
    "let's quickly review the three methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  4,  9, 16, 25, 36, 49, 64, 81])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec = np.array([i**2 for i in range(10)])\n",
    "vec"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Iteration over the array: no access to the indexes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n",
      "1.0\n",
      "2.0\n",
      "3.0\n",
      "4.0\n",
      "5.0\n",
      "6.0\n",
      "7.0\n",
      "8.0\n",
      "9.0\n"
     ]
    }
   ],
   "source": [
    "from math import sqrt\n",
    "\n",
    "for square in vec:\n",
    "    print(sqrt(square))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Counter-based iteration using `np.arange()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "4\n",
      "9\n",
      "16\n",
      "25\n",
      "36\n",
      "49\n",
      "64\n",
      "81\n"
     ]
    }
   ],
   "source": [
    "for i in np.arange(vec.size):\n",
    "    print(vec[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Enumeration of indexes and values using `enumerate()`: access to both indexes and values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i = 0, vec_i = 0\n",
      "i = 1, vec_i = 1\n",
      "i = 2, vec_i = 4\n",
      "i = 3, vec_i = 9\n",
      "i = 4, vec_i = 16\n",
      "i = 5, vec_i = 25\n",
      "i = 6, vec_i = 36\n",
      "i = 7, vec_i = 49\n",
      "i = 8, vec_i = 64\n",
      "i = 9, vec_i = 81\n"
     ]
    }
   ],
   "source": [
    "for i, vec_i in enumerate(vec):\n",
    "    print(\"i = {}, vec_i = {}\".format(i, vec_i)) # vec_i is equivalent to vec[i]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.3. Basic operations (are _element-wise_ ) <a name=\"indexing_slicing_iterating\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Basic array operations are computed element-wise. We can distinguish a couple of relevant cases:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  4,  9, 16, 25, 36, 49, 64, 81])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec = np.array([i**2 for i in range(10)])\n",
    "vec"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- array `+` number: number is added to each element of array (same for `-`, `*`, `/`, `**` operators)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([100, 101, 104, 109, 116, 125, 136, 149, 164, 181])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec + 100 # equivalent to 100 + vec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1,  0,  3,  8, 15, 24, 35, 48, 63, 80])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec - 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  0,   2,   8,  18,  32,  50,  72,  98, 128, 162])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec * 2 # equivalent to 2 * vec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dtype:  float64\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([ 0.        ,  0.33333333,  1.33333333,  3.        ,  5.33333333,\n",
       "        8.33333333, 12.        , 16.33333333, 21.33333333, 27.        ])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec_new = vec / 3 # note the casting to float\n",
    "print(\"dtype: \", vec_new.dtype)\n",
    "vec_new"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([   0,    1,   16,   81,  256,  625, 1296, 2401, 4096, 6561],\n",
       "      dtype=int32)"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- array `+` array: elements are added element-wise (same for `-`, `*`, `/` operators)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([81, 64, 49, 36, 25, 16,  9,  4,  1,  0])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec_rev = vec[::-1]\n",
    "vec_rev"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([81, 65, 53, 45, 41, 41, 45, 53, 65, 81])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec + vec_rev # equivalent to vec_rev + vec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-81, -63, -45, -27,  -9,   9,  27,  45,  63,  81])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec - vec_rev"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  0,  64, 196, 324, 400, 400, 324, 196,  64,   0])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec * vec_rev # equivalent to vec_rev * vec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\gabri\\Anaconda3\\envs\\ITForBusAndFin2020_env\\lib\\site-packages\\ipykernel_launcher.py:1: RuntimeWarning: divide by zero encountered in true_divide\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.00000000e+00, 1.56250000e-02, 8.16326531e-02, 2.50000000e-01,\n",
       "       6.40000000e-01, 1.56250000e+00, 4.00000000e+00, 1.22500000e+01,\n",
       "       6.40000000e+01,            inf])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec / vec_rev  # notice the 'inf' and the warning when we divide by zero some elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([81, 64, 49, 36, 25, 16,  9,  4,  1,  0])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec_rev"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([          0,           1,           0,  -919996767,           0,\n",
       "       -2052264063,  1159987200,     5764801,          64,           1],\n",
       "      dtype=int32)"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec ** vec_rev # each element of vec is exponentiated to the corresponding element of vec_rev"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3.1. _Focus on:_ `*` operator on lists <a name=\"*elementwise\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On Lists, operator `*` have completely different behavior: it repeats (`*`) the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lis = [i**2 for i in range(10)]\n",
    "lis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lis * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3.2. Built-in methods: `.min()`, `.max()`, `.sum()` and more  <a name=\"built_in_methods_1d\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  4,  9, 16, 25, 36, 49, 64, 81])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the sum of its elements is"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "285"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec.sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "its minimum and maximum elements are"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "81\n"
     ]
    }
   ],
   "source": [
    "print(vec.min())\n",
    "print(vec.max())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "its mean and standard deviation (useful when working with arrays made from random values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "28.5"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "26.852374196707448"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec.std()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3.3. Universal functions  <a name=\"univ_func_1d\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Universal_ functions are functions which are  general enough to work both on NumPy's arrays (element-wise) and basic Python data types. We can just name a few, but there are many (many) more. Take a look [here](https://docs.scipy.org/doc/numpy/user/quickstart.html#universal-functions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  4,  9, 16, 25, 36, 49, 64, 81])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.00000000e+00, 2.71828183e+00, 5.45981500e+01, 8.10308393e+03,\n",
       "       8.88611052e+06, 7.20048993e+10, 4.31123155e+15, 1.90734657e+21,\n",
       "       6.23514908e+27, 1.50609731e+35])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.exp(vec) # exponential of each element of vec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20.085536923187668"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.exp(3) # e^3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sqrt(vec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.7320508075688772"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sqrt(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. N-dim arrays <a name=\"N_dim\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy arrays are born to be multi-dimensional. So we now talk about the NumPy’s main object: the homogeneous multidimensional array. It is a table of elements (usually numbers), all of the same type, indexed by a tuple of positive integers. In NumPy dimensions are called axes.\n",
    "\n",
    "We'll focus on the case $N=2$, which is the case of matrices. But what follows extends to any dimension $N>2$ too."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1. Array Creation <a name=\"creation_ndim\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In my experience, N-dim arrays are most easily created using placeholder functions like `np.ones()`, `np.zeros()` and `np.empty()` and then change the initiliazed values with our data.\n",
    "\n",
    "But, let's'quickly review the other methods too. As in the 1-dim case, they can be created:\n",
    "\n",
    "- from Lists or Tuples;\n",
    "- using placeholder functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1.1. From Lists or Tuples  <a name=\"from_lists_ndim\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nested lists can be used to define arrays. In general, funciton `np.array()` transforms:\n",
    "- sequences of sequences into two-dimensional arrays, \n",
    "- sequences of sequences of sequences into three-dimensional arrays, \n",
    "\n",
    "and so on."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's make an example with a list of lists, first five even numbers in the first list and first five odds numbers in the second. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[0, 2, 4, 6, 8], [1, 3, 5, 7, 9]]"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lis_of_lis = [[i for i in range(10) if i%2 == 0], [i for i in range(10) if i%2 != 0]]\n",
    "lis_of_lis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In passing, notice the flexibility of the lst comprehension, which allows to define a list from a loop with an `if` condition."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's now define the corresponding array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 2, 4, 6, 8],\n",
       "       [1, 3, 5, 7, 9]])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat = np.array(lis_of_lis)\n",
    "mat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "which we have called `mat` as it can indeed represent a $2 \\times 5$ matrix of integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(mat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As said for the 1-dim case, I defined separately the list `lis_of_lis` just for clarity. The above definition is equivalent to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 2, 4, 6, 8],\n",
       "       [1, 3, 5, 7, 9]])"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat = np.array([[i for i in range(10) if i%2 == 0], [i for i in range(10) if i%2 != 0]])\n",
    "mat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's have a look at `mat` meta-informations. First of all, `mat` is 2-dimensional:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat.ndim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "now its shape: it has 2 rows with 5 values each"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 5)"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The number of elements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now observe the output of `len()` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(mat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`len()` applied to a multi-dimensional array simply returns the _length_ of the first axes which - for a 2-dim array - simply is the number of rows. It's not what we expected, that's why I reccomended to use `.size` instead."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`.dtype` considerations are as in the 1-dim case:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int32')"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1.2. _Focus on:_ printing arrays  <a name=\"print_array_ndim\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you print an array, NumPy displays it in this way:\n",
    "- 1-dim arrays are printed as _rows_ (as we have seen before);\n",
    "- 2-dim arrays are printed as matrices (_rows_ and _cols_ );\n",
    "- 3-dim arrays are printed as several matrices, one for each _page_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "l1:  [0, 1, 2]\n",
      "l2:  [0, 1, 4]\n",
      "l3:  [0, 1, 8]\n"
     ]
    }
   ],
   "source": [
    "l1 = [i for i in np.arange(3)]\n",
    "l2 = [i**2 for i in np.arange(3)]\n",
    "l3 = [i**3 for i in np.arange(3)]\n",
    "\n",
    "print(\"l1: \", l1)\n",
    "print(\"l2: \", l2)\n",
    "print(\"l3: \", l3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1-dim: vector of length 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2])"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec = np.array(l1)\n",
    "print(vec.ndim)\n",
    "vec"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2-dim: (2,3) matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "(2, 3)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [0, 1, 4]])"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat = np.array([l1,l2])\n",
    "\n",
    "print(mat.ndim)\n",
    "print(mat.shape)\n",
    "mat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3-dim case: 4 nested lists of 2 lists of length 3 each, which become 4 distinct $2 \\times 3$ matrices of numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "(4, 2, 3)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[[0, 1, 2],\n",
       "        [0, 1, 2]],\n",
       "\n",
       "       [[0, 1, 4],\n",
       "        [0, 1, 4]],\n",
       "\n",
       "       [[0, 1, 8],\n",
       "        [0, 1, 8]],\n",
       "\n",
       "       [[0, 1, 2],\n",
       "        [0, 1, 4]]])"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tensor = np.array([[l1,l1], [l2,l2], [l3,l3], [l1,l2]])\n",
    "\n",
    "print(tensor.ndim)\n",
    "print(tensor.shape)\n",
    "tensor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1.3. Using placeholder content: role of the `shape` parameter <a name=\"arange_linspace_ndim\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As in 1-dim case, when you know how many values you need to store, how you want to arrange them, but you don't know which values to input in advance, you can use one of these initialized functions:\n",
    "\n",
    "- `np.ones(shape[, dtype])`: creates an array of ones;\n",
    "- `np.zeros(shape[, dtype])`: creates an array of zeros;\n",
    "- `np.empty(shape[, dtype])`: creates an empty array, where the actual values depend on the state of memory.\n",
    "\n",
    "In each of these, \n",
    "\n",
    "- `dtype` is optional and, default set to `float64` (NumPy's `float` type);\n",
    "- `shape` is a Tuple number corresponding to the `.shape` attribute of the newly created array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dtype:  float64\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat = np.ones((2,5))\n",
    "print(\"dtype: \", mat.dtype)\n",
    "mat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dtype:  int32\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[1, 1, 1, 1, 1],\n",
       "       [1, 1, 1, 1, 1]])"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat = np.ones((2,5), dtype=\"int\")\n",
    "print(\"dtype: \", mat.dtype)\n",
    "mat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dtype:  float64\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat = np.zeros((2,5))\n",
    "print(\"dtype: \", mat.dtype)\n",
    "mat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dtype:  int32\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0]])"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat = np.zeros((2,5), dtype=\"int\")\n",
    "print(\"dtype: \", mat.dtype)\n",
    "mat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dtype:  float64\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat = np.empty((2,5))\n",
    "print(\"dtype: \", mat.dtype)\n",
    "mat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "these values filled by `.empty()` could have been whatever depending on the current state of the memory"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.2. Indexing, Slicing, Assigning and Iterating <a name=\"indexing_slicing_iterating_ndim\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multi-dimensional arrays have one index per axis. These indices are given as a comma-separated sequence. Each index follows the rules of 1-dim arrays. We'll focus here on the 2-dim case. Generalization to the $N>2$-dim case should be easy. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.1. Indexing <a name=\"ind_nd\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's re-define our `mat` matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 2, 4, 6, 8],\n",
       "       [1, 3, 5, 7, 9]])"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat = np.array([[i for i in range(10) if i%2 == 0], [i for i in range(10) if i%2 != 0]])\n",
    "mat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The 2-dimensional array `mat` can be indexed as\n",
    "\n",
    "`mat[i,j]`\n",
    "\n",
    "where `i` is the index of the rows and `j` the one of columns. Each index behaves as in the 1-dim case\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "numpy.int32"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(mat[0,1])\n",
    "type(mat[0,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "print(mat[1,-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.2. Slicing <a name=\"slice_nd\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The 2-dimensional array `mat` can be sliced as\n",
    "\n",
    "`mat[i:j:k, m:n:q]`\n",
    "\n",
    "where for each dimension, indexes have start, stop, step meanings as in the 1-dim case"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The role of the `:` (colon) is that of range selector. Here is the full range `mat[:]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 2, 4, 6, 8],\n",
       "       [1, 3, 5, 7, 9]])"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 2, 4, 6, 8],\n",
       "       [1, 3, 5, 7, 9]])"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat[:,:] # equivalent to simply mat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 2],\n",
       "       [1, 3]])"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat[:, 0:2] # elements from column 0 (included) to column 2 (excluded), all rows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 3, 5, 7, 9])"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat[1, :] # the second row"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The role of the step is the same as in the 1-dim case for each dim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 4, 8])"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat[0, ::2] # elements from the first row, each 2 columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 4])"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat[::-1, 2] # column 3, reading bottom-up the rows"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.3. Assigning new values <a name=\"assign_nd\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 2, 4, 6, 8],\n",
       "       [1, 3, 5, 7, 9]])"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To change a single value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat[1,2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  0,   2,   4,   6,   8],\n",
       "       [  1,   3, -17,   7,   9]])"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat[1,2] = -17\n",
    "mat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To change a whole slice:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 6, 8])"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat[0, 2:5] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[   0,    2, 1000, 1000, 1000],\n",
       "       [   1,    3,  -17,    7,    9]])"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat[0, 2:5] = 1000\n",
    "mat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.4. Iterating over N-dim arrays <a name=\"iter_nd\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because of celebrated _vectorization_ and Universal functions which apply element-wise to each array, `for` loops over multi-dim arrays are rarely used in practice."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For your knowledge, you can loop as you would do in the 1-dim case, but consider that the loops will be done over the first axis (rows in 2-dim case):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 2, 4, 6, 8],\n",
       "       [1, 3, 5, 7, 9]])"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat = np.array([[i for i in range(10) if i%2 == 0], [i for i in range(10) if i%2 != 0]])\n",
    "mat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 2 4 6 8]\n",
      "[1 3 5 7 9]\n"
     ]
    }
   ],
   "source": [
    "for row in mat:\n",
    "    print(row)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To loop over each element you can do a nested loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "2\n",
      "4\n",
      "6\n",
      "8\n",
      "1\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for row in mat:\n",
    "    for element in row:\n",
    "        print(element)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "which in real-life situation is highly inefficient and I discourage you to use it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3. Basic operations (are _element-wise_ ) <a name=\"basic_op_nd\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As in the 1-dim case, basic array operations are computed element-wise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 2, 4, 6, 8],\n",
       "       [1, 3, 5, 7, 9]])"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat = np.array([[i for i in range(10) if i%2 == 0], [i for i in range(10) if i%2 != 0]])\n",
    "mat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  4,  8, 12, 16],\n",
       "       [ 2,  6, 10, 14, 18]])"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and similarly for other mathematical operators."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3.1. _Focus on:_ Matrix Operations <a name=\"matrix_operations_nd\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The product operators works element-wise between matrices too:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of A: (n,m) =  (2, 2)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[0, 2],\n",
       "       [1, 3]])"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = mat[:,:2]\n",
    "print(\"Shape of A: (n,m) = \", A.shape)\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of B: (n,m) =  (2, 2)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[6, 8],\n",
       "       [7, 9]])"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = mat[:,-2:]\n",
    "print(\"Shape of B: (n,m) = \", B.shape)\n",
    "B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "such that the $(i,j)$ element of matrix `A*B` is \n",
    "\n",
    "$$\n",
    "(A*B)_{ij} = A_{ij} \\times B_{ij}\n",
    "$$\n",
    "\n",
    "which is not the element of the product-matrix of `A` and `B`..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0, 16],\n",
       "       [ 7, 27]])"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C_elementwise = A*B\n",
    "C_elementwise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The matrix product can be implemented using the `@` operator, such that the $(i,j)$ element of matrix `A @ B` is\n",
    "\n",
    "$$\n",
    "(A @ B)_{ij} = \\sum_{k=0}^{1} A_{ik} \\times B_{kj}\n",
    "$$\n",
    "\n",
    "given the common shape $(n,m)=(2,2)$, which makes `A @ B` the real product-matrix of `A` and `B`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[14, 18],\n",
       "       [27, 35]])"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AB = A @ B\n",
    "AB"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From linear algebra, recall that two matrices $A$ - of shape $(n,m)$ - and $D$ - of shape $(p,q)$ - an be multiplied together only if $m = q$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of D: (p,q) =  (2, 3)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[0, 2, 4],\n",
       "       [1, 3, 5]])"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D = mat[:,:3]\n",
    "print(\"Shape of D: (p,q) = \", D.shape)\n",
    "D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "therefore if you try to do `A @ D`, then no problem because $m=q=2$ and the product matrix of the shapes\n",
    "\n",
    "$$\n",
    "(n,m)=(2,2) \\times (2,3) = (p,q)\n",
    "$$\n",
    "\n",
    "will be a matrix of shape $(m,p)=(2,3)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of A: (n,m) =  (2, 2)\n",
      "Shape of D: (p,q) =  (2, 3)\n",
      "Shape of AD: (m,p) =  (2, 3)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 2,  6, 10],\n",
       "       [ 3, 11, 19]])"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AD = A @ D\n",
    "print(\"Shape of A: (n,m) = \", A.shape)\n",
    "print(\"Shape of D: (p,q) = \", D.shape)\n",
    "print(\"Shape of AD: (m,p) = \", AD.shape)\n",
    "AD"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "whereas if you try to multiply `D @ A`, this would be a product of matrices of shapes\n",
    "\n",
    "$$\n",
    "(p,q) = (2,3) \\times (2,2) = (n,m)\n",
    "$$\n",
    "\n",
    "which is _forbidden_ mathematically because of mismatch of the inner shapes: $q = 3 \\neq 2 = n$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This consistently results in the raise of the error: \n",
    "\n",
    "```python\n",
    "ValueError: matmul: Input operand 1 has a mismatch in its core dimension 0, with gufunc signature (n?,k),(k,m?)->(n?,m?) (size 2 is different from 3)\n",
    "```\n",
    "\n",
    "This (rather verbose) error message is simply warning you that of the mentioned mismatch between $q$ and $n$, which makes impossible to do `D @ A`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This raises: ValueError: matmul: Input operand 1 has a mismatch in its core dimension 0, \n",
    "#                          with gufunc signature (n?,k),(k,m?)->(n?,m?) (size 2 is different from 3)\n",
    "\n",
    "# D @ A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, notice that the element-wise products are (in general) defined only if the two matrices have the same shape. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is to say that `A*D`, which would try to do the element-wise product of matrices of shapes $(n,m)=(2,2)$ and $(p,q)=(2,3)$, raises:\n",
    "\n",
    "```python\n",
    "ValueError: operands could not be broadcast together with shapes (2,2) (2,3)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This raises: ValueError: operands could not be broadcast together with shapes (2,2) (2,3) \n",
    "\n",
    "# A*D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and, symmetrically, `D*A`, which would try to do the element-wise product of matrices of shapes $(p,q)=(2,3)$ and $(n,m)=(2,2)$, raises:\n",
    "\n",
    "```python\n",
    "ValueError: operands could not be broadcast together with shapes (2,3) (2,2) \n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This raises: ValueError: operands could not be broadcast together with shapes (2,3) (2,2) \n",
    "\n",
    "# D*A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3.2. Built-in methods: role of the `axis` parameter  <a name=\"built_in_methods_nd\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These built-in methods work the same as in the 1-dim case, but allow to specify the axis too:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 2, 4, 6, 8],\n",
       "       [1, 3, 5, 7, 9]])"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sum of all elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat.sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sum row-wise (that is, over rows for each column)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  5,  9, 13, 17])"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat.sum(axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sum column-wise (that is, over columns for each row)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([20, 25])"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat.sum(axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3.3. Universal functions  <a name=\"univ_func_nd\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Same as 1-dim case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 2, 4, 6, 8],\n",
       "       [1, 3, 5, 7, 9]])"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.00000000e+00, 7.38905610e+00, 5.45981500e+01, 4.03428793e+02,\n",
       "        2.98095799e+03],\n",
       "       [2.71828183e+00, 2.00855369e+01, 1.48413159e+02, 1.09663316e+03,\n",
       "        8.10308393e+03]])"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.exp(mat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.4. Shape Manipulation <a name=\"shape_manipulation\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we have seen, the shape of an array is the number of elements along each axis (read: dimensions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 0,  1,  4,  9],\n",
       "       [ 0,  1,  8, 27]])"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([[i for i in range(4)], \n",
    "                [i**2 for i in range(4)],\n",
    "                [i**3 for i in range(4)]])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 4)"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "so matrix `A`, which is for NumPy a 2-dim `numpy.ndarray`, has its 12 elements arranged in 3 rows and 4 columns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rows of A:  3\n",
      "Columns of A:  4\n"
     ]
    }
   ],
   "source": [
    "print(\"Rows of A: \", A.shape[0])\n",
    "print(\"Columns of A: \", A.shape[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that it's always true that the product of the numbers in the `.shape` Tuple is the `.size` of the array. \n",
    "\n",
    "In our example: `A.shape[0]` $\\times$ `A.shape[1]` $ = 3 \\times 4 = 12 = $ `A.size`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.4.1. Changing the shape: `.reshape()` <a name=\"reshape\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can change the shape of an array. That is, keeping the total number of elements constant, we can change the way in which they are arranged. There is an `numpy.ndarray` method to do this:\n",
    "\n",
    "`array.reshape(shape)`\n",
    "\n",
    "where `array` is the original array and `shape` is the new shape Tuple. The product of the `shape` Tuple must match the original `array.size`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example, instead of arranging the $3 \\times 4 = 12$ elements of `A` in a $(3,4)$ shape, we could arrange them as $(2,6)$ shape because $2 \\times 6 = 12$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  0,  1],\n",
       "       [ 4,  9,  0,  1,  8, 27]])"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_26 = A.reshape((2,6))\n",
    "A_26"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "which has a $(2,6)$ shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 6)"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_26.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "but still the same number of elements of `A`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_26.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Under the hoods: `.reshape()` is basically simply changing the _view_ of our array, without creating a new array. This is a cheap operation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that if you (intentionally or unintentionally) try to reshape an array with a new shape that wouldn't keep constant the number of items, an error is raised."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example, instead of arranging the $3 \\times 4 = 12$ elements of `A` in a $(3,4)$ shape, we try to arrange them in a $(2,8)$ shape... this raises the error\n",
    "\n",
    "```python\n",
    "ValueError: cannot reshape array of size 12 into shape (2,8)\n",
    "```\n",
    "\n",
    "because `A_28.size` $ = 2 \\times 8 = 16 \\neq 12 = $ `A.size`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 0,  1,  4,  9],\n",
       "       [ 0,  1,  8, 27]])"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This raises: ValueError: cannot reshape array of size 12 into shape (2,8)\n",
    "\n",
    "# A_28 = A.reshape((2,8))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.4.2. _Focus on:_ Matrix Transpose `.T` <a name=\"mat_T\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A particular kind of reshape is the exchange of rows for columns, which is the matematical operation of _transposition_ of a matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 0,  1,  4,  9],\n",
       "       [ 0,  1,  8, 27]])"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The transpose of A is simply calculated using the `.T` attribute of any array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  0,  0],\n",
       "       [ 1,  1,  1],\n",
       "       [ 2,  4,  8],\n",
       "       [ 3,  9, 27]])"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_t = A.T\n",
    "A_t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 3)"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_t.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_t.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.4.3. Changing the size: `.resize()` <a name=\"resize\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While, as we said, `.reshape()` simply change the view of an array, there is another method which can change the shape as well, but relaxing the constraint of having the `.size` constant. The function to do this is:\n",
    "\n",
    "`np.resize(array, shape)`\n",
    "\n",
    "Notice that `.resize()` will, in general, create a new array. This is then an expensive operation, which should be avoided as much as you can."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 0,  1,  4,  9],\n",
       "       [ 0,  1,  8, 27]])"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([[i for i in range(4)], \n",
    "                [i**2 for i in range(4)],\n",
    "                [i**3 for i in range(4)]])\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With `.resize()` we can do the same things we did with `.reshape()`, in particular simply rearranging the elements in a different shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  0,  1],\n",
       "       [ 4,  9,  0,  1,  8, 27]])"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_26 = np.resize(A, (2,6))\n",
    "A_26"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 6)"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_26.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_26.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or you can down-size (that is, select few numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [3, 0, 1]])"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_23 = np.resize(A, (2,3))\n",
    "A_23"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3)"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_23.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_23.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or you can up-size the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 0,  1,  4,  9],\n",
       "       [ 0,  1,  8, 27],\n",
       "       [ 0,  1,  2,  3],\n",
       "       [ 0,  1,  4,  9],\n",
       "       [ 0,  1,  8, 27]])"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_64 = np.resize(A, (6,4))\n",
    "A_64"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(6, 4)"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_64.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_64.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that while a a down-sizing will select a few of the elements of the original array, an up-sizing will fill the additional slots repeating elements of the original array. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.4.4. From N-dim to 1-dim: `.flatten()` <a name=\"flatten\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to reshape your multi-dimensional array rearranging its elements as a 1-dim array (useful to iterate over all its elements), you can use the `.flatten()` method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 0,  1,  4,  9],\n",
       "       [ 0,  1,  8, 27]])"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  0,  1,  4,  9,  0,  1,  8, 27])"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_1dim = A.flatten()\n",
    "A_1dim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_1dim.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.5. Stacking Arrays together: `.hstack()` and `.vstack()` <a name=\"stacking\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can stack together arrays, either vertically:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 0,  1,  4,  9],\n",
       "       [ 0,  1,  8, 27]])"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  0,  10,  20,  30],\n",
       "       [  0,  10,  40,  90],\n",
       "       [  0,  10,  80, 270]])"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = 10 * A\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  0,   1,   2,   3],\n",
       "       [  0,   1,   4,   9],\n",
       "       [  0,   1,   8,  27],\n",
       "       [  0,  10,  20,  30],\n",
       "       [  0,  10,  40,  90],\n",
       "       [  0,  10,  80, 270]])"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AB_vstack = np.vstack((A,B))\n",
    "AB_vstack"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or horizontally"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  0,   1,   2,   3,   0,  10,  20,  30],\n",
       "       [  0,   1,   4,   9,   0,  10,  40,  90],\n",
       "       [  0,   1,   8,  27,   0,  10,  80, 270]])"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AB_hstack = np.hstack((A,B))\n",
    "AB_hstack"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.6. Indexing with Boolean Arrays <a name=\"cond_ind\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far, to select elements or slices of an array we have provided directly the integer indexes `i` or range of indexes `i:j:k` to each dimension of the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 0,  1,  4,  9],\n",
       "       [ 0,  1,  8, 27]])"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "27"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[2,3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 4])"
      ]
     },
     "execution_count": 179,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[1,1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another typical situation that you can encounter in practice is that you want to select only portions of the array that satisfy some logical condition(s). This is achieved quite easily in NumPy using [Boolean arrays](https://docs.scipy.org/doc/numpy/user/quickstart.html#indexing-with-boolean-arrays)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.6.1. Boolean Arrays <a name=\"bool_arrays\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Boolean arrays are arrays with a boolean `.dtype` and are the result of the action of _comparison operators_ `>`, `<`, `>=`, `<=`, `==` and `!=`. For example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 0,  1,  4,  9],\n",
       "       [ 0,  1,  8, 27]])"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False,  True],\n",
       "       [False, False,  True,  True],\n",
       "       [False, False,  True,  True]])"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A > 2.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "what is returned by the operation `A > 2.5` is actually a booalean array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False,  True],\n",
       "       [False, False,  True,  True],\n",
       "       [False, False,  True,  True]])"
      ]
     },
     "execution_count": 186,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cond = (A > 2.5)\n",
    "cond"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('bool')"
      ]
     },
     "execution_count": 187,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cond.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As expected, boolean arrays can be combined using the _logical operators_ `&` (logical and), `|` (logical or) and `!` (logical not)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False,  True],\n",
       "       [False, False,  True,  True],\n",
       "       [False, False,  True, False]])"
      ]
     },
     "execution_count": 190,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cond = (A > 2.5) & (A < 10)\n",
    "cond"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('bool')"
      ]
     },
     "execution_count": 191,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cond.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.6.2. Conditional Selection <a name=\"ind_with_bool_arrays\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use a boolean array to select only portions of an array for which the corresponding boolean array has `True` value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 0,  1,  4,  9],\n",
       "       [ 0,  1,  8, 27]])"
      ]
     },
     "execution_count": 192,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False,  True],\n",
       "       [False, False,  True,  True],\n",
       "       [False, False,  True, False]])"
      ]
     },
     "execution_count": 193,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cond"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "this is done in an obvious way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4, 9, 8])"
      ]
     },
     "execution_count": 195,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_c = A[cond]\n",
    "A_c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "notice that that this conditional selection returns a flattened array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "(3, 4)\n"
     ]
    }
   ],
   "source": [
    "print(A.ndim)\n",
    "print(A.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "(4,)\n"
     ]
    }
   ],
   "source": [
    "print(A_c.ndim)\n",
    "print(A_c.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If your goal is to change some values according to a condition, you can simply use the boolean array for indexing and then assign the value to the selection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 0,  1,  4,  9],\n",
       "       [ 0,  1,  8, 27]])"
      ]
     },
     "execution_count": 198,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False,  True],\n",
       "       [False, False,  True,  True],\n",
       "       [False, False,  True, False]])"
      ]
     },
     "execution_count": 199,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cond"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2, -1],\n",
       "       [ 0,  1, -1, -1],\n",
       "       [ 0,  1, -1, 27]])"
      ]
     },
     "execution_count": 200,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[cond] = -1\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "as you can see, value `-1` is assigned to all (and only) elements of `A` for which `cond` was `True`. The shape is not affected by this assignment."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Lists Vs Arrays <a name=\"list_vs_arrays\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.1. Speed-comparison: Lists 0 - 1 Arrays <a name=\"speed_comp\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's compare the execution time of some simple function first over a list and then over a (comparable) array."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's consider a nested list made of $m=5000$ lists, each made of $n=1000$ elements which are sum of numbers $i + k$ defined as follow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 1000\n",
    "m = 5000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [[i+k for i in range(n)] for k in range(m)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To visualize the structure of the list try with smaller values like"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[0, 1, 2], [1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 6]]"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l_small = [[i+k for i in range(3)] for k in range(5)]\n",
    "l_small"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's now compute and time the creation of new list which is made out of `l`, taking the square `**2` of each of its elements "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 1.91 s\n"
     ]
    }
   ],
   "source": [
    "%time l_squared = [[i**2 for i in lis] for lis in l]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "so it took more than 1.5 seconds to compute the list of squares and assign it to `l_squared`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "let's define the corresponding array (notice that the printing of NumPy arrays is also smart enough to work with huge arrays too)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.array(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[   0,    1,    2, ...,  997,  998,  999],\n",
       "       [   1,    2,    3, ...,  998,  999, 1000],\n",
       "       [   2,    3,    4, ...,  999, 1000, 1001],\n",
       "       ...,\n",
       "       [4997, 4998, 4999, ..., 5994, 5995, 5996],\n",
       "       [4998, 4999, 5000, ..., 5995, 5996, 5997],\n",
       "       [4999, 5000, 5001, ..., 5996, 5997, 5998]])"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5000, 1000)"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and let's compute the squared array: it is just `arr**2`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 14 ms\n"
     ]
    }
   ],
   "source": [
    "%time arr_squared = arr ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and this took order of milli-seconds!!! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[       0,        1,        4, ...,   994009,   996004,   998001],\n",
       "       [       1,        4,        9, ...,   996004,   998001,  1000000],\n",
       "       [       4,        9,       16, ...,   998001,  1000000,  1002001],\n",
       "       ...,\n",
       "       [24970009, 24980004, 24990001, ..., 35928036, 35940025, 35952016],\n",
       "       [24980004, 24990001, 25000000, ..., 35940025, 35952016, 35964009],\n",
       "       [24990001, 25000000, 25010001, ..., 35952016, 35964009, 35976004]],\n",
       "      dtype=int32)"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr_squared"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.2. _Vectorization_ of code: Lists 0 - 2 Arrays <a name=\"vectorization\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The idea of vectorization is that of applying an operation or a function on an array object \"at once\", instead of looping over the array and applying it on each element. Needless, to say that there is considerable speed gain."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have already seen examples of vectorizations: array + numbers and array + array operations are all example of it beacause we delegate to the operator `+` (but also works for other operators of course) the looping over the array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 0,  1,  4,  9],\n",
       "       [ 0,  1,  8, 27]])"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  3,  4,  5],\n",
       "       [ 2,  3,  6, 11],\n",
       "       [ 2,  3, 10, 29]])"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A + 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "is equivalent to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B initialized: \n",
      "[[0 0 0 0]\n",
      " [0 0 0 0]\n",
      " [0 0 0 0]]\n",
      "B = A+2:\n",
      "[[ 2  3  4  5]\n",
      " [ 2  3  6 11]\n",
      " [ 2  3 10 29]]\n"
     ]
    }
   ],
   "source": [
    "B = np.zeros(A.shape, dtype=\"int\")\n",
    "print(\"B initialized: \")\n",
    "print(B)\n",
    "\n",
    "for i, A_row in enumerate(A):\n",
    "    #print(\"i = {}; A_row = {}\".format(i, A_row))\n",
    "    for j, A_ij in enumerate(A_row):\n",
    "        #print(\"j = {}; A_ij = {}\".format(j, A_ij))\n",
    "        B[i,j] = A_ij + 2\n",
    "\n",
    "print(\"B = A+2:\")\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "which is way more complicated, error-prone and inefficient (slower)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same when you combine arrays element-wise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 0,  1,  4,  9],\n",
       "       [ 0,  1,  8, 27]])"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  3,  4,  5],\n",
       "       [ 2,  3,  6, 11],\n",
       "       [ 2,  3, 10, 29]])"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  0,   3,   8,  15],\n",
       "       [  0,   3,  24,  99],\n",
       "       [  0,   3,  80, 783]])"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C = A*B\n",
    "C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "this is equivalent to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C initialized: \n",
      "[[0 0 0 0]\n",
      " [0 0 0 0]\n",
      " [0 0 0 0]]\n",
      "C = A*B: \n",
      "[[  0   3   8  15]\n",
      " [  0   3  24  99]\n",
      " [  0   3  80 783]]\n"
     ]
    }
   ],
   "source": [
    "C = np.zeros(A.shape, dtype=\"int\")\n",
    "print(\"C initialized: \")\n",
    "print(C)\n",
    "\n",
    "for i in range(A.shape[0]):\n",
    "    for j in range(A.shape[1]):\n",
    "        C[i,j] = A[i,j] * B[i,j]\n",
    "\n",
    "print(\"C = A*B: \")\n",
    "print(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Basically the idea is that, when you want to do an operation or applying a function to each element of one or more arrays, simply treat the array as if it is a single number. NumPy - in most of the cases - will recognize that that operation or function has to be distributed over each element of the array. NumPy will take care of the distribution of the application of the operation or function over the array, without the need for you to explicitly code the loops..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Basic Python lists have limited functionalities in this regard. Worth to mention are `map()` and `filter()` methods for lists, which to be honest I barely never used. 2-0."
   ]
  }
 ],
 "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}