NumPy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "U0qrlpoFcXuR"
   },
   "source": [
    "# NumPy Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "2ePkLWqFcXuS"
   },
   "source": [
    "Data manipulation in Python is nearly synonymous with NumPy array manipulation: tools like Pandas and xarray are built around the NumPy array.\n",
    "This section will present several examples of using NumPy array manipulation to access data and subarrays.\n",
    "\n",
    "We'll cover a few categories of basic array manipulations here:\n",
    "\n",
    "- *Attributes of arrays*: Determining the size, shape and data types of arrays\n",
    "- *Indexing of arrays*: Getting and setting the value of individual array elements\n",
    "- *Slicing of arrays*: Getting and setting smaller subarrays within a larger array\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "msCtXxFgcXuT"
   },
   "source": [
    "## NumPy Array Attributes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "WYKpetYGcXuU"
   },
   "source": [
    "First let's discuss some useful array attributes.\n",
    "We'll start by defining three random arrays, a one-dimensional, two-dimensional, and three-dimensional array.\n",
    "We'll use NumPy's random number generator, which we will *seed* with a set value in order to ensure that the same random arrays are generated each time this code is run:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "E40ceryJcXuV"
   },
   "outputs": [],
   "source": [
    "import numpy as np   # This is the convention for importing the NumPy package\n",
    "np.random.seed(0)  # seed for reproducibility\n",
    "\n",
    "x1 = np.random.randint(10, size=6)  # One-dimensional array\n",
    "x2 = np.random.randint(10, size=(3, 4))  # Two-dimensional array\n",
    "x3 = np.random.randint(10, size=(3, 4, 5))  # Three-dimensional array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 263
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 522,
     "status": "ok",
     "timestamp": 1580410337053,
     "user": {
      "displayName": "Stephen Nesbitt",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mCVId9VDUROBQ6S6mfm7quWxlY3BklQdeZtzaqJ_8U=s64",
      "userId": "06234418338196972854"
     },
     "user_tz": 360
    },
    "id": "gURf0pwzCX3J",
    "outputId": "e1a17b2a-ae3c-405a-92a2-78068d0921bd"
   },
   "outputs": [],
   "source": [
    "x3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ojgA2YsMcXuZ"
   },
   "source": [
    "Each array has attributes ``ndim`` (the number of dimensions), ``shape`` (the size of each dimension), and ``size`` (the total size of the array):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 69
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 260,
     "status": "ok",
     "timestamp": 1548185305125,
     "user": {
      "displayName": "Stephen Nesbitt",
      "photoUrl": "https://lh4.googleusercontent.com/-k1GSpJp_v9k/AAAAAAAAAAI/AAAAAAAAoak/zCbJWwkhKvM/s64/photo.jpg",
      "userId": "06234418338196972854"
     },
     "user_tz": 360
    },
    "id": "MNC8sHhScXua",
    "outputId": "a068fe7f-e4f5-43d8-eba3-f8acecd0837a"
   },
   "outputs": [],
   "source": [
    "print(\"x3 ndim: \", x3.ndim)\n",
    "print(\"x3 shape:\", x3.shape)\n",
    "print(\"x3 size: \", x3.size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UsbcMayPcXuf"
   },
   "source": [
    "Another useful attribute is the ``dtype``, the data type of the array (which was discussed  in [Understanding Data Types in Python](02.01-Understanding-Data-Types.ipynb)):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 358,
     "status": "ok",
     "timestamp": 1548185443209,
     "user": {
      "displayName": "Stephen Nesbitt",
      "photoUrl": "https://lh4.googleusercontent.com/-k1GSpJp_v9k/AAAAAAAAAAI/AAAAAAAAoak/zCbJWwkhKvM/s64/photo.jpg",
      "userId": "06234418338196972854"
     },
     "user_tz": 360
    },
    "id": "aCxxSfNgcXug",
    "outputId": "52422636-1bfe-4fdd-8f23-2539eeed0ac2"
   },
   "outputs": [],
   "source": [
    "print(\"dtype:\", x3.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "CHXpJ8JncXus"
   },
   "source": [
    "## Array Indexing: Accessing Single Elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "GRkzL-VacXut"
   },
   "source": [
    "If you are familiar with Python's standard list indexing, indexing in NumPy will feel quite familiar.\n",
    "In a one-dimensional array, the $i^{th}$ 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": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 214,
     "status": "ok",
     "timestamp": 1548185519450,
     "user": {
      "displayName": "Stephen Nesbitt",
      "photoUrl": "https://lh4.googleusercontent.com/-k1GSpJp_v9k/AAAAAAAAAAI/AAAAAAAAoak/zCbJWwkhKvM/s64/photo.jpg",
      "userId": "06234418338196972854"
     },
     "user_tz": 360
    },
    "id": "0LJV3RevcXuu",
    "outputId": "10b8f6ba-1c0e-4c94-fe97-32bf4b942949"
   },
   "outputs": [],
   "source": [
    "x1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 231,
     "status": "ok",
     "timestamp": 1548185564035,
     "user": {
      "displayName": "Stephen Nesbitt",
      "photoUrl": "https://lh4.googleusercontent.com/-k1GSpJp_v9k/AAAAAAAAAAI/AAAAAAAAoak/zCbJWwkhKvM/s64/photo.jpg",
      "userId": "06234418338196972854"
     },
     "user_tz": 360
    },
    "id": "gsAW4i0JcXuw",
    "outputId": "714fd321-08d8-4c0d-87b2-9ff1b754c10c"
   },
   "outputs": [],
   "source": [
    "x1[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 216,
     "status": "ok",
     "timestamp": 1548185581213,
     "user": {
      "displayName": "Stephen Nesbitt",
      "photoUrl": "https://lh4.googleusercontent.com/-k1GSpJp_v9k/AAAAAAAAAAI/AAAAAAAAoak/zCbJWwkhKvM/s64/photo.jpg",
      "userId": "06234418338196972854"
     },
     "user_tz": 360
    },
    "id": "5SitUB1LcXu0",
    "outputId": "789b39d7-f789-4fd9-c05e-42db8357f343"
   },
   "outputs": [],
   "source": [
    "x1[4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Y1NMTeRzcXu4"
   },
   "source": [
    "To index from the end of the array, you can use negative indices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 201,
     "status": "ok",
     "timestamp": 1548185596374,
     "user": {
      "displayName": "Stephen Nesbitt",
      "photoUrl": "https://lh4.googleusercontent.com/-k1GSpJp_v9k/AAAAAAAAAAI/AAAAAAAAoak/zCbJWwkhKvM/s64/photo.jpg",
      "userId": "06234418338196972854"
     },
     "user_tz": 360
    },
    "id": "HBw8q2QScXu5",
    "outputId": "6c98b2d9-0d89-48ce-85e1-70a0c4450955"
   },
   "outputs": [],
   "source": [
    "x1[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 361,
     "status": "ok",
     "timestamp": 1548185602589,
     "user": {
      "displayName": "Stephen Nesbitt",
      "photoUrl": "https://lh4.googleusercontent.com/-k1GSpJp_v9k/AAAAAAAAAAI/AAAAAAAAoak/zCbJWwkhKvM/s64/photo.jpg",
      "userId": "06234418338196972854"
     },
     "user_tz": 360
    },
    "id": "Btnsq_PacXu8",
    "outputId": "7a859351-54eb-4fb9-f06d-d7cafb290d88"
   },
   "outputs": [],
   "source": [
    "x1[-2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "-L2p7F1RcXvA"
   },
   "source": [
    "In a multi-dimensional array, items can be accessed using a comma-separated tuple of indices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 69
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 179,
     "status": "ok",
     "timestamp": 1548185619721,
     "user": {
      "displayName": "Stephen Nesbitt",
      "photoUrl": "https://lh4.googleusercontent.com/-k1GSpJp_v9k/AAAAAAAAAAI/AAAAAAAAoak/zCbJWwkhKvM/s64/photo.jpg",
      "userId": "06234418338196972854"
     },
     "user_tz": 360
    },
    "id": "Xk_E6xYLcXvC",
    "outputId": "e4808eee-9aa8-4b11-af3c-18a273625e00"
   },
   "outputs": [],
   "source": [
    "x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 200,
     "status": "ok",
     "timestamp": 1548185643189,
     "user": {
      "displayName": "Stephen Nesbitt",
      "photoUrl": "https://lh4.googleusercontent.com/-k1GSpJp_v9k/AAAAAAAAAAI/AAAAAAAAoak/zCbJWwkhKvM/s64/photo.jpg",
      "userId": "06234418338196972854"
     },
     "user_tz": 360
    },
    "id": "1ukcxvsbcXvH",
    "outputId": "fabadc81-778d-4f57-ae21-b433408f1d3c"
   },
   "outputs": [],
   "source": [
    "x2[0, 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 213,
     "status": "ok",
     "timestamp": 1548185663706,
     "user": {
      "displayName": "Stephen Nesbitt",
      "photoUrl": "https://lh4.googleusercontent.com/-k1GSpJp_v9k/AAAAAAAAAAI/AAAAAAAAoak/zCbJWwkhKvM/s64/photo.jpg",
      "userId": "06234418338196972854"
     },
     "user_tz": 360
    },
    "id": "xBY7FMCWcXvL",
    "outputId": "4fd5cc16-a873-42e5-ce4a-32c4fc9c920c"
   },
   "outputs": [],
   "source": [
    "x2[2, 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 231,
     "status": "ok",
     "timestamp": 1548185705414,
     "user": {
      "displayName": "Stephen Nesbitt",
      "photoUrl": "https://lh4.googleusercontent.com/-k1GSpJp_v9k/AAAAAAAAAAI/AAAAAAAAoak/zCbJWwkhKvM/s64/photo.jpg",
      "userId": "06234418338196972854"
     },
     "user_tz": 360
    },
    "id": "W0Ui5ZWYcXvP",
    "outputId": "4d5a066e-6799-4b8c-c388-85f179256b15"
   },
   "outputs": [],
   "source": [
    "x2[2, -1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "B0EtzZDWcXvT"
   },
   "source": [
    "Values can also be modified using any of the above index notation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 69
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 215,
     "status": "ok",
     "timestamp": 1548185735445,
     "user": {
      "displayName": "Stephen Nesbitt",
      "photoUrl": "https://lh4.googleusercontent.com/-k1GSpJp_v9k/AAAAAAAAAAI/AAAAAAAAoak/zCbJWwkhKvM/s64/photo.jpg",
      "userId": "06234418338196972854"
     },
     "user_tz": 360
    },
    "id": "K4Fu3MJgcXvT",
    "outputId": "971764c6-1389-41ca-b797-3c834712b570"
   },
   "outputs": [],
   "source": [
    "x2[0, 0] = 12\n",
    "x2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "X9NqbwwpcXvY"
   },
   "source": [
    "Keep in mind that, unlike Python lists, NumPy arrays have a fixed type.\n",
    "This means, for example, that if you attempt to insert a floating-point value to an integer array, the value will be silently truncated. Don't be caught unaware by this behavior!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 594,
     "status": "ok",
     "timestamp": 1580410823611,
     "user": {
      "displayName": "Stephen Nesbitt",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mCVId9VDUROBQ6S6mfm7quWxlY3BklQdeZtzaqJ_8U=s64",
      "userId": "06234418338196972854"
     },
     "user_tz": 360
    },
    "id": "xPkfu2mocXvY",
    "outputId": "bc600c6e-61df-4423-a217-a477c60de189"
   },
   "outputs": [],
   "source": [
    "x1[0] = 3.74159  # this will be truncated!\n",
    "x1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "b_1Q-w-qcXvc"
   },
   "source": [
    "## Array Slicing: Accessing Subarrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "hhP5drVQcXvd"
   },
   "source": [
    "Just as we can use square brackets to access individual array elements, we can also use them to access subarrays with the *slice* notation, marked by the colon (``:``) character.\n",
    "The NumPy slicing syntax follows that of the standard Python list; to access a slice of an array ``x``, use this:\n",
    "``` python\n",
    "x[start:stop:step]\n",
    "```\n",
    "If any of these are unspecified, they default to the values ``start=0``, ``stop=``*``size of dimension``*, ``step=1``.\n",
    "We'll take a look at accessing sub-arrays in one dimension and in multiple dimensions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "jRmABsP9cXve"
   },
   "source": [
    "### One-dimensional subarrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 955,
     "status": "ok",
     "timestamp": 1580410948843,
     "user": {
      "displayName": "Stephen Nesbitt",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mCVId9VDUROBQ6S6mfm7quWxlY3BklQdeZtzaqJ_8U=s64",
      "userId": "06234418338196972854"
     },
     "user_tz": 360
    },
    "id": "rXRgggzicXvf",
    "outputId": "d73f6143-297f-4635-ed2d-08cde2eba241"
   },
   "outputs": [],
   "source": [
    "x = np.arange(10)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 448,
     "status": "ok",
     "timestamp": 1580410994939,
     "user": {
      "displayName": "Stephen Nesbitt",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mCVId9VDUROBQ6S6mfm7quWxlY3BklQdeZtzaqJ_8U=s64",
      "userId": "06234418338196972854"
     },
     "user_tz": 360
    },
    "id": "2lAEOLDQcXvi",
    "outputId": "eae66656-777d-4236-85e9-a32dd278e31e"
   },
   "outputs": [],
   "source": [
    "x[:5]  # first five elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 392,
     "status": "ok",
     "timestamp": 1580411000884,
     "user": {
      "displayName": "Stephen Nesbitt",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mCVId9VDUROBQ6S6mfm7quWxlY3BklQdeZtzaqJ_8U=s64",
      "userId": "06234418338196972854"
     },
     "user_tz": 360
    },
    "id": "vDw6SBAAcXvl",
    "outputId": "d4ef06db-767c-4c65-8e87-13903ac3ce2c"
   },
   "outputs": [],
   "source": [
    "x[5:]  # elements after index 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 410,
     "status": "ok",
     "timestamp": 1580411033549,
     "user": {
      "displayName": "Stephen Nesbitt",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mCVId9VDUROBQ6S6mfm7quWxlY3BklQdeZtzaqJ_8U=s64",
      "userId": "06234418338196972854"
     },
     "user_tz": 360
    },
    "id": "862HXi5CcXvp",
    "outputId": "5d6ca67c-99a6-4316-c638-b997bfe7c137"
   },
   "outputs": [],
   "source": [
    "x[4:7]  # middle sub-array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 553,
     "status": "ok",
     "timestamp": 1580411047658,
     "user": {
      "displayName": "Stephen Nesbitt",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mCVId9VDUROBQ6S6mfm7quWxlY3BklQdeZtzaqJ_8U=s64",
      "userId": "06234418338196972854"
     },
     "user_tz": 360
    },
    "id": "HPRZbdrbcXvs",
    "outputId": "d9fdc410-1341-4b2e-c6bd-dc785d35428a"
   },
   "outputs": [],
   "source": [
    "x[::2]  # every other element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 433,
     "status": "ok",
     "timestamp": 1580411065864,
     "user": {
      "displayName": "Stephen Nesbitt",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mCVId9VDUROBQ6S6mfm7quWxlY3BklQdeZtzaqJ_8U=s64",
      "userId": "06234418338196972854"
     },
     "user_tz": 360
    },
    "id": "7b9GuiOwcXvv",
    "outputId": "2f8abdaf-d95b-43c5-e1cc-095444204119"
   },
   "outputs": [],
   "source": [
    "x[1::2]  # every other element, starting at index 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "pDmGdJLAcXvz"
   },
   "source": [
    "A potentially confusing case is when the ``step`` value is negative.\n",
    "In this case, the defaults for ``start`` and ``stop`` are swapped.\n",
    "This becomes a convenient way to reverse an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 315,
     "status": "ok",
     "timestamp": 1548186046880,
     "user": {
      "displayName": "Stephen Nesbitt",
      "photoUrl": "https://lh4.googleusercontent.com/-k1GSpJp_v9k/AAAAAAAAAAI/AAAAAAAAoak/zCbJWwkhKvM/s64/photo.jpg",
      "userId": "06234418338196972854"
     },
     "user_tz": 360
    },
    "id": "NxU4XXSVcXv0",
    "outputId": "10a6f0ca-2649-4ba6-e003-5b3ad7ed92a1"
   },
   "outputs": [],
   "source": [
    "x[::-1]  # all elements, reversed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 338,
     "status": "ok",
     "timestamp": 1548186062157,
     "user": {
      "displayName": "Stephen Nesbitt",
      "photoUrl": "https://lh4.googleusercontent.com/-k1GSpJp_v9k/AAAAAAAAAAI/AAAAAAAAoak/zCbJWwkhKvM/s64/photo.jpg",
      "userId": "06234418338196972854"
     },
     "user_tz": 360
    },
    "id": "3k0888XacXv5",
    "outputId": "c9723c3b-23b0-4bee-de34-cce43bb988ba"
   },
   "outputs": [],
   "source": [
    "x[5::-2]  # reversed every other from index 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Mwb_vkMMcXv7"
   },
   "source": [
    "### Multi-dimensional subarrays\n",
    "\n",
    "Multi-dimensional slices work in the same way, with multiple slices separated by commas.\n",
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 70
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 566,
     "status": "ok",
     "timestamp": 1580411115649,
     "user": {
      "displayName": "Stephen Nesbitt",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mCVId9VDUROBQ6S6mfm7quWxlY3BklQdeZtzaqJ_8U=s64",
      "userId": "06234418338196972854"
     },
     "user_tz": 360
    },
    "id": "dGfcsHPIcXv8",
    "outputId": "7453b945-f942-4ff3-88a9-3848faaf0bb7"
   },
   "outputs": [],
   "source": [
    "x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 52
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 440,
     "status": "ok",
     "timestamp": 1580411145847,
     "user": {
      "displayName": "Stephen Nesbitt",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mCVId9VDUROBQ6S6mfm7quWxlY3BklQdeZtzaqJ_8U=s64",
      "userId": "06234418338196972854"
     },
     "user_tz": 360
    },
    "id": "Zeay9l8zcXwA",
    "outputId": "9c2df94a-5378-4282-c54a-5327fffed6ec"
   },
   "outputs": [],
   "source": [
    "x2[:2, :3]  # two rows, three columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 69
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 211,
     "status": "ok",
     "timestamp": 1548186132481,
     "user": {
      "displayName": "Stephen Nesbitt",
      "photoUrl": "https://lh4.googleusercontent.com/-k1GSpJp_v9k/AAAAAAAAAAI/AAAAAAAAoak/zCbJWwkhKvM/s64/photo.jpg",
      "userId": "06234418338196972854"
     },
     "user_tz": 360
    },
    "id": "jR0rMUI2cXwC",
    "outputId": "b5b0d0a5-e87b-45f8-c400-05f3a0a5020b"
   },
   "outputs": [],
   "source": [
    "x2[:3, ::2]  # all rows, every other column"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "8UqBj-LqcXwG"
   },
   "source": [
    "Finally, subarray dimensions can even be reversed together:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 69
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 208,
     "status": "ok",
     "timestamp": 1548186146008,
     "user": {
      "displayName": "Stephen Nesbitt",
      "photoUrl": "https://lh4.googleusercontent.com/-k1GSpJp_v9k/AAAAAAAAAAI/AAAAAAAAoak/zCbJWwkhKvM/s64/photo.jpg",
      "userId": "06234418338196972854"
     },
     "user_tz": 360
    },
    "id": "hy7v74C1cXwI",
    "outputId": "1a74ce92-0133-4fbc-f4e3-ccd51fbde7f5"
   },
   "outputs": [],
   "source": [
    "x2[::-1, ::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "GqtxVmkRcXwM"
   },
   "source": [
    "#### Accessing array rows and columns\n",
    "\n",
    "One commonly needed routine is accessing of single rows or columns of an array.\n",
    "This can be done by combining indexing and slicing, using an empty slice marked by a single colon (``:``):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1358,
     "status": "ok",
     "timestamp": 1580411268778,
     "user": {
      "displayName": "Stephen Nesbitt",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mCVId9VDUROBQ6S6mfm7quWxlY3BklQdeZtzaqJ_8U=s64",
      "userId": "06234418338196972854"
     },
     "user_tz": 360
    },
    "id": "Xvxg0YBacXwN",
    "outputId": "82882bb1-bd5d-4a7d-e660-2ec115c12caa"
   },
   "outputs": [],
   "source": [
    "print(x2[:, 0])  # first column of x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 410,
     "status": "ok",
     "timestamp": 1580411284460,
     "user": {
      "displayName": "Stephen Nesbitt",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AAuE7mCVId9VDUROBQ6S6mfm7quWxlY3BklQdeZtzaqJ_8U=s64",
      "userId": "06234418338196972854"
     },
     "user_tz": 360
    },
    "id": "YDtnk_lAcXwU",
    "outputId": "0291ba67-3384-453c-c3f5-081c38cc7ec9"
   },
   "outputs": [],
   "source": [
    "print(x2[1, :])  # first row of x2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "E4ZtS-IvcXwX"
   },
   "source": [
    "In the case of row access, the empty slice can be omitted for a more compact syntax:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 192,
     "status": "ok",
     "timestamp": 1548186266440,
     "user": {
      "displayName": "Stephen Nesbitt",
      "photoUrl": "https://lh4.googleusercontent.com/-k1GSpJp_v9k/AAAAAAAAAAI/AAAAAAAAoak/zCbJWwkhKvM/s64/photo.jpg",
      "userId": "06234418338196972854"
     },
     "user_tz": 360
    },
    "id": "RGhK43x6cXwY",
    "outputId": "816f2fd2-23c9-4aff-922d-7d4a76dbc3c4"
   },
   "outputs": [],
   "source": [
    "print(x2[0])  # equivalent to x2[0, :]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "sXaIBd_fVPYe"
   },
   "source": [
    "## The Slowness of Loops\n",
    "\n",
    "Python's default implementation (known as CPython) does some operations very slowly.\n",
    "This is in part due to the dynamic, interpreted nature of the language: the fact that types are flexible, so that sequences of operations cannot be compiled down to efficient machine code as in languages like C and Fortran.\n",
    "Recently there have been various attempts to address this weakness: well-known examples are the [PyPy](http://pypy.org/) project, a just-in-time compiled implementation of Python; the [Cython](http://cython.org) project, which converts Python code to compilable C code; and the [Numba](http://numba.pydata.org/) project, which converts snippets of Python code to fast LLVM bytecode.\n",
    "Each of these has its strengths and weaknesses, but it is safe to say that none of the three approaches has yet surpassed the reach and popularity of the standard CPython engine.\n",
    "\n",
    "The relative sluggishness of Python generally manifests itself in situations where many small operations are being repeated – for instance looping over arrays to operate on each element.\n",
    "For example, imagine we have an array of values and we'd like to compute the reciprocal of each.\n",
    "A straightforward approach might look like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "OBykiSjVVPYf",
    "outputId": "37c753c4-d87f-449c-cb60-f6fd77686c87"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "np.random.seed(0)\n",
    "\n",
    "def compute_reciprocals(values):\n",
    "    output = np.empty(len(values))\n",
    "    for i in range(len(values)):\n",
    "        output[i] = 1.0 / values[i]\n",
    "    return output\n",
    "        \n",
    "values = np.random.randint(1, 10, size=5)\n",
    "compute_reciprocals(values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "iUVjbY59VPYh"
   },
   "source": [
    "This implementation probably feels fairly natural to someone from, say, a C or Java background.\n",
    "But if we measure the execution time of this code for a large input, we see that this operation is very slow, perhaps surprisingly so!\n",
    "We'll benchmark this with IPython's ``%timeit`` magic (discussed in [Profiling and Timing Code](01.07-Timing-and-Profiling.ipynb)):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Gy9OfRrvVPYi",
    "outputId": "f88a0044-d7f1-403d-d82e-0aea2e38b2a7"
   },
   "outputs": [],
   "source": [
    "big_array = np.random.randint(1, 100, size=1000000)\n",
    "%timeit compute_reciprocals(big_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dplclPFNVPYn"
   },
   "source": [
    "It takes several seconds to compute these million operations and to store the result!\n",
    "When even cell phones have processing speeds measured in Giga-FLOPS (i.e., billions of numerical operations per second), this seems almost absurdly slow.\n",
    "It turns out that the bottleneck here is not the operations themselves, but the type-checking and function dispatches that CPython must do at each cycle of the loop.\n",
    "Each time the reciprocal is computed, Python first examines the object's type and does a dynamic lookup of the correct function to use for that type.\n",
    "If we were working in compiled code instead, this type specification would be known before the code executes and the result could be computed much more efficiently."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jYXOT8-PVPYn"
   },
   "source": [
    "## Introducing UFuncs\n",
    "\n",
    "For many types of operations, NumPy provides a convenient interface into just this kind of statically typed, compiled routine. This is known as a *vectorized* operation.\n",
    "This can be accomplished by simply performing an operation on the array, which will then be applied to each element.\n",
    "This vectorized approach is designed to push the loop into the compiled layer that underlies NumPy, leading to much faster execution.\n",
    "\n",
    "Compare the results of the following two:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "lyKLJSJfVPYn",
    "outputId": "7be64558-32af-4174-eded-8aacd7c434c4"
   },
   "outputs": [],
   "source": [
    "print(compute_reciprocals(values))\n",
    "print(1.0 / values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OiLZCQp8VPYq"
   },
   "source": [
    "Looking at the execution time for our big array, we see that it completes orders of magnitude faster than the Python loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "K8CQ2D6AVPYq",
    "outputId": "787a76fd-6e96-4358-96ed-8d62a42a4a9f"
   },
   "outputs": [],
   "source": [
    "%timeit (1.0 / big_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "H0PARbuhVPYs"
   },
   "source": [
    "Vectorized operations in NumPy are implemented via *ufuncs*, whose main purpose is to quickly execute repeated operations on values in NumPy arrays.\n",
    "Ufuncs are extremely flexible – before we saw an operation between a scalar and an array, but we can also operate between two arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "BOrM56wjVPYt",
    "outputId": "844983ea-283c-4db8-c285-20029eacd918"
   },
   "outputs": [],
   "source": [
    "np.arange(5) / np.arange(1, 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nBZ529ebVPYv"
   },
   "source": [
    "And ufunc operations are not limited to one-dimensional arrays–they can also act on multi-dimensional arrays as well:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "w58VCUcWVPYw",
    "outputId": "aeca737e-4cfe-46b9-fa2d-b3445c532cd9"
   },
   "outputs": [],
   "source": [
    "x = np.arange(9).reshape((3, 3))\n",
    "2 ** x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7buoRZRoVPYy"
   },
   "source": [
    "Computations using vectorization through ufuncs are nearly always more efficient than their counterpart implemented using Python loops, especially as the arrays grow in size.\n",
    "Any time you see such a loop in a Python script, you should consider whether it can be replaced with a vectorized expression."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ynsPRXN7VPYy"
   },
   "source": [
    "## Exploring NumPy's UFuncs\n",
    "\n",
    "Ufuncs exist in two flavors: *unary ufuncs*, which operate on a single input, and *binary ufuncs*, which operate on two inputs.\n",
    "We'll see examples of both these types of functions here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HE3xHbCtVPYz"
   },
   "source": [
    "### Array arithmetic\n",
    "\n",
    "NumPy's ufuncs feel very natural to use because they make use of Python's native arithmetic operators.\n",
    "The standard addition, subtraction, multiplication, and division can all be used:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "o0XdEVfQVPY0",
    "outputId": "dac4a6d2-3392-4422-d3f5-82c772fcba15"
   },
   "outputs": [],
   "source": [
    "x = np.arange(4)\n",
    "print(\"x     =\", x)\n",
    "print(\"x + 5 =\", x + 5)\n",
    "print(\"x - 5 =\", x - 5)\n",
    "print(\"x * 2 =\", x * 2)\n",
    "print(\"x / 2 =\", x / 2)\n",
    "print(\"x // 2 =\", x // 2)  # floor division"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-HB7V17EVPY3"
   },
   "source": [
    "There is also a unary ufunc for negation, and a ``**`` operator for exponentiation, and a ``%`` operator for modulus:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "w7HNrCepVPY4",
    "outputId": "8ce8d60f-6810-471c-da87-714a764a6a11"
   },
   "outputs": [],
   "source": [
    "print(\"-x     = \", -x)\n",
    "print(\"x ** 2 = \", x ** 2)\n",
    "print(\"x % 2  = \", x % 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ddCZS_QdVPY6"
   },
   "source": [
    "In addition, these can be strung together however you wish, and the standard order of operations is respected:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "rNhQ7tuTVPY6",
    "outputId": "63f2accd-087c-47d5-cfcd-882142ce2be2"
   },
   "outputs": [],
   "source": [
    "-(0.5*x + 1) ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "G6tRdDi-VPY_"
   },
   "source": [
    "Each of these arithmetic operations are simply convenient wrappers around specific functions built into NumPy; for example, the ``+`` operator is a wrapper for the ``add`` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "AnQkBI2JVPZA",
    "outputId": "4b06dfb7-ae97-4baf-d785-c568b4933846"
   },
   "outputs": [],
   "source": [
    "np.add(x, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "MGfrIdShVPZC"
   },
   "source": [
    "The following table lists the arithmetic operators implemented in NumPy:\n",
    "\n",
    "| Operator\t    | Equivalent ufunc    | Description                           |\n",
    "|---------------|---------------------|---------------------------------------|\n",
    "|``+``          |``np.add``           |Addition (e.g., ``1 + 1 = 2``)         |\n",
    "|``-``          |``np.subtract``      |Subtraction (e.g., ``3 - 2 = 1``)      |\n",
    "|``-``          |``np.negative``      |Unary negation (e.g., ``-2``)          |\n",
    "|``*``          |``np.multiply``      |Multiplication (e.g., ``2 * 3 = 6``)   |\n",
    "|``/``          |``np.divide``        |Division (e.g., ``3 / 2 = 1.5``)       |\n",
    "|``//``         |``np.floor_divide``  |Floor division (e.g., ``3 // 2 = 1``)  |\n",
    "|``**``         |``np.power``         |Exponentiation (e.g., ``2 ** 3 = 8``)  |\n",
    "|``%``          |``np.mod``           |Modulus/remainder (e.g., ``9 % 4 = 1``)|\n",
    "\n",
    "Additionally there are Boolean/bitwise operators; we will explore these in [Comparisons, Masks, and Boolean Logic](02.06-Boolean-Arrays-and-Masks.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Pmif4iCJVPZC"
   },
   "source": [
    "### Absolute value\n",
    "\n",
    "Just as NumPy understands Python's built-in arithmetic operators, it also understands Python's built-in absolute value function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "EW30bHTnVPZC",
    "outputId": "8a109542-6520-4b44-9484-edeea4f6454b"
   },
   "outputs": [],
   "source": [
    "x = np.array([-2, -1, 0, 1, 2])\n",
    "abs(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "40miBWChVPZF"
   },
   "source": [
    "The corresponding NumPy ufunc is ``np.absolute``, which is also available under the alias ``np.abs``:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "FLwNkMfMVPZG",
    "outputId": "be2d73f2-4c90-4a81-974d-e178e38f3219"
   },
   "outputs": [],
   "source": [
    "np.absolute(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "btKD3esGVPZI",
    "outputId": "d5d702bc-1658-458a-f31a-55eff3f538f5"
   },
   "outputs": [],
   "source": [
    "np.abs(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FASwEQzhVPZK"
   },
   "source": [
    "This ufunc can also handle complex data, in which the absolute value returns the magnitude:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "htfiVgaUVPZK",
    "outputId": "395495d2-facf-4eae-8875-c76b31a5c3dc"
   },
   "outputs": [],
   "source": [
    "x = np.array([3 - 4j, 4 - 3j, 2 + 0j, 0 + 1j])\n",
    "np.abs(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Pu5Tu2f7VPZN"
   },
   "source": [
    "### Trigonometric functions\n",
    "\n",
    "NumPy provides a large number of useful ufuncs, and some of the most useful for the data scientist are the trigonometric functions.\n",
    "We'll start by defining an array of angles:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "YW2_1g6uVPZN"
   },
   "outputs": [],
   "source": [
    "theta = np.linspace(0, np.pi, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KmKgw7WxVPZP"
   },
   "source": [
    "Now we can compute some trigonometric functions on these values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "RY7COJrqVPZP",
    "outputId": "78ecfeec-d6a3-4457-fd24-7c79995d740e"
   },
   "outputs": [],
   "source": [
    "print(\"theta      = \", theta)\n",
    "print(\"sin(theta) = \", np.sin(theta))\n",
    "print(\"cos(theta) = \", np.cos(theta))\n",
    "print(\"tan(theta) = \", np.tan(theta))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Jp4EEHZEVPZR"
   },
   "source": [
    "The values are computed to within machine precision, which is why values that should be zero do not always hit exactly zero.\n",
    "Inverse trigonometric functions are also available:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "GkrrefH9VPZR",
    "outputId": "baccf6a9-5407-49a1-d600-2371f577eaa0"
   },
   "outputs": [],
   "source": [
    "x = [-1, 0, 1]\n",
    "print(\"x         = \", x)\n",
    "print(\"arcsin(x) = \", np.arcsin(x))\n",
    "print(\"arccos(x) = \", np.arccos(x))\n",
    "print(\"arctan(x) = \", np.arctan(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "t7ihcb4YVPZT"
   },
   "source": [
    "### Exponents and logarithms\n",
    "\n",
    "Another common type of operation available in a NumPy ufunc are the exponentials:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "51N-d41MVPZT",
    "outputId": "5bb951fa-c86c-44e3-f321-0e6f83b6ff68"
   },
   "outputs": [],
   "source": [
    "x = [1, 2, 3]\n",
    "print(\"x     =\", x)\n",
    "print(\"e^x   =\", np.exp(x))\n",
    "print(\"2^x   =\", np.exp2(x))\n",
    "print(\"3^x   =\", np.power(3, x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "V8oylUleVPZV"
   },
   "source": [
    "The inverse of the exponentials, the logarithms, are also available.\n",
    "The basic ``np.log`` gives the natural logarithm; if you prefer to compute the base-2 logarithm or the base-10 logarithm, these are available as well:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "e9mlMFNNVPZW",
    "outputId": "66786e72-221c-4c39-eba8-168b4e29acf7"
   },
   "outputs": [],
   "source": [
    "x = [1, 2, 4, 10]\n",
    "print(\"x        =\", x)\n",
    "print(\"ln(x)    =\", np.log(x))\n",
    "print(\"log2(x)  =\", np.log2(x))\n",
    "print(\"log10(x) =\", np.log10(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rsWnAmjvVPZX"
   },
   "source": [
    "There are also some specialized versions that are useful for maintaining precision with very small input:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "UsHEAZVJVPZY",
    "outputId": "fff283b9-4184-493e-ed4e-8949f5141ed5"
   },
   "outputs": [],
   "source": [
    "x = [0, 0.001, 0.01, 0.1]\n",
    "print(\"exp(x) - 1 =\", np.expm1(x))\n",
    "print(\"log(1 + x) =\", np.log1p(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ORu-JMv9VPZa"
   },
   "source": [
    "When ``x`` is very small, these functions give more precise values than if the raw ``np.log`` or ``np.exp`` were to be used."
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "M01N04 Introduction to NumPy.ipynb",
   "provenance": [
    {
     "file_id": "https://github.com/jakevdp/PythonDataScienceHandbook/blob/master/notebooks/02.02-The-Basics-Of-NumPy-Arrays.ipynb",
     "timestamp": 1548125363405
    }
   ]
  },
  "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}