Numpy Universal Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "07118626",
   "metadata": {},
   "source": [
    "# Numpy ufunc"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a887609",
   "metadata": {},
   "source": [
    "### What are ufuncs?\n",
    "ufuncs stands for \"Universal Functions\" and they are NumPy functions that operate on the ndarray object.\n",
    "\n",
    "### Why use ufuncs?\n",
    "ufuncs are used to implement vectorization in NumPy which is way faster than iterating over elements.\n",
    "\n",
    "They also provide broadcasting and additional methods like reduce, accumulate etc. that are very helpful for computation.\n",
    "\n",
    "ufuncs also take additional arguments, like:\n",
    "\n",
    "where: boolean array or condition defining where the operations should take place.\n",
    "\n",
    "dtype: defining the return type of elements.\n",
    "\n",
    "out: output array where the return value should be copied.\n",
    "\n",
    "### What is Vectorization?\n",
    "Converting iterative statements into a vector based operation is called vectorization.\n",
    "It is faster as modern CPUs are optimized for such operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "962aa4f2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 7, 9, 11]\n"
     ]
    }
   ],
   "source": [
    "x = [1, 2, 3, 4]\n",
    "y = [4, 5, 6, 7]\n",
    "z = []\n",
    "\n",
    "for i, j in zip(x, y):\n",
    "  z.append(i + j)\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "969354cd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 5  7  9 11]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "x = [1, 2, 3, 4]\n",
    "y = [4, 5, 6, 7]\n",
    "z = np.add(x, y)\n",
    "\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "792eb875",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6 8 10 12]\n"
     ]
    }
   ],
   "source": [
    "def myadd(x, y):\n",
    "  return x+y\n",
    "\n",
    "myadd = np.frompyfunc(myadd, 2, 1)\n",
    "\n",
    "print(myadd([1, 2, 3, 4], [5, 6, 7, 8]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "299ca88e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "add is ufunc\n"
     ]
    }
   ],
   "source": [
    "#Use an if statement to check if the function is a ufunc or not:\n",
    "if type(np.add) == np.ufunc:\n",
    "  print('add is ufunc')\n",
    "else:\n",
    "  print('add is not ufunc')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e59b93c",
   "metadata": {},
   "source": [
    "### Simple Arithmetic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "76d66982",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[30 32 34 36 38 40]\n"
     ]
    }
   ],
   "source": [
    "arr1 = np.array([10, 11, 12, 13, 14, 15])\n",
    "arr2 = np.array([20, 21, 22, 23, 24, 25])\n",
    "\n",
    "newarr = np.add(arr1, arr2)\n",
    "\n",
    "print(newarr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "5567ab02",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-10  -1   8  17  26  35]\n"
     ]
    }
   ],
   "source": [
    "arr1 = np.array([10, 20, 30, 40, 50, 60])\n",
    "arr2 = np.array([20, 21, 22, 23, 24, 25])\n",
    "\n",
    "newarr = np.subtract(arr1, arr2)\n",
    "\n",
    "print(newarr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79e5ce5d",
   "metadata": {},
   "source": [
    "### Rounding Decimals\n",
    "There are primarily five ways of rounding off decimals in NumPy:\n",
    "\n",
    "- truncation\n",
    "- fix\n",
    "- rounding\n",
    "- floor\n",
    "- ceil"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "6bf269d8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-3.  3.]\n"
     ]
    }
   ],
   "source": [
    "#Truncation\n",
    "import numpy as np\n",
    "\n",
    "arr = np.trunc([-3.1666, 3.6667])\n",
    "\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "1e1458e2",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-3.  3.]\n"
     ]
    }
   ],
   "source": [
    "#Fix\n",
    "arr = np.fix([-3.1666, 3.6667])\n",
    "\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7b4cd15",
   "metadata": {},
   "source": [
    "#### Rounding\n",
    "- The around() function increments preceding digit or decimal by 1 if >=5 else do nothing.\n",
    "- E.g. round off to 1 decimal point, 3.16666 is 3.2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "6a7e17df",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.17\n"
     ]
    }
   ],
   "source": [
    "arr = np.around(3.1666, 2)\n",
    "\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "738036c1",
   "metadata": {},
   "source": [
    "#### Floor\n",
    "- The floor() function rounds off decimal to nearest lower integer.\n",
    "- E.g. floor of 3.166 is 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "72c6b804",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-4.  3.]\n"
     ]
    }
   ],
   "source": [
    "arr = np.floor([-3.1666, 3.6667])\n",
    "\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "275fa95a",
   "metadata": {},
   "source": [
    "#### Ceil\n",
    "- The ceil() function rounds off decimal to nearest upper integer.\n",
    "- E.g. ceil of 3.166 is 4."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "ad05eaf6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-3.  4.]\n"
     ]
    }
   ],
   "source": [
    "arr = np.ceil([-3.1666, 3.6667])\n",
    "\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9269662",
   "metadata": {},
   "source": [
    "## NumPy Logs\n",
    "NumPy provides functions to perform log at the base 2, e and 10.\n",
    "\n",
    "We will also explore how we can take log for any base by creating a custom ufunc.\n",
    "\n",
    "All of the log functions will place -inf or inf in the elements if the log can not be computed."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d671d492",
   "metadata": {},
   "source": [
    "### Log at Base 2\n",
    "Use the log2() function to perform log at the base 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "c700c586",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.         1.         1.5849625  2.         2.32192809 2.5849625\n",
      " 2.80735492 3.         3.169925  ]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(1, 10)\n",
    "\n",
    "print(np.log2(arr))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d53bd897",
   "metadata": {},
   "source": [
    "### Log at Base 10\n",
    "Use the log10() function to perform log at the base 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "0495fbd7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.         0.30103    0.47712125 0.60205999 0.69897    0.77815125\n",
      " 0.84509804 0.90308999 0.95424251]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(1, 10)\n",
    "\n",
    "print(np.log10(arr))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9645cd30",
   "metadata": {},
   "source": [
    "### Natural Log, or Log at Base e\n",
    "Use the log() function to perform log at the base e."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "d4748219",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.         0.69314718 1.09861229 1.38629436 1.60943791 1.79175947\n",
      " 1.94591015 2.07944154 2.19722458]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(1, 10)\n",
    "\n",
    "print(np.log(arr))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c8c2d2a",
   "metadata": {},
   "source": [
    "### Log at Any Base\n",
    "NumPy does not provide any function to take log at any base, so we can use the frompyfunc() function along with inbuilt function math.log() with two input parameters and one output parameter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "a1e2f3f2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.7005483074552052\n"
     ]
    }
   ],
   "source": [
    "from math import log\n",
    "import numpy as np\n",
    "\n",
    "nplog = np.frompyfunc(log, 2, 1)\n",
    "\n",
    "print(nplog(100, 15))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5eadd0e3",
   "metadata": {},
   "source": [
    "## NumPy Summations\n",
    "What is the difference between summation and addition?\n",
    "Addition is done between two arguments whereas summation happens over n elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "95b55f59",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 4 6]\n"
     ]
    }
   ],
   "source": [
    "#Addition\n",
    "arr1 = np.array([1, 2, 3])\n",
    "arr2 = np.array([1, 2, 3])\n",
    "\n",
    "newarr = np.add(arr1, arr2)\n",
    "\n",
    "print(newarr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "7e6137c1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "#Summation\n",
    "arr1 = np.array([1, 2, 3])\n",
    "arr2 = np.array([1, 2, 3])\n",
    "\n",
    "newarr = np.sum([arr1, arr2])\n",
    "\n",
    "print(newarr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2bc99c52",
   "metadata": {},
   "source": [
    "### Summation Over an Axis\n",
    "If you specify axis=1, NumPy will sum the numbers in each array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "a2e8f9d8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6 6]\n"
     ]
    }
   ],
   "source": [
    "arr1 = np.array([1, 2, 3])\n",
    "arr2 = np.array([1, 2, 3])\n",
    "\n",
    "newarr = np.sum([arr1, arr2], axis=1)\n",
    "\n",
    "print(newarr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b16adf1d",
   "metadata": {},
   "source": [
    "### Cummulative Sum\n",
    "Cummulative sum means partially adding the elements in array.\n",
    "\n",
    "E.g. The partial sum of [1, 2, 3, 4] would be [1, 1+2, 1+2+3, 1+2+3+4] = [1, 3, 6, 10].\n",
    "\n",
    "Perfom partial sum with the cumsum() function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "2cd31182",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 3 6]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([1, 2, 3])\n",
    "newarr = np.cumsum(arr)\n",
    "print(newarr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e52fd642",
   "metadata": {},
   "source": [
    "## NumPy Products\n",
    "To find the product of the elements in an array, use the prod() function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "1faea4fc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24\n"
     ]
    }
   ],
   "source": [
    "#Find the product of the elements of this array:\n",
    "#Returns: 24 because 1*2*3*4 = 24\n",
    "\n",
    "arr = np.array([1, 2, 3, 4])\n",
    "x = np.prod(arr)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a3ee013",
   "metadata": {},
   "source": [
    "### Product Over an Axis\n",
    "If you specify axis=1, NumPy will return the product of each array.\n",
    "Perform summation in the following array over 1st axis:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "d219f233",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  24 1680]\n"
     ]
    }
   ],
   "source": [
    "arr1 = np.array([1, 2, 3, 4])\n",
    "arr2 = np.array([5, 6, 7, 8])\n",
    "\n",
    "newarr = np.prod([arr1, arr2], axis=1)\n",
    "\n",
    "print(newarr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37ee2a9a",
   "metadata": {},
   "source": [
    "### Cummulative Product\n",
    "Cummulative product means taking the product partially.\n",
    "\n",
    "E.g. The partial product of [1, 2, 3, 4] is [1, 1*2, 1*2*3, 1*2*3*4] = [1, 2, 6, 24]\n",
    "\n",
    "Perfom partial sum with the cumprod() function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "23fc0629",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[   5   30  210 1680]\n"
     ]
    }
   ],
   "source": [
    "#Take cummulative product of all elements for following array:\n",
    "arr = np.array([5, 6, 7, 8])\n",
    "newarr = np.cumprod(arr)\n",
    "print(newarr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e80a5fd",
   "metadata": {},
   "source": [
    "## NumPy Differences\n",
    "A discrete difference means subtracting two successive elements.\n",
    "\n",
    "E.g. for [1, 2, 3, 4], the discrete difference would be [2-1, 3-2, 4-3] = [1, 1, 1]\n",
    "\n",
    "To find the discrete difference, use the diff() function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "fcc6efd6",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  5  10 -20]\n"
     ]
    }
   ],
   "source": [
    "#Compute discrete difference of the following array:\n",
    "arr = np.array([10, 15, 25, 5])\n",
    "newarr = np.diff(arr)\n",
    "print(newarr)\n",
    "\n",
    "#Returns: [5 10 -20] because 15-10=5, 25-15=10, and 5-25=-20"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0367fc6a",
   "metadata": {},
   "source": [
    "We can perform this operation repeatedly by giving parameter n.\n",
    "\n",
    "E.g. for [1, 2, 3, 4], the discrete difference with n = 2 would be [2-1, 3-2, 4-3] = [1, 1, 1] , then, since n=2, we will do it once more, with the new result: [1-1, 1-1] = [0, 0]\n",
    "Example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "52666bae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  5 -30]\n"
     ]
    }
   ],
   "source": [
    "#Compute discrete difference of the following array twice:\n",
    "\n",
    "arr = np.array([10, 15, 25, 5])\n",
    "newarr = np.diff(arr, n=2)\n",
    "print(newarr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5094675b",
   "metadata": {},
   "source": [
    "## NumPy LCM Lowest Common Multiple\n",
    "The Lowest Common Multiple is the smallest number that is a common multiple of two numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "5a182c27",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "#Find the LCM of the following two numbers:\n",
    "num1 = 4\n",
    "num2 = 6\n",
    "\n",
    "x = np.lcm(num1, num2)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26ee7b71",
   "metadata": {},
   "source": [
    "### Finding LCM in Arrays\n",
    "To find the Lowest Common Multiple of all values in an array, you can use the reduce() method.\n",
    "The reduce() method will use the ufunc, in this case the lcm() function, on each element, and reduce the array by one dimension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "ce3863d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18\n"
     ]
    }
   ],
   "source": [
    "#Find the LCM of the values of the following array:\n",
    "\n",
    "arr = np.array([3, 6, 9])\n",
    "x = np.lcm.reduce(arr)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "2b533ee2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Our Array is: [ 1  2  3  4  5  6  7  8  9 10]\n",
      "Answer is: 2520\n"
     ]
    }
   ],
   "source": [
    "#Find the LCM of all values of an array where the array contains all integers from 1 to 10:\n",
    "\n",
    "arr = np.arange(1, 11)\n",
    "print(\"Our Array is: {}\".format(arr))\n",
    "x = np.lcm.reduce(arr)\n",
    "\n",
    "print(\"Answer is: {}\".format(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e7dca58",
   "metadata": {},
   "source": [
    "## NumPy GCD Greatest Common Denominator\n",
    "The GCD (Greatest Common Denominator), also known as HCF (Highest Common Factor) is the biggest number that is a common factor of both of the numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "a785ee41",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Highest Common Factor of X & Y is: 3\n"
     ]
    }
   ],
   "source": [
    "#Find the HCF of the following two numbers:\n",
    "\n",
    "X = 6\n",
    "Y = 9\n",
    "\n",
    "HCF = np.gcd(X, Y)\n",
    "\n",
    "print(\"Highest Common Factor of X & Y is: {}\".format(HCF))\n",
    "\n",
    "#Returns: 3 because that is the highest number both numbers can be divided by (6/3=2 and 9/3=3)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b69cb02c",
   "metadata": {},
   "source": [
    "### Finding GCD in Arrays\n",
    "To find the Highest Common Factor of all values in an array, you can use the reduce() method.\n",
    "\n",
    "The reduce() method will use the ufunc, in this case the gcd() function, on each element, and reduce the array by one dimension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "15e1f972",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "#Find the GCD for all of the numbers in the following array:\n",
    "\n",
    "arr = np.array([20, 8, 32, 36, 16])\n",
    "x = np.gcd.reduce(arr)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50827b3e",
   "metadata": {},
   "source": [
    "## NumPy Trigonometric Functions\n",
    "NumPy provides the ufuncs sin(), cos() and tan() that take values in radians and produce the corresponding sin, cos and tan values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "0843d612",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "source": [
    "#Find sine value of PI/2:\n",
    "\n",
    "x = np.sin(np.pi/2)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "091e7a99",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.         0.8660254  0.70710678 0.58778525]\n"
     ]
    }
   ],
   "source": [
    "#Find sine values for all of the values in arr:\n",
    "\n",
    "arr = np.array([np.pi/2, np.pi/3, np.pi/4, np.pi/5])\n",
    "x = np.sin(arr)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6dbd9f7d",
   "metadata": {},
   "source": [
    "### Convert Degrees Into Radians\n",
    "By default all of the trigonometric functions take radians as parameters but we can convert radians to degrees and vice versa as well in NumPy.\n",
    "\n",
    "__Note:__ radians values are pi/180 * degree_values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "5e19ec52",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.57079633 3.14159265 4.71238898 6.28318531]\n"
     ]
    }
   ],
   "source": [
    "#Convert all of the values in following array arr to radians:\n",
    "\n",
    "arr = np.array([90, 180, 270, 360])\n",
    "x = np.deg2rad(arr)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f4fd3b4",
   "metadata": {},
   "source": [
    "### Radians to Degrees"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "6dace731",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 90. 180. 270. 360.]\n"
     ]
    }
   ],
   "source": [
    "#Convert all of the values in following array arr to degrees:\n",
    "\n",
    "arr = np.array([np.pi/2, np.pi, 1.5*np.pi, 2*np.pi])\n",
    "x = np.rad2deg(arr)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f489e364",
   "metadata": {},
   "source": [
    "### Finding Angles\n",
    "Finding angles from values of sine, cos, tan. E.g. sin, cos and tan inverse (arcsin, arccos, arctan).\n",
    "\n",
    "NumPy provides ufuncs arcsin(), arccos() and arctan() that produce radian values for corresponding sin, cos and tan values given."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "27390ccd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.5707963267948966\n"
     ]
    }
   ],
   "source": [
    "#Find the angle of 1.0:\n",
    "\n",
    "x = np.arcsin(1.0)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "caf7d674",
   "metadata": {},
   "source": [
    "### Angles of Each Value in Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "d84002c2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1.57079633 -1.57079633  0.10016742]\n"
     ]
    }
   ],
   "source": [
    "#Find the angle for all of the sine values in the array\n",
    "\n",
    "arr = np.array([1, -1, 0.1])\n",
    "x = np.arcsin(arr)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6f1f139",
   "metadata": {},
   "source": [
    "### Hypotenues\n",
    "Finding hypotenues using pythagoras theorem in NumPy.\n",
    "\n",
    "NumPy provides the hypot() function that takes the base and perpendicular values and produces hypotenues based on pythagoras theorem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "b25a97a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.0\n"
     ]
    }
   ],
   "source": [
    "#Find the hypotenues for 4 base and 3 perpendicular:\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "base = 3\n",
    "perp = 4\n",
    "\n",
    "x = np.hypot(base, perp)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d227a5e5",
   "metadata": {},
   "source": [
    "## NumPy Hyperbolic Functions\n",
    "NumPy provides the ufuncs sinh(), cosh() and tanh() that take values in radians and produce the corresponding sinh, cosh and tanh values.."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "c0ef099f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.3012989023072947\n"
     ]
    }
   ],
   "source": [
    "#Find sinh value of PI/2:\n",
    "\n",
    "x = np.sinh(np.pi/2)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "d7c2b0bf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2.50917848 1.60028686 1.32460909 1.20397209]\n"
     ]
    }
   ],
   "source": [
    "#Find cosh values for all of the values in arr:\n",
    "\n",
    "arr = np.array([np.pi/2, np.pi/3, np.pi/4, np.pi/5])\n",
    "x = np.cosh(arr)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66651316",
   "metadata": {},
   "source": [
    "## NumPy Set Operations\n",
    "A set in mathematics is a collection of unique elements.\n",
    "\n",
    "Sets are used for operations involving frequent intersection, union and difference operations."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4d16d22",
   "metadata": {},
   "source": [
    "### Create Sets in NumPy\n",
    "We can use NumPy's unique() method to find unique elements from any array. E.g. create a set array, but remember that the set arrays should only be 1-D arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "fc7afcfb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6 7]\n"
     ]
    }
   ],
   "source": [
    "#Convert following array with repeated elements to a set:\n",
    "\n",
    "arr = np.array([1, 1, 1, 2, 3, 4, 5, 5, 6, 7])\n",
    "x = np.unique(arr)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be33e6da",
   "metadata": {},
   "source": [
    "### Finding Union"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "7f170c76",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6]\n"
     ]
    }
   ],
   "source": [
    "#Find union of the following two set arrays:\n",
    "\n",
    "arr1 = np.array([1, 2, 3, 4])\n",
    "arr2 = np.array([3, 4, 5, 6])\n",
    "\n",
    "newarr = np.union1d(arr1, arr2)\n",
    "\n",
    "print(newarr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04a29a6e",
   "metadata": {},
   "source": [
    "### Finding Intersection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "5ae83b83",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3 4]\n"
     ]
    }
   ],
   "source": [
    "#Find intersection of the following two set arrays:\n",
    "\n",
    "arr1 = np.array([1, 2, 3, 4])\n",
    "arr2 = np.array([3, 4, 5, 6])\n",
    "\n",
    "newarr = np.intersect1d(arr1, arr2, assume_unique=True)\n",
    "\n",
    "print(newarr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20c07fcf",
   "metadata": {},
   "source": [
    "__Note:__ the intersect1d() method takes an optional argument assume_unique, which if set to True can speed up computation. It should always be set to True when dealing with sets."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cec5026",
   "metadata": {},
   "source": [
    "### Finding Difference\n",
    "To __find only the values in the first set that is NOT present in the seconds set__, use the setdiff1d() method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "40cceaed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2]\n"
     ]
    }
   ],
   "source": [
    "#Find the difference of the set1 from set2:\n",
    "\n",
    "set1 = np.array([1, 2, 3, 4])\n",
    "set2 = np.array([3, 4, 5, 6])\n",
    "\n",
    "newarr = np.setdiff1d(set1, set2, assume_unique=True)\n",
    "\n",
    "print(newarr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c6a75d1",
   "metadata": {},
   "source": [
    "### Finding Symmetric Difference\n",
    "To find only the values that are NOT present in BOTH sets, use the setxor1d() method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "a7a96889",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 5 6]\n"
     ]
    }
   ],
   "source": [
    "#Find the symmetric difference of the set1 and set2:\n",
    "\n",
    "set1 = np.array([1, 2, 3, 4])\n",
    "set2 = np.array([3, 4, 5, 6])\n",
    "\n",
    "newarr = np.setxor1d(set1, set2, assume_unique=True)\n",
    "\n",
    "print(newarr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cd477435",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}