3_numpy_old.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy Introduction\n",
    "\n",
    "- Improved by: [Dhouha Grissa](https://www.cpr.ku.dk/staff/jensen-group/?pure=en/persons/605543)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Numpy**, which stands for Numerical Python, is the core library for scientific and numerical computing in Python. It provides a high-performance multidimensional array object, and tools for working with these arrays.\n",
    "\n",
    "In this tutorial, we explain the basics of NumPy such as its environment and properties. We also discusse the various array functions, operations, types of indexing, etc.\n",
    "\n",
    "   - Official documentation: http://docs.scipy.org/doc/\n",
    "   - The NumPy User Guide: [PDF](https://numpy.org/doc/stable/numpy-user.pdf), [website](https://numpy.org/doc/stable/user)\n",
    "   - [Manual](https://numpy.org/doc/stable/)\n",
    "\n",
    "### What is NumPy?\n",
    "\n",
    "**Numpy** is an open source project, created in 2005 by Travis Oliphant. It's main object is the 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",
    "### Why Use NumPy ?\n",
    "\n",
    "**Numpy** is at the core of nearly every scientific Python application or module since it provides a fast N-d array datatype that can be manipulated in a vectorized form.\n",
    "\n",
    "   - Python does numerical computations slowly\n",
    "   - 1000 x 1000 matrix multiply\n",
    "   - fast, multidimensional arrays\n",
    "   - Python triple loop takes > 10 min **vs** Numpy takes ~0.03 seconds\n",
    "   - fast, multidimensional arrays\n",
    "   - plotting tools\n",
    "\n",
    "### Arrays and Vectorization\n",
    "\n",
    "**Arrays** are sequences of same-type data points (most-often numbers).  Numpy allows us to work with the sequence without writing a for-loop, using a technique called **vectorization**.  \n",
    "\n",
    "Besides an **array()** class, Numpy also includes a lot of math functions, which makes analysis much easier.  Let's try some out!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy Getting started\n",
    "\n",
    "### Installation of NumPy\n",
    "\n",
    "If you have Python and **PIP** already installed on a system, then installation of NumPy is very easy.\n",
    "\n",
    "Install it using this command: **pip install numpy**\n",
    "\n",
    "### Import NumPy\n",
    "\n",
    "Once NumPy is installed, import it in your applications by adding the import keyword:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NumPy as np\n",
    "\n",
    "NumPy is usually imported under the **np** alias.\n",
    "Create an alias with the **as** keyword while importing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now the NumPy package can be referred to as **np** instead of **numpy**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Checking NumPy Version\n",
    "\n",
    "The version string is stored under **__**version__ attribute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.14.3\n"
     ]
    }
   ],
   "source": [
    "print(np.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy Creating Arrays\n",
    "\n",
    "NumPy is used to work with arrays. The array object in **NumPy** is called **ndarray**.\n",
    "\n",
    "We can create a NumPy ndarray object by using the **array()** function.\n",
    "\n",
    "### 1-D Arrays\n",
    "\n",
    "An array that has a rank 1 array and called uni-dimensional or 1-D array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2]\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "#**Example**\n",
    "arr = np.array([1, 2])\n",
    "\n",
    "print(arr)\n",
    "\n",
    "print(type(arr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Create a 1-D array containing the values 1,2,3,4,5. Then print it out:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "#arr = np.array([1, 2, 3, 4, 5])\n",
    "#print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2-D Arrays\n",
    "\n",
    "An array that has 1-D arrays as its elements is called a 2-D array.\n",
    "\n",
    "These are often used to represent matrix or 2nd order tensors."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Create a 2-D array containing two arrays with the values 1,2,3 and 4,5,6:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "#arr = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "#print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3-D arrays\n",
    "\n",
    "An array that has 2-D arrays (matrices) as its elements is called 3-D array.\n",
    "\n",
    "These are often used to represent a 3rd order tensor."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Create a 3-D array with two 2-D arrays, both containing two arrays with the values 1,2,3 and 4,5,6:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]])\n",
    "#print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Check Number of Dimensions\n",
    "\n",
    "NumPy Arrays provides the **ndim** attribute that returns an integer that tells us how many dimensions the array have."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print(a.ndim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Check how many dimensions these arrays have:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = np.array([1, 2, 3, 4, 5])\n",
    "c = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "d = np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print(b.ndim)\n",
    "#print(c.ndim)\n",
    "#print(d.ndim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get the Shape of an Array\n",
    "\n",
    "The shape of an array is the number of elements in each dimension.\n",
    "\n",
    "NumPy arrays have an attribute called **shape** that returns a tuple with each index having the number of corresponding elements."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Print the shape of a 2-D array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print(arr.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "TiadUOo7Z8Y9"
   },
   "source": [
    "## Building Arrays Exercices\n",
    "\n",
    "### Building Arrays\n",
    "\n",
    "Numpy has some convenient array-building functions as well.  Some commonly-used are examples are **arange()**, **linspace()**, **zeros()**, and the random number generation functions in **random**.\n",
    "\n",
    "| function | Purpose |  Example |\n",
    "| -------- | ------- | ---------|\n",
    "| **`np.arange()`**                  | Makes an array with all the integers between two values | np.arange(2, 7) |\n",
    "| **`np.linspace()`**               | Makes a specific-length array |  np.linspace(2, 3, 10) |\n",
    "| **`np.zeros()`**                    | Makes an array of all zeros | np.zeros(5) |\n",
    "| **`np.ones()`**                     | Makes an array of all ones | np.ones(3) |\n",
    "| **`np.random.random()`** | Makes an array of random numbers | np.random.random(100) |\n",
    "| **`np.random.randn()`**     | Makes an array of normally-distributed random numbers | np.random.randn(100) |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "yhtqOOlKZ8ZC"
   },
   "source": [
    "1. Make an array containing the numbers 1 to 15."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "lzwPrnZcZ8ZE"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#np.arange(1, 16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "15ZzOLSPZ8ZI"
   },
   "source": [
    "2. Make an array containing 20 zeros."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "eNGUx1K0Z8ZI"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "       0., 0., 0.])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#np.zeros(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "TjRMDeh1Z8ZL"
   },
   "source": [
    "3. Make an array contain 20 ones!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "J3Y7BeuYZ8ZM"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
       "       1., 1., 1.])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#np.ones(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "dvzWUJS_Z8ZO"
   },
   "source": [
    "4. Generate an array of 10 random numbers from Numpy's **random** submodule, using any function you want."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.19420113, 0.72116741, 0.12062238, 0.31133038, 0.83235338,\n",
       "       0.1229514 , 0.2357226 , 0.76733401, 0.97485605, 0.36178444])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#np.random.random((10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. Create an array with 5 dimensions and verify that it has 5 dimensions, using **ndmin** as argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[[[1 2 3 4]]]]]\n",
      "number of dimensions : 5\n"
     ]
    }
   ],
   "source": [
    "#arr = np.array([1, 2, 3, 4], ndmin=5)\n",
    "#print(arr)\n",
    "#print('number of dimensions :', arr.ndim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy Array Indexing\n",
    "Array indexing is the same as accessing an array element.\n",
    "You can access an array element by referring to its index number.\n",
    "\n",
    "The indexes in NumPy arrays start with 0, meaning that the first element has index 0, and the second has index 1 etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "_W3Xjv_BZ8ZP"
   },
   "source": [
    "1. Get the first element from the following array:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([1, 2, 3, 4]) \n",
    "#print(arr[0]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Get third and fourth elements from the following array and add them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.array([1, 2, 3, 4])\n",
    "#print(arr[2] + arr[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy Sorting Arrays\n",
    "Sorting means putting elements in an ordered sequence.\n",
    "\n",
    "Ordered sequence is any sequence that has an order corresponding to elements, like numeric or alphabetical, ascending or descending.\n",
    "\n",
    "The NumPy ndarray object has a function called **sort()**, that will sort a specified array."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Sort the array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.array([3, 2, 0, 1])\n",
    "\n",
    "#print(np.sort(arr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Sort the array alphabetically:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.array(['banana', 'cherry', 'apple'])\n",
    "\n",
    "#print(np.sort(arr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Sort a 2-D array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 3 4]\n",
      " [0 1 5]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([[3, 2, 4], [5, 0, 1]])\n",
    "\n",
    "#print(np.sort(arr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "hidaeheydcnI"
   },
   "source": [
    "## Statistics Methods on Arrays\n",
    "\n",
    "Arrays have many useful math methods.  For example, to get the mean of an array of numbers:\n",
    "\n",
    "```python\n",
    "data = np.random.random(100)\n",
    "data.mean()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "MGk0swf7d8v2"
   },
   "source": [
    "**Exercise**: Calculate the statistics on the following numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "D1Y4IcKrdvUS",
    "outputId": "5298642f-ebaa-49e1-b231-58bd624e5706"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = np.arange(2, 7)\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "JM-X308-Z8ZS"
   },
   "source": [
    "1. Get the mean of the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "pbzT3Zh4Z8ZS"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.0\n"
     ]
    }
   ],
   "source": [
    "#print(data.mean())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "gbsNfpFZZ8ZW"
   },
   "source": [
    "2. What is the sum of the data?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "aXvRm3hGgpwK"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n"
     ]
    }
   ],
   "source": [
    "#print(data.sum())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "eJWqrZG1Z8ZX"
   },
   "source": [
    "3. The maximum of the data?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "qSnBsjJXgtd-"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "#print(data.max())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "KysuOALKZ8ZZ"
   },
   "source": [
    "4. The standard deviation of the data?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "LMjhsHzlZ8Za"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.4142135623730951\n"
     ]
    }
   ],
   "source": [
    "#print(data.std())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "lVjmHfdIeaT3"
   },
   "source": [
    "## Statistics Functions on Arrays\n",
    "\n",
    "Numpy also has many useful statistics **functions**.  These take an array as an input and can be found inside the **np** library.  Sometimes, the same functionality can be found both as a Numpy function  and an array method, giving you the choice of how you'd like to use it.  \n",
    "\n",
    "\n",
    "For example, the following **method**:\n",
    "\n",
    "\n",
    "```python\n",
    "data = np.random.random(100)\n",
    "data.mean()\n",
    "```\n",
    "\n",
    "can also be used as a **function**:\n",
    "\n",
    "\n",
    "```python\n",
    "data = np.random.random(100)\n",
    "np.mean(data)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "dvxWENoKfU63"
   },
   "source": [
    "**Exercise**: Calculate the statistics on the following numbers, this time using the **function** version of the previous methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "zK-gBedWfU66",
    "outputId": "5298642f-ebaa-49e1-b231-58bd624e5706"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = np.arange(2, 7)\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "wU9eR-g3fU7C"
   },
   "source": [
    "1. Get the mean of the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "1jPswldbfU7E"
   },
   "outputs": [],
   "source": [
    "#np.mean(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "AGlnNDHIfU7G"
   },
   "source": [
    "2. What is the sum of the data?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "APSVzGrufU7I"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#np.sum(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "EOLmR39hg-_d"
   },
   "source": [
    "3. What is the minimum of the data?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "fuNClX8jhF2D"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#np.min(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "yHW6AmYRfU7J"
   },
   "source": [
    "4. The standard deviation?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "nEBQ9LMifU7K"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.4142135623730951"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#np.std(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "sXa5LJR3fkms"
   },
   "source": [
    "## Arithmetic with Arrays\n",
    "\n",
    "Arrays can also be added, subtracted, multiplied, and divided.  \n",
    "\n",
    "For example, to add 10 to all values in an array:\n",
    "\n",
    "```python\n",
    "data = np.random.randn(5)\n",
    "print(data)\n",
    "print(data + 10)\n",
    "```\n",
    "\n",
    "Here is multiplying two arrays together: \n",
    "\n",
    "```python\n",
    "print(data )\n",
    "print(data * data)\n",
    "```\n",
    "\n",
    "It is also possible to use arithmetic operations such as **add(), subtract(), multiply(), and divide()**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "GNlkeFb4gdNB"
   },
   "source": [
    "**Exercises**: Modify the following arrays using the math operators  (+, -, *, /)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "YL7Gcz6riHk3",
    "outputId": "e80f1a14-3b99-4637-f5ea-a00d1bf5aa6c"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-3, -2, -1,  0,  1,  2,  3,  4])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = np.arange(-3, 5)\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "qbxwK2fbgCDu"
   },
   "source": [
    "1. Multiply the data by 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ZVnBgjboiNaE"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-300 -200 -100    0  100  200  300  400]\n"
     ]
    }
   ],
   "source": [
    "#print(data * 100)\n",
    "#print(np.multiply(data, 100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "jPgqsy1IiNt9"
   },
   "source": [
    "2. Add 40 to each value in the array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "_5Sfk2BPiQtS"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[37 38 39 40 41 42 43 44]\n"
     ]
    }
   ],
   "source": [
    "#print(data + 40)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "imSMnB0riRLv"
   },
   "source": [
    "3. Divide the numbers by 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "s2yAdtB5iU_S"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-0.03 -0.02 -0.01  0.    0.01  0.02  0.03  0.04]\n"
     ]
    }
   ],
   "source": [
    "#print(data / 100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3A41TFUSiXss"
   },
   "source": [
    "4. Subtract the data from itself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "4GGICAy-id7t"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 0 0 0 0 0 0 0]\n"
     ]
    }
   ],
   "source": [
    "#print(data - data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "uomV6dEciplB"
   },
   "source": [
    "## Extra Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "HZqr2Eq6iyoF"
   },
   "source": [
    "### Exercise: Other math functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "DFwChLniiyMe"
   },
   "source": [
    "1. Calculate the square of all the numbers from 0 to 8."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "fmDi3vaDi6-Y"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.arange(0, 9)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print(np.square(arr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "l9cIn7KYi7Q3"
   },
   "source": [
    "2. Calculate the square roots of all the numbers from 0 to 8."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "0FK2dRjIi-zW"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.         1.         1.41421356 1.73205081 2.         2.23606798\n",
      " 2.44948974 2.64575131 2.82842712]\n"
     ]
    }
   ],
   "source": [
    "#print(np.sqrt(arr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "QzT4DbVcjEG2"
   },
   "source": [
    "3. Make an array of 20 values, all of them 2's."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "pNduEem7jLVa"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2., 2.,\n",
       "       2., 2., 2.])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#data = np.linspace(2, 2, 20)\n",
    "#data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "TB70XLfvjrX-"
   },
   "source": [
    "4. Subtract the mean of the array from each element in the array (a.k.a. \"mean-centering\" the values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 87
    },
    "colab_type": "code",
    "id": "k63kx1QnjslL",
    "outputId": "b9300a20-590c-4164-8b35-4d6f651f847c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-5.5 -4.5 -3.5]\n",
      " [-2.5 -1.5 -0.5]\n",
      " [ 0.5  1.5  2.5]\n",
      " [ 3.5  4.5  5.5]]\n"
     ]
    }
   ],
   "source": [
    "#arr = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
    "#mean = arr.mean()\n",
    "#mean\n",
    "#print(arr - mean)\n",
    "#arr - mean[:, None] if mean = arr.mean(axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "hPWZnQJlZ8Z3"
   },
   "source": [
    "### Translating Algorithms into Code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "E5953XipZ8Z4"
   },
   "source": [
    "Calculate the standard deviation of an array's values, without using the numpy.std() function.  (Formula can be found here: http://www.mathsisfun.com/data/standard-deviation-formulas.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "N9URKQmUZ8Z5"
   },
   "source": [
    "1. Work out the Mean (the simple average of the numbers)\n",
    "2. Then for each number: subtract the Mean and square the result\n",
    "3. Then work out the mean of those squared differences.\n",
    "4. Take the square root of that and we are done!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Rtkw7KeVZ8Z5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6 7 8 9]\n",
      "Standard Deviation of the sample is:  2.581988897471611\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "arr = np.arange(1,10)\n",
    "print(arr)\n",
    "def std_deviation(data):\n",
    "    mean = sum(data) / len(data)\n",
    "    sd =0.0\n",
    "    for x in data:\n",
    "        sd+= pow(x-mean, 2) \n",
    "    var = sd/len(data) # variance\n",
    "    std = math.sqrt(var)\n",
    "    return std\n",
    "\n",
    "print(\"Standard Deviation of the sample is: \", std_deviation(arr))"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "Copy of Vectorization.ipynb",
   "provenance": [],
   "version": "0.3.2"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  },
  "toc-autonumbering": true
 },
 "nbformat": 4,
 "nbformat_minor": 4
}