notebooks/Numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "minute-grace",
   "metadata": {},
   "source": [
    "# NumPy\n",
    "\n",
    "## Useful information\n",
    "\n",
    "[PyPl](https://pypi.org/project/numpy/)   \n",
    "[Website](https://matplotlib.org/)  \n",
    "[Documentation](https://numpy.org/doc/stable/reference)  \n",
    "[Quickstart](https://numpy.org/doc/stable/user/quickstart.html)  \n",
    "[Cheatsheet](https://s3.amazonaws.com/assets.datacamp.com/blog_assets/Numpy_Python_Cheat_Sheet.pdf)\n",
    "  \n",
    "<img src=\"https://techscript24.com/wp-content/uploads/2020/10/86498201-a8bd8680-bd39-11ea-9d08-66b610a8dc01.png)\" width=200 height=200 />"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "improving-suite",
   "metadata": {},
   "source": [
    "## Table of Contents\n",
    "\n",
    "  * [Introduction](#introduction)\n",
    "  * [The Basics of NumPy Arrays](#the-basics-of-numpy-arrays)\n",
    "    + [NumPy for Matlab users](#numpy-for-matlab-users)\n",
    "    + [The ndarray data structure](#the-ndarray-data-structure)\n",
    "    + [Datatypes](#datatypes)\n",
    "    + [Shape and Dimensions](#shape-and-dimensions)\n",
    "    + [Initial placeholders](#initial-placeholders)\n",
    "  * [Array indexing](#array-indexing)\n",
    "    + [Subsetting](#subsetting)\n",
    "    + [Slicing](#slicing)\n",
    "    + [Boolean indexing](#boolean-indexing)\n",
    "  * [Array mathematics](#array-mathematics)\n",
    "    + [Arithmetic operations](#arithmetic-operations)\n",
    "      - [Addition](#addition)\n",
    "      - [Subtraction](#subtraction)\n",
    "      - [Multiplication](#multiplication)\n",
    "      - [Division](#division)\n",
    "      - [Squareroot](#squareroot)\n",
    "    + [Product operations](#product-operations)\n",
    "      - [Inner product](#inner-product)\n",
    "      - [Cross product](#cross-product)\n",
    "    + [Aggregations](#aggregations)\n",
    "    + [Boolean Logic](#boolean-logic)\n",
    "  * [Array manipulation](#array-manipulation)\n",
    "    + [Reshaping arrays](#reshaping-arrays)\n",
    "    + [Adding/removing elements](#adding-removing-elements)\n",
    "    + [Combining arrays](#combining-arrays)\n",
    "      - [Stacking](#stacking)\n",
    "      - [Tiling](#tiling)\n",
    "    + [Splitting arrays](#splitting-arrays)\n",
    "  * [Broadcasting](#broadcasting)\n",
    "    + [Rules](#rules)\n",
    "  * [Exercises](#exercises)\n",
    "  * [Challenge](#challenge)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "silver-stopping",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "\n",
    "NumPy is a library for the Python programming language, adding support for large, multi-dimensional arrays and matrices, along with a large collection of high-level mathematical functions to operate on these arrays, in a faster and more compact way than Python lists.\n",
    "\n",
    "To start using it, just import in Python, for example, like this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "healthy-picking",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "geological-digit",
   "metadata": {},
   "source": [
    "## The Basics of NumPy Arrays "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "incident-script",
   "metadata": {},
   "source": [
    "### NumPy for Matlab users\n",
    "\n",
    "MATLAB and NumPy have a lot in common. But there are many differences. NumPy was created to do numerical and scientific computing in the most natural way with Python, not to be a MATLAB clone.\n",
    "\n",
    "However, it might be useful to draw a parallel line between these two, if you are already familiar with MATLAB matrix structures and methods. So, we advise you to consult the key differences and similataries between MATLAB and NumPy [here](https://numpy.org/doc/stable/user/numpy-for-matlab-users.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "exceptional-german",
   "metadata": {},
   "source": [
    "### The ndarray data structure\n",
    "\n",
    "The core functionality of NumPy is its `ndarray`, for *n*-dimensional array, data structure. These arrays are strided views on memory. \n",
    "\n",
    "In contrast to Python's built-in list data structure, these arrays are homogeneously typed: all elements of a single array must be of the same type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "human-quantum",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "[1 2 3]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1, 2, 3])   # Create a NumPy array\n",
    "\n",
    "print(type(a))           \n",
    "print(a)  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "duplicate-delay",
   "metadata": {},
   "source": [
    "### Datatypes\n",
    "\n",
    "As mentioned above, NumPy arrays are a grid of elements of the same type. So it provides a large set of numeric datatypes that you can use to construct arrays. \n",
    "\n",
    "NumPy tries to guess a datatype when you create an array, but functions that construct arrays usually also include an optional argument to explicitly specify the datatype.\n",
    "\n",
    "Since NumPy is mostly written in C, these types map to C numeric types. You can check them all [here](https://numpy.org/devdocs/user/basics.types.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "mounted-experiment",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int32\n",
      "float64\n",
      "int64\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "x = np.array([1, 2])                   # Let numpy choose the datatype\n",
    "print(x.dtype)         \n",
    "\n",
    "x = np.array([1.0, 2.0])               # Let numpy choose the datatype\n",
    "print(x.dtype)             \n",
    "\n",
    "x = np.array([1, 2], dtype=np.int64)   # Force a particular datatype\n",
    "print(x.dtype)                        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "theoretical-calculator",
   "metadata": {},
   "source": [
    "### Shape and Dimensions\n",
    "\n",
    "The shape of an array is a tuple of integers giving the size of the array along each dimension. The number of dimensions of an array its called its rank.\n",
    "\n",
    "<img src=\"https://fgnt.github.io/python_crashkurs_doc/_images/numpy_array_t.png\" width=400/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "timely-sunrise",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4,)\n",
      "(2, 3)\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1, 2, 3, 4])   # Rank 1 array   \n",
    "\n",
    "print(a.shape)\n",
    " \n",
    "b = np.array([               # Rank 2 array  \n",
    "    [5.2, 3.0, 4.5], \n",
    "    [9.1, 0.1, 0.3]\n",
    "])    \n",
    "\n",
    "print(b.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "heavy-lebanon",
   "metadata": {},
   "source": [
    "A minimum dimension might even be specified when creating an array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "dynamic-forum",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[[[1 2 3 4]]]]]\n",
      "(1, 1, 1, 1, 4)\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1, 2, 3, 4], ndmin=5)\n",
    "\n",
    "print(a)\n",
    "print(a.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "smaller-picking",
   "metadata": {},
   "source": [
    "### Initial placeholders"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "peaceful-lightning",
   "metadata": {},
   "source": [
    "Sometimes we just want to create arrays filled with placeholder values, looking for an easier way to declare arrays of a given size with ease and without the trouble of filling them manually."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "recent-publication",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.zeros([3, 4])           # Creates an array filled with zeros\n",
    "np.ones([3, 4])            # Creates an array filled with ones\n",
    "np.arange(10, 26, 5)       # Creates an array of evenly spaced values (min, max, step)\n",
    "np.linspace(0, 2, 9)       # Creates an array of evenly spaced values (min, max, size)\n",
    "np.full((2, 2), 7)         # Creates an array filled with a constant value\n",
    "np.random.random((2, 2))   # Creates an array filled with random values\n",
    "np.empty((3, 2));          # Creates an empty array"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "light-remedy",
   "metadata": {},
   "source": [
    "## Array indexing\n",
    "\n",
    "Similar to Python lists, NumPy arrays can be sliced and indexed. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "alternate-greece",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([1, 2, 3])\n",
    "\n",
    "b = np.array([\n",
    "    [1, 2, 3],\n",
    "    [4, 5, 6]\n",
    "])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "prospective-kingdom",
   "metadata": {},
   "source": [
    "### Subsetting\n",
    "\n",
    "In a one-dimensional array, the ith value (counting from zero) can be accessed by specifying the desired index in square brackets, just as with Python lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "understanding-mileage",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "billion-massachusetts",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "premier-camera",
   "metadata": {},
   "source": [
    "In a multi-dimensional array, items can be accessed using a comma-separated tuple of indices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "environmental-idaho",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[1, 2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "transparent-communication",
   "metadata": {},
   "source": [
    "### Slicing\n",
    "\n",
    "The NumPy slicing syntax follows that of the standard Python list. To access a slice of an array x, the following syntax is used"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "irish-democracy",
   "metadata": {},
   "source": [
    "`x[start:stop:step]`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ceramic-season",
   "metadata": {},
   "source": [
    "Since arrays may be multidimensional, you must specify a slice for each dimension of the array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "revolutionary-surfing",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[0:2]  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "adverse-minneapolis",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 5])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[0:2, 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "clinical-california",
   "metadata": {},
   "source": [
    "A potentially confusing case is when the step value is negative. In this case, the defaults for `start` and `stop` are swapped. This becomes a convenient way to reverse an array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "comic-philip",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 2, 1])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "closing-father",
   "metadata": {},
   "source": [
    "One must be careful when changing the content of an array, since when we assign an array to a variable, we're assigning its reference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "developing-wiring",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "c = b[1]\n",
    "\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "light-fountain",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3]\n",
      " [10  5  6]]\n"
     ]
    }
   ],
   "source": [
    "c[0] = 10\n",
    "\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "civil-desperate",
   "metadata": {},
   "source": [
    "In this case, changing a slice of the array `c` will also affect `b` since they share the same memory reference.\n",
    "\n",
    "To avoid this situation, we can create a copy of an array using the `copy` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "nearby-defensive",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3]\n",
      " [10  5  6]]\n"
     ]
    }
   ],
   "source": [
    "c = b[1].copy()\n",
    "\n",
    "c[0] = 4\n",
    "\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "blocked-tutorial",
   "metadata": {},
   "source": [
    "### Boolean indexing\n",
    "\n",
    "Boolean array indexing lets you pick out arbitrary elements of an array. Frequently this type of indexing is used to select the elements of an array that satisfy some condition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "freelance-ecuador",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[a < 2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "expressed-policy",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2, 10,  6])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[b % 2 == 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sporting-complexity",
   "metadata": {},
   "source": [
    "## Array mathematics\n",
    "\n",
    "### Arithmetic operations\n",
    "\n",
    "Basic mathematical functions operate elementwise on arrays, and are available both as operator overloads and as functions in the NumPy module:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "brave-mystery",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 2.]\n",
      " [3. 4.]]\n",
      "[[5. 6.]\n",
      " [7. 8.]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1,2],[3,4]], dtype=np.float64)\n",
    "y = np.array([[5,6],[7,8]], dtype=np.float64)\n",
    "\n",
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "demanding-comedy",
   "metadata": {},
   "source": [
    "#### Addition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "middle-riverside",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 6.  8.]\n",
      " [10. 12.]]\n",
      "[[ 6.  8.]\n",
      " [10. 12.]]\n"
     ]
    }
   ],
   "source": [
    "print(x + y)\n",
    "print(np.add(x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "armed-redhead",
   "metadata": {},
   "source": [
    "#### Subtraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "technical-desire",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-4. -4.]\n",
      " [-4. -4.]]\n",
      "[[-4. -4.]\n",
      " [-4. -4.]]\n"
     ]
    }
   ],
   "source": [
    "print(x - y)\n",
    "print(np.subtract(x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "executive-government",
   "metadata": {},
   "source": [
    "#### Multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "dense-estate",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 5. 12.]\n",
      " [21. 32.]]\n",
      "[[ 5. 12.]\n",
      " [21. 32.]]\n"
     ]
    }
   ],
   "source": [
    "print(x * y)\n",
    "print(np.multiply(x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "experimental-offset",
   "metadata": {},
   "source": [
    "#### Division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "curious-athletics",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.2        0.33333333]\n",
      " [0.42857143 0.5       ]]\n",
      "[[0.2        0.33333333]\n",
      " [0.42857143 0.5       ]]\n"
     ]
    }
   ],
   "source": [
    "print(x / y)\n",
    "print(np.divide(x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "operational-intervention",
   "metadata": {},
   "source": [
    "#### Squareroot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "intermediate-transition",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         1.41421356]\n",
      " [1.73205081 2.        ]]\n"
     ]
    }
   ],
   "source": [
    "print(np.sqrt(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "early-officer",
   "metadata": {},
   "source": [
    "### Product operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "israeli-latin",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n",
      "[[5 6]\n",
      " [7 8]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1, 2],[3, 4]])\n",
    "y = np.array([[5, 6],[7, 8]])\n",
    "\n",
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "unable-favorite",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 9 10]\n",
      "[11 12]\n"
     ]
    }
   ],
   "source": [
    "v = np.array([9, 10])\n",
    "w = np.array([11, 12])\n",
    "\n",
    "print(v)\n",
    "print(w)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "upset-discussion",
   "metadata": {},
   "source": [
    "#### Inner product"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cognitive-edward",
   "metadata": {},
   "source": [
    "Inner product of vectors, produces a scalar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "associate-antique",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "219\n",
      "219\n"
     ]
    }
   ],
   "source": [
    "print(v.dot(w))\n",
    "print(np.dot(v, w))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "developmental-roulette",
   "metadata": {},
   "source": [
    "Product of matrix and vector, produces a vector ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "polar-lightning",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[29 67]\n",
      "[29 67]\n"
     ]
    }
   ],
   "source": [
    "print(x.dot(v))\n",
    "print(np.dot(x, v))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "intended-visitor",
   "metadata": {},
   "source": [
    "Product of two matrixes, produces a matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "light-senator",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[19 22]\n",
      " [43 50]]\n",
      "[[19 22]\n",
      " [43 50]]\n"
     ]
    }
   ],
   "source": [
    "print(x.dot(y))\n",
    "print(np.dot(x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acoustic-receiver",
   "metadata": {},
   "source": [
    "#### Cross product\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "native-screw",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-3  6 -3]\n"
     ]
    }
   ],
   "source": [
    "x = [1, 2, 3]\n",
    "y = [4, 5, 6]\n",
    "\n",
    "print(np.cross(x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "tested-saint",
   "metadata": {},
   "source": [
    "### Aggregations\n",
    "\n",
    "Often when faced with a large amount of data, a first step is to compute summary statistics for the data in question.\n",
    "\n",
    "NumPy has fast built-in aggregation functions for working on arrays to help with this process.\n",
    "\n",
    "`np.prod` - Compute product of elements  \n",
    "`np.mean` - Compute mean of elements  \n",
    "`np.std` - Compute standard deviation  \n",
    "`np.var` - Compute variance   \n",
    "`np.min` / `np.max`- Find minimum/maximum value  \n",
    "`np.argmin` / `np.argmax` - Find index of minimum/maximum value  \n",
    "`np.median` - Compute median of elements  \n",
    "`np.percentile` - Compute rank-based statistics of elements  \n",
    "`np.any` - Evaluate whether any elements are true  \n",
    "`np.all` - Evaluate whether all elements are true  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "empty-retail",
   "metadata": {},
   "source": [
    "### Boolean Logic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "hearing-discipline",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True,  True, False],\n",
       "       [False, False, False]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "x < 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "sensitive-flight",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0, 0], dtype=int32), array([0, 1], dtype=int32))"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.where(x < 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "abstract-mumbai",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0, 0], dtype=int32), array([0, 1], dtype=int32))"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.nonzero(x < 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "developing-participation",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0],\n",
       "       [0, 1]], dtype=int32)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.argwhere(x < 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "vulnerable-northern",
   "metadata": {},
   "source": [
    "## Array manipulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "computational-ridge",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [1, 2, 3]])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "i = np.array([[1, 2, 3], [1, 2, 3]])\n",
    "i"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "challenging-boundary",
   "metadata": {},
   "source": [
    "### Reshaping arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "alpine-advice",
   "metadata": {},
   "source": [
    "To obtain the transpose of a matrix array we use the `transpose` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "presidential-mouth",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1],\n",
       "       [2, 2],\n",
       "       [3, 3]])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.transpose(i)\n",
    "i.T"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "occupational-limit",
   "metadata": {},
   "source": [
    "To flatten an array we can use the `ravel` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "amber-iceland",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 1, 2, 3])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "i.ravel()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sharing-interim",
   "metadata": {},
   "source": [
    "We can also reshape the array into any shape without changing its data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "working-superintendent",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 1],\n",
       "       [2, 3]])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "i.reshape(3, -2)    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lesbian-norway",
   "metadata": {},
   "source": [
    "### Adding/removing elements"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "turned-diversity",
   "metadata": {},
   "source": [
    "To add, remove or insert elements in arrays, NumPy follows the Python syntax for lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "patent-individual",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 1, 2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "j = np.array([4, 5, 6])\n",
    "\n",
    "np.append(i, j)  # Append items to an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "sexual-worst",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 5, 1, 2, 3])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.insert(i, 3, 5)   # Insert items in an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "sunset-capability",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 3, 1, 2, 3])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.delete(i, np.array(1))   # Delete items from an array"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "statewide-creativity",
   "metadata": {},
   "source": [
    "### Combining arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "noble-driving",
   "metadata": {},
   "source": [
    "To concatenate any number of arrays together, the `concatenate` method is used. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "exotic-newspaper",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 3, 2, 1, 4, 4, 4])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([1, 2, 3])\n",
    "y = np.array([3, 2, 1])\n",
    "z = np.array([4, 4, 4])\n",
    "\n",
    "np.concatenate([x, y, z])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "worthy-grave",
   "metadata": {},
   "source": [
    "As long as the arrays have the same dimension, we can concatenate them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "informed-simpson",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid = np.array([[1, 2, 3],\n",
    "                 [4, 5, 6]])\n",
    "\n",
    "np.concatenate([grid, grid])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "transparent-straight",
   "metadata": {},
   "source": [
    "#### Stacking\n",
    "\n",
    "For working with arrays of mixed dimensions, it can be clearer to use the `vstack` (row-wise) and `hstack` (collumn-wise) functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "ecological-bruce",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [9, 8, 7],\n",
       "       [6, 5, 4]])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([1, 2, 3])\n",
    "grid = np.array([[9, 8, 7],\n",
    "                 [6, 5, 4]])\n",
    "\n",
    "# Vertically stack the arrays \n",
    "np.vstack([x, grid])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "emerging-interface",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 9,  8,  7, 99],\n",
       "       [ 6,  5,  4, 99]])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = np.array([[99],\n",
    "              [99]])\n",
    "\n",
    "# Horizontally stack the arrays \n",
    "np.hstack([grid, y])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sensitive-sussex",
   "metadata": {},
   "source": [
    "#### Tiling\n",
    "\n",
    "If we're stacking arrays with themselves, using the `tile` function provides an easier and more practical way to do it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "olive-genius",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([0, 1, 2])\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "fresh-indian",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 0, 1, 2])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.tile(a, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "lucky-uniform",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2, 0, 1, 2],\n",
       "       [0, 1, 2, 0, 1, 2]])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.tile(a, (2, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "fancy-confidence",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0, 1, 2, 0, 1, 2]],\n",
       "\n",
       "       [[0, 1, 2, 0, 1, 2]]])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.tile(a, (2, 1, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "premier-richardson",
   "metadata": {},
   "source": [
    "### Splitting arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abstract-thesis",
   "metadata": {},
   "source": [
    "The opposite of concatenation is splitting, which is implemented by the functions `split`, `hsplit`, and `vsplit`. For each of these, we can pass a list of indices giving the split points."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "iraqi-bikini",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3] [99 99] [3 2 1]\n"
     ]
    }
   ],
   "source": [
    "x = [1, 2, 3, 99, 99, 3, 2, 1]\n",
    "x1, x2, x3 = np.split(x, [3, 5])\n",
    "\n",
    "print(x1, x2, x3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "sudden-nicaragua",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]\n",
      " [12 13 14 15]]\n"
     ]
    }
   ],
   "source": [
    "grid = np.arange(16).reshape((4, 4))\n",
    "print(grid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "involved-league",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2 3]\n",
      " [4 5 6 7]]\n",
      "[[ 8  9 10 11]\n",
      " [12 13 14 15]]\n"
     ]
    }
   ],
   "source": [
    "upper, lower = np.vsplit(grid, [2])\n",
    "\n",
    "print(upper)\n",
    "print(lower)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "southern-motivation",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1]\n",
      " [ 4  5]\n",
      " [ 8  9]\n",
      " [12 13]]\n",
      "[[ 2  3]\n",
      " [ 6  7]\n",
      " [10 11]\n",
      " [14 15]]\n"
     ]
    }
   ],
   "source": [
    "left, right = np.hsplit(grid, [2])\n",
    "\n",
    "print(left)\n",
    "print(right)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "suburban-express",
   "metadata": {},
   "source": [
    "## Broadcasting\n",
    "\n",
    "Broadcasting is a powerful mechanism that allows NumPy to work with arrays of different shapes (sizes) when performing arithmetic operations. Frequently we have a smaller array and a larger array, and we want to use the smaller array multiple times to perform some operation on the larger array.\n",
    "\n",
    "For example, suppose that we want to add a constant vector to each row of a matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "interested-integration",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2  2  4]\n",
      " [ 5  5  7]\n",
      " [ 8  8 10]\n",
      " [11 11 13]]\n"
     ]
    }
   ],
   "source": [
    "# We will add the vector v to each row of the matrix x, storing the result in the matrix y\n",
    "\n",
    "x = np.array([\n",
    "    [1, 2, 3], \n",
    "    [4, 5, 6],\n",
    "    [7, 8, 9],\n",
    "    [10, 11, 12]\n",
    "])\n",
    "v = np.array([1, 0, 1])\n",
    "y = np.empty_like(x)   # Create an empty matrix with the same shape as x\n",
    "\n",
    "# Add the vector v to each row of the matrix x with an explicit loop\n",
    "for i in range(4):\n",
    "    y[i, :] = x[i, :] + v\n",
    "\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "solid-effort",
   "metadata": {},
   "source": [
    "This works, however when the matrix `x` is very large, computing an explicit loop in Python could be slow. \n",
    "Note that adding the vector `v` to each row of the matrix `x` is equivalent to forming a matrix `vv` by stacking multiple copies of `v` \n",
    "vertically, then performing elementwise summation of x and vv. We could implement this approach like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "spiritual-shadow",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 0 1]\n",
      " [1 0 1]\n",
      " [1 0 1]\n",
      " [1 0 1]]\n"
     ]
    }
   ],
   "source": [
    "# We will add the vector v to each row of the matrix x, storing the result in the matrix y\n",
    "\n",
    "vv = np.tile(v, (4, 1))   # Stack 4 copies of v on top of each other\n",
    "\n",
    "print(vv)                "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "placed-innocent",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2  2  4]\n",
      " [ 5  5  7]\n",
      " [ 8  8 10]\n",
      " [11 11 13]]\n"
     ]
    }
   ],
   "source": [
    "y = x + vv  # Add x and vv elementwise\n",
    "\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "suburban-speed",
   "metadata": {},
   "source": [
    "NumPy broadcasting allows us to perform this computation without actually creating multiple copies of `v`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "recreational-costume",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2  2  4]\n",
      " [ 5  5  7]\n",
      " [ 8  8 10]\n",
      " [11 11 13]]\n"
     ]
    }
   ],
   "source": [
    "y = x + v  # Add v to each row of x using broadcasting\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "informative-giving",
   "metadata": {},
   "source": [
    "### Rules\n",
    "\n",
    "Broadcasting two arrays together follows these rules\n",
    "\n",
    "1. If the arrays do not have the same rank, prepend the shape of the lower rank array with 1s until both shapes have the same length.\n",
    "2. The two arrays are said to be compatible in a dimension if they have the same size in the dimension, or if one of the arrays has size 1 in that dimension.\n",
    "3. The arrays can be broadcast together if they are compatible in all dimensions.\n",
    "4. After broadcasting, each array behaves as if it had shape equal to the elementwise maximum of shapes of the two input arrays.\n",
    "5. In any dimension where one array had size 1 and the other array had size greater than 1, the first array behaves as if it were copied along that dimension"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "proper-disclaimer",
   "metadata": {},
   "source": [
    "## Exercises\n",
    "\n",
    "These are some exercises we propose for you to practice your NumPy's library syntax. Almost all of them can be done using ony one line.\n",
    "\n",
    "You can find the correspondent solutions [here](Solutions.ipynb).\n",
    "\n",
    "1. Create a vector of length 10 with values evenly distributed between 5 and 50.\n",
    "2. Create an array of shape (3, 2) filled with the number 5.\n",
    "3. Convert the values of Fahrenheit degrees stored in `[0, 12, 45, 34, 99]` into Centigrade degrees. \n",
    "4. Get the indices of the elements that are bigger than 10 in `[[0, 10, 20], [20, 30, 40]]`.\n",
    "5. Change the shape of `[1, 2, 3, 4, 5, 6]` to (3, 2) and select its first two rows.\n",
    "6. Calculate the inner product of `[4, 5]` and `[7, 10]`.\n",
    "7. Calculate the normalized vector perpendicular to `[1, 5, 3]` and `[8, 4, 2]`.\n",
    "8. Subtract `[1, 0, 3]` from each row of the array `[[0, 0, 0], [1, 2, 3], [4, 5, 6]]` using broadcasting."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "loved-expert",
   "metadata": {},
   "source": [
    "## Challenge\n",
    "\n",
    "1. Suppose you have the following vectors `[1, 2, 3]` and `[8, 0, 4]`.\n",
    "2. Calculate a vector perpendicular to them.\n",
    "3. Rotate it by 45º degrees around the X axis.\n",
    "4. Scale it by 150% in the Z axis.\n",
    "5. Translate it by 10 units in the Y axis.\n",
    "6. Check what's the biggest coordinate value of the resulting vector. \n",
    "7. Create a vector with that same number (rounded up) of evenly spaced values (between 0 and 100) and sum the first half of them.\n",
    "\n",
    "**Note:** For 3D transformations, refer to the following transformation matrixes:\n",
    "\n",
    "[Translation](https://cdn.discordapp.com/attachments/583749883673182208/813361691811250216/unknown.png)  \n",
    "[Scaling](https://cdn.discordapp.com/attachments/583749883673182208/813361738400399370/unknown.png)   \n",
    "[Rotation](https://cdn.discordapp.com/attachments/583749883673182208/813361935398862898/unknown.png)  "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.1"
  },
  "toc-autonumbering": false,
  "toc-showcode": false,
  "toc-showmarkdowntxt": false,
  "toc-showtags": false
 },
 "nbformat": 4,
 "nbformat_minor": 5
}