notebooks/03-02 Ufuncs.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ufuncs\n",
    "Python's default implementation does some operations slowly. This is in part due to the dynamic and interpreted nature of the language. It is this feature that allows types to be flexible but since the type has to be checked at every operation, the sequences of operations cannot be compiled down to efficient machine code as in languages like C. Let’s take a look at Python native implementation of this:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "import numpy as np\n",
    "def get_sin(arr):\n",
    "    # Create an empty output array of same size as input\n",
    "    output = np.empty_like(arr)\n",
    "    for i in range(len(output)):\n",
    "        output[i] = np.sin(arr[i])\n",
    "    return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 13 s, sys: 53.9 ms, total: 13.1 s\n",
      "Wall time: 13.1 s\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([-0.64745651, -0.99996545,  0.99756044, ..., -0.96197339,\n",
       "        0.85711429,  0.99999453])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "input_arr = np.random.uniform(-np.pi, np.pi, 10000000)\n",
    "%time get_sin(input_arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Even though the above implementation is correct and might look optimized for people who are familiar with languages like C and Java, the above loop takes significant amount of time (check the `total` CPU times) and is horribly inefficient due to the reasons we mentioned above. \n",
    "\n",
    "This is where NumPy's `ufuncs` come to save the day. NumPy provides a convenient interface into these kinds of statically-typed, compiled routine. This is known as a vectorized operation. This can be accomplished by simply performing an operation on the array, which will then be applied to each element.\n",
    "\n",
    "The vectorized approach is designed to push the `loop` part of the code into the compiled layer that underlies NumPy, leading to much faster execution.\n",
    "\n",
    "Let's take a look at the NumPy ufunc based solution for the same example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 133 ms, sys: 450 µs, total: 133 ms\n",
      "Wall time: 134 ms\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([-0.9657678 ,  0.79841143,  0.28326751, ..., -0.88320409,\n",
       "       -0.79466346,  0.70549672])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "input_arr = np.random.uniform(-np.pi, np.pi, 10000000)\n",
    "%time np.sin(input_arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Thats much faster, right?\n",
    "\n",
    "You can also use these ufuncs on multi-dimensional array. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original Array: \n",
      "[[96 45 96 63]\n",
      " [18 65 61 42]\n",
      " [31 21 65 19]]\n",
      "\n",
      "Reciprocal: \n",
      "[[0.01041667 0.02222222 0.01041667 0.01587302]\n",
      " [0.05555556 0.01538462 0.01639344 0.02380952]\n",
      " [0.03225806 0.04761905 0.01538462 0.05263158]]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "arr = np.random.randint(1, 100, (3, 4))\n",
    "# take reciprocal\n",
    "print(\"Original Array: \\n{}\".format(arr), end=\"\\n\\n\")\n",
    "print(\"Reciprocal: \\n{}\".format(1/arr), end=\"\\n\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Array Mathematics\n",
    "\n",
    "#### Arithmetic Operations\n",
    "Python's native operators can be directly used as a convenient wrapper for NumPy's ufuncs to `broadcast` the operation over all the elements of that array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x      = [-5 -4 -3 -2 -1  0  1  2  3  4]\n",
      "x + 10  = [ 5  6  7  8  9 10 11 12 13 14]\n",
      "x - 10  = [-15 -14 -13 -12 -11 -10  -9  -8  -7  -6]\n",
      "x * 4  = [-20 -16 -12  -8  -4   0   4   8  12  16]\n",
      "x / 4  = [-1.25 -1.   -0.75 -0.5  -0.25  0.    0.25  0.5   0.75  1.  ]\n",
      "x % 4  = [3 0 1 2 3 0 1 2 3 0]\n",
      "x // 4 = [-2 -1 -1 -1 -1  0  0  0  0  1]\n",
      "x ** 2 = [25 16  9  4  1  0  1  4  9 16]\n",
      "abs(x) = [5 4 3 2 1 0 1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(-5, 5)\n",
    "print(\"x      =\", x)\n",
    "print(\"x + 10  =\", x + 10) # wrapper for np.sum \n",
    "print(\"x - 10  =\", x - 10) # wrapper for np.subtract\n",
    "print(\"x * 4  =\", x * 4)  # wrapper for np.multiply\n",
    "print(\"x / 4  =\", x / 4)  # wrapper for np.divide\n",
    "print(\"x % 4  =\", x % 4)  # wrapper for np.mod\n",
    "print(\"x // 4 =\", x // 4) # wrapper for np.floor_divide\n",
    "print(\"x ** 2 =\", x ** 2) # wrapper for np.power\n",
    "print(\"abs(x) =\", abs(x)) # wrapper for np.abs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above operations have been performed on the array of a particular datatype and so the result will have the same datatype as the array that is being operated on. However when you perform any operation on an array that results in a different datatype or on multiple arrays of different datatypes, the type of the resulting array will correspond to the more precise one. This is also known as upcasting.\n",
    "\n",
    "In the above example, check the output of division (/). Can you find the type of that array?\n",
    "\n",
    "When standard mathematical operations are used with numpy arrays, they are applied on an element-by-element basis and a new array is created and filled with the result. This means that the arrays should be of same size when any mathematical operation is performed on them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array1: \n",
      "[1. 2. 3. 4.]\n",
      "\n",
      "Array2: \n",
      "[ 4.  8. 12. 16.]\n",
      "\n",
      "\n",
      " Array2 - Array1: \n",
      " [ 3.  6.  9. 12.]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "arr1 = np.array([1., 2., 3., 4.])\n",
    "arr2 = np.linspace(4, 16, num=4)\n",
    "print(\"Array1: \\n{}\".format(arr1), end=\"\\n\\n\")\n",
    "print(\"Array2: \\n{}\".format(arr2), end=\"\\n\\n\")\n",
    "print(\"\\n Array2 - Array1: \\n {}\".format(arr2-arr1), end=\"\\n\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, if there was a size mismatch, then we would receive a `ValueError`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "operands could not be broadcast together with shapes (3,) (4,) ",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-7-6db414b41f4e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0marr2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinspace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m16\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnum\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"\\n Array2 - Array1: \\n {}\"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marr2\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0marr1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mend\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"\\n\\n\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (3,) (4,) "
     ]
    }
   ],
   "source": [
    "arr2 = np.linspace(4, 16, num=3)\n",
    "print(\"\\n Array2 - Array1: \\n {}\".format(arr2-arr1), end=\"\\n\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Well you might wonder why was it that we did not get a broadcast error when we performed addition of a single number over an array. We shall look at this in the module on Broadcasting.\n",
    "\n",
    "#### Trignometric Functions\n",
    "Just like Arithmetic operations, NumPy provides a bunch of trigonometric `ufuncs`. Let’s take a look at some."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input Array: \n",
      "[-0.95633706 -0.49033535 -0.48827774  0.5121991   0.16100066]\n",
      "\n",
      "sin: \n",
      "[-0.81708531 -0.47092175 -0.46910558  0.49009532  0.16030601]\n",
      "\n",
      "cos: \n",
      "[0.57651678 0.88217498 0.88314209 0.87166885 0.98706737]\n",
      "\n",
      "tan: \n",
      "[-1.4172793  -0.53381898 -0.53117792  0.56224943  0.16240635]\n",
      "\n",
      "arcsin: \n",
      "[-1.27420085 -0.51247449 -0.51011515  0.53774331  0.16170446]\n",
      "\n",
      "arccos: \n",
      "[2.84499718 2.08327082 2.08091147 1.03305302 1.40909187]\n",
      "\n",
      "arctan: \n",
      "[-0.76308315 -0.45588604 -0.4542259   0.47335919  0.15963079]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "input_arr = np.random.uniform(-1, 1, 5)\n",
    "print(\"Input Array: \\n{}\".format(input_arr), end=\"\\n\\n\")\n",
    "print(\"sin: \\n{}\".format(np.sin(input_arr)), end=\"\\n\\n\")\n",
    "print(\"cos: \\n{}\".format(np.cos(input_arr)), end=\"\\n\\n\")\n",
    "print(\"tan: \\n{}\".format(np.tan(input_arr)), end=\"\\n\\n\")\n",
    "print(\"arcsin: \\n{}\".format(np.arcsin(input_arr)), end=\"\\n\\n\")\n",
    "print(\"arccos: \\n{}\".format(np.arccos(input_arr)), end=\"\\n\\n\")\n",
    "print(\"arctan: \\n{}\".format(np.arctan(input_arr)), end=\"\\n\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Logarithmic Functions\n",
    "Numpy provides logarithmic ufuncs for different `bases'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x        = [5 6 4 6 2]\n",
      "ln(x)    = [1.60943791 1.79175947 1.38629436 1.79175947 0.69314718]\n",
      "log2(x)  = [2.32192809 2.5849625  2.         2.5849625  1.        ]\n",
      "log10(x) = [0.69897    0.77815125 0.60205999 0.77815125 0.30103   ]\n"
     ]
    }
   ],
   "source": [
    "input_arr = np.random.randint(1, 7, 5)\n",
    "print(\"x        =\", input_arr)\n",
    "print(\"ln(x)    =\", np.log(input_arr))\n",
    "print(\"log2(x)  =\", np.log2(input_arr))\n",
    "print(\"log10(x) =\", np.log10(input_arr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Counterpart of Logs, we also have exponential ufuncs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x     = [5 1 4 4 2]\n",
      "e^x   = [148.4131591    2.71828183  54.59815003  54.59815003   7.3890561 ]\n",
      "2^x   = [32.  2. 16. 16.  4.]\n",
      "10^x   = [100000     10  10000  10000    100]\n"
     ]
    }
   ],
   "source": [
    "input_arr = np.random.randint(1, 7, 5)\n",
    "print(\"x     =\", input_arr)\n",
    "print(\"e^x   =\", np.exp(input_arr))\n",
    "print(\"2^x   =\", np.exp2(input_arr))\n",
    "print(\"10^x   =\", np.power(10, input_arr))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}