00_02_numbers_in_python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Manipulating numbers in Python\n",
    "================\n",
    "\n",
    "**_Disclaimer_: Much of this section has been transcribed from <a href=\"https://pymotw.com/2/math/\">https://pymotw.com/2/math/</a>** \n",
    "\n",
    "Every computer represents numbers using the <a href=\"https://en.wikipedia.org/wiki/IEEE_floating_point\">IEEE floating point standard</a>. The **math** module implements many of the IEEE functions that would normally be found in the native platform C libraries for complex mathematical operations using floating point values, including logarithms and trigonometric operations. \n",
    "\n",
    "The fundamental information about number representation is contained in the module **sys**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import sys \n",
    "\n",
    "sys.float_info"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From here we can learn, for instance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.7976931348623157e+308"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sys.float_info.max"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, we can learn the limits of the IEEE 754 standard\n",
    "\n",
    "Largest Real = 1.79769e+308, 7fefffffffffffff // -Largest Real = -1.79769e+308, ffefffffffffffff\n",
    "\n",
    "Smallest Real = 2.22507e-308, 0010000000000000 // -Smallest Real = -2.22507e-308, 8010000000000000\n",
    "\n",
    "Zero = 0, 0000000000000000 // -Zero = -0, 8000000000000000\n",
    "\n",
    "eps = 2.22045e-16, 3cb0000000000000 // -eps = -2.22045e-16, bcb0000000000000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Interestingly, one could define an even larger constant (more about this below)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "inf"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "infinity = float(\"inf\")\n",
    "infinity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "inf"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "infinity/10000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Special constants\n",
    "\n",
    "Many math operations depend on special constants. **math** includes values for $\\pi$ and $e$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "π: 3.141592653589793115997963468544\n",
      "e: 2.718281828459045090795598298428\n",
      "nan: nan\n",
      "inf: inf\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "print ('π: %.30f' % math.pi)\n",
    "print ('e: %.30f' % math.e)\n",
    "print('nan: {:.30f}'.format(math.nan))\n",
    "print('inf: {:.30f}'.format(math.inf))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Both values are limited in precision only by the platform’s floating point C library."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing for exceptional values\n",
    "\n",
    "Floating point calculations can result in two types of exceptional values. INF (“infinity”) appears when the double used to hold a floating point value overflows from a value with a large absolute value.\n",
    "There are several reserved bit patterns, mostly those with all ones in the exponent field. These allow for tagging special cases as Not A Number—NaN. If there are all ones and the fraction is zero, the number is Infinite.\n",
    "\n",
    "The IEEE standard specifies:\n",
    "\n",
    "Inf = Inf, 7ff0000000000000 // -Inf = -Inf, fff0000000000000\n",
    "\n",
    "NaN = NaN, fff8000000000000 // -NaN = NaN, 7ff8000000000000\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "nan"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float(\"inf\")-float(\"inf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " e  x      x**2   isinf \n",
      "--- ------ ------ ------\n",
      "  0 1      1      False \n",
      " 20 1e+20  1e+40  False \n",
      " 40 1e+40  1e+80  False \n",
      " 60 1e+60  1e+120 False \n",
      " 80 1e+80  1e+160 False \n",
      "100 1e+100 1e+200 False \n",
      "120 1e+120 1e+240 False \n",
      "140 1e+140 1e+280 False \n",
      "160 1e+160 inf    True  \n",
      "180 1e+180 inf    True  \n",
      "200 1e+200 inf    True  \n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "print('{:^3} {:6} {:6} {:6}'.format(\n",
    "    'e', 'x', 'x**2', 'isinf'))\n",
    "print('{:-^3} {:-^6} {:-^6} {:-^6}'.format(\n",
    "    '', '', '', ''))\n",
    "\n",
    "for e in range(0, 201, 20):\n",
    "    x = 10.0 ** e\n",
    "    y = x * x\n",
    "    print('{:3d} {:<6g} {:<6g} {!s:6}'.format(\n",
    "        e, x, y, math.isinf(y),))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When the exponent in this example grows large enough, the square of x no longer fits inside a double, and the value is recorded as infinite. Not all floating point overflows result in INF values, however. Calculating an exponent with floating point values, in particular, raises OverflowError instead of preserving the INF result.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x    = 1e+200\n",
      "x*x  = inf\n",
      "(34, 'Result too large')\n"
     ]
    }
   ],
   "source": [
    "x = 10.0 ** 200\n",
    "\n",
    "print('x    =', x)\n",
    "print('x*x  =', x*x)\n",
    "try:\n",
    "    print('x**2 =', x**2)\n",
    "except OverflowError as err:\n",
    "    print(err)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This discrepancy is caused by an implementation difference in the library used by C Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Division operations using infinite values are undefined. The result of dividing a number by infinity is NaN (“not a number”)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = inf\n",
      "isnan(x) = False\n",
      "y = x / x = nan\n",
      "y == nan = False\n",
      "isnan(y) = True\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "x = (10.0 ** 200) * (10.0 ** 200)\n",
    "y = x/x\n",
    "\n",
    "print('x =', x)\n",
    "print('isnan(x) =', math.isnan(x))\n",
    "print('y = x / x =', x/x)\n",
    "print('y == nan =', y == float('nan'))\n",
    "print('isnan(y) =', math.isnan(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparing\n",
    "Comparisons for floating point values can be error prone, with each step of the computation potentially introducing errors due to the numerical representation. The isclose() function uses a stable algorithm to minimize these errors and provide a way for relative as well as absolute comparisons. The formula used is equivalent to\n",
    "\n",
    "abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)\n",
    "By default, isclose() uses relative comparison with the tolerance set to 1e-09, meaning that the difference between the values must be less than or equal to 1e-09 times the larger absolute value between a and b. Passing a keyword argument rel_tol to isclose() changes the tolerance. In this example, the values must be within 10% of each other.\n",
    "\n",
    "The comparison between 0.1 and 0.09 fails because of the error representing 0.1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   a        b     rel_tol  abs(a-b) tolerance  close  \n",
      "-------- -------- -------- -------- -------- --------\n",
      " 1000.00   900.00     0.10   100.00   100.00     True\n",
      "  100.00    90.00     0.10    10.00    10.00     True\n",
      "   10.00     9.00     0.10     1.00     1.00     True\n",
      "    1.00     0.90     0.10     0.10     0.10     True\n",
      "    0.10     0.09     0.10     0.01     0.01    False\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "INPUTS = [\n",
    "    (1000, 900, 0.1),\n",
    "    (100, 90, 0.1),\n",
    "    (10, 9, 0.1),\n",
    "    (1, 0.9, 0.1),\n",
    "    (0.1, 0.09, 0.1),\n",
    "]\n",
    "\n",
    "print('{:^8} {:^8} {:^8} {:^8} {:^8} {:^8}'.format(\n",
    "    'a', 'b', 'rel_tol', 'abs(a-b)', 'tolerance', 'close')\n",
    ")\n",
    "print('{:-^8} {:-^8} {:-^8} {:-^8} {:-^8} {:-^8}'.format(\n",
    "    '-', '-', '-', '-', '-', '-'),\n",
    ")\n",
    "\n",
    "fmt = '{:8.2f} {:8.2f} {:8.2f} {:8.2f} {:8.2f} {!s:>8}'\n",
    "\n",
    "for a, b, rel_tol in INPUTS:\n",
    "    close = math.isclose(a, b, rel_tol=rel_tol)\n",
    "    tolerance = rel_tol * max(abs(a), abs(b))\n",
    "    abs_diff = abs(a - b)\n",
    "    print(fmt.format(a, b, rel_tol, abs_diff, tolerance, close))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To use a fixed or \"absolute\" tolerance, pass abs_tol instead of rel_tol.\n",
    "\n",
    "For an absolute tolerance, the difference between the input values must be less than the tolerance given.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   a          b      abs_tol   abs(a-b)   close  \n",
      "-------- ----------- -------- ---------- --------\n",
      "    1.00   1.0000001    1e-08 0.000000100    False\n",
      "    1.00  1.00000001    1e-08 0.000000010     True\n",
      "    1.00 1.000000001    1e-08 0.000000001     True\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "INPUTS = [\n",
    "    (1.0, 1.0 + 1e-07, 1e-08),\n",
    "    (1.0, 1.0 + 1e-08, 1e-08),\n",
    "    (1.0, 1.0 + 1e-09, 1e-08),\n",
    "]\n",
    "\n",
    "print('{:^8} {:^11} {:^8} {:^10} {:^8}'.format(\n",
    "    'a', 'b', 'abs_tol', 'abs(a-b)', 'close')\n",
    ")\n",
    "print('{:-^8} {:-^11} {:-^8} {:-^10} {:-^8}'.format(\n",
    "    '-', '-', '-', '-', '-'),\n",
    ")\n",
    "\n",
    "for a, b, abs_tol in INPUTS:\n",
    "    close = math.isclose(a, b, abs_tol=abs_tol)\n",
    "    abs_diff = abs(a - b)\n",
    "    print('{:8.2f} {:11} {:8} {:0.9f} {!s:>8}'.format(\n",
    "        a, b, abs_tol, abs_diff, close))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "nan and inf are special cases.\n",
    "nan is never close to another value, including itself. inf is only close to itself.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nan, nan: False\n",
      "nan, 1.0: False\n",
      "inf, inf: True\n",
      "inf, 1.0: False\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "print('nan, nan:', math.isclose(math.nan, math.nan))\n",
    "print('nan, 1.0:', math.isclose(math.nan, 1.0))\n",
    "print('inf, inf:', math.isclose(math.inf, math.inf))\n",
    "print('inf, 1.0:', math.isclose(math.inf, 1.0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Converting to Integers\n",
    "\n",
    "The math module includes three functions for converting floating point values to whole numbers. Each takes a different approach, and will be useful in different circumstances.\n",
    "\n",
    "The simplest is trunc(), which truncates the digits following the decimal, leaving only the significant digits making up the whole number portion of the value. floor() converts its input to the largest preceding integer, and ceil() (ceiling) produces the largest integer following sequentially after the input value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  i     int   trunk  floor  ceil \n",
      "-----  -----  -----  -----  -----\n",
      " -1.5   -1.0   -1.0   -2.0   -1.0\n",
      " -0.8    0.0    0.0   -1.0    0.0\n",
      " -0.5    0.0    0.0   -1.0    0.0\n",
      " -0.2    0.0    0.0   -1.0    0.0\n",
      "  0.0    0.0    0.0    0.0    0.0\n",
      "  0.2    0.0    0.0    0.0    1.0\n",
      "  0.5    0.0    0.0    0.0    1.0\n",
      "  0.8    0.0    0.0    0.0    1.0\n",
      "  1.0    1.0    1.0    1.0    1.0\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "print('{:^5}  {:^5}  {:^5}  {:^5}  {:^5}'.format('i', 'int', 'trunk', 'floor', 'ceil'))\n",
    "print('{:-^5}  {:-^5}  {:-^5}  {:-^5}  {:-^5}'.format('', '', '', '', ''))\n",
    "\n",
    "fmt = '  '.join(['{:5.1f}'] * 5)\n",
    "\n",
    "for i in [ -1.5, -0.8, -0.5, -0.2, 0, 0.2, 0.5, 0.8, 1 ]:\n",
    "    print (fmt.format(i, int(i), math.trunc(i), math.floor(i), math.ceil(i)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Alternate Representations\n",
    "\n",
    "**modf()** takes a single floating point number and returns a tuple containing the fractional and whole number parts of the input value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0/2 = (0.0, 0.0)\n",
      "1/2 = (0.5, 0.0)\n",
      "2/2 = (0.0, 1.0)\n",
      "3/2 = (0.5, 1.0)\n",
      "4/2 = (0.0, 2.0)\n",
      "5/2 = (0.5, 2.0)\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "for i in range(6):\n",
    "    print('{}/2 = {}'.format(i, math.modf(i/2.0)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**frexp()** returns the mantissa and exponent of a floating point number, and can be used to create a more portable representation of the value. It uses the formula x = m \\* 2 \\*\\* e, and returns the values m and e."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   x        m        e   \n",
      "-------  -------  -------\n",
      "   0.10     0.80       -3\n",
      "   0.50     0.50        0\n",
      "   4.00     0.50        3\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "print('{:^7}  {:^7}  {:^7}'.format('x', 'm', 'e'))\n",
    "print('{:-^7}  {:-^7}  {:-^7}'.format('', '', ''))\n",
    "\n",
    "for x in [ 0.1, 0.5, 4.0 ]:\n",
    "    m, e = math.frexp(x)\n",
    "    print('{:7.2f}  {:7.2f}  {:7d}'.format(x, m, e))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**ldexp()** is the inverse of frexp(). Using the same formula as frexp(), ldexp() takes the mantissa and exponent values as arguments and returns a floating point number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   m        e        x   \n",
      "-------  -------  -------\n",
      "   0.80       -3     0.10\n",
      "   0.50        0     0.50\n",
      "   0.50        3     4.00\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "print('{:^7}  {:^7}  {:^7}'.format('m', 'e', 'x'))\n",
    "print('{:-^7}  {:-^7}  {:-^7}'.format('', '', ''))\n",
    "\n",
    "for m, e in [ (0.8, -3),\n",
    "              (0.5,  0),\n",
    "              (0.5,  3),\n",
    "              ]:\n",
    "    x = math.ldexp(m, e)\n",
    "    print('{:7.2f}  {:7d}  {:7.2f}'.format(m, e, x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Positive and Negative Signs\n",
    "\n",
    "The absolute value of number is its value without a sign. Use **fabs()** to calculate the absolute value of a floating point number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.1\n",
      "0.0\n",
      "0.0\n",
      "1.1\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "print(math.fabs(-1.1))\n",
    "print(math.fabs(-0.0))\n",
    "print(math.fabs(0.0))\n",
    "print(math.fabs(1.1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To determine the sign of a value, either to give a set of values the same sign or simply for comparison, use **copysign()** to set the sign of a known good value. An extra function like copysign() is needed because comparing NaN and -NaN directly with other values does not work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  f      s     < 0    > 0    = 0 \n",
      "-----  -----  -----  -----  -----\n",
      " -1.0     -1  True   False  False\n",
      "  0.0      1  False  False  True \n",
      "  1.0      1  False  True   False\n",
      " -inf     -1  True   False  False\n",
      "  inf      1  False  True   False\n",
      "  nan     -1  False  False  False\n",
      "  nan      1  False  False  False\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "print\n",
    "print('{:^5}  {:^5}  {:^5}  {:^5}  {:^5}'.format('f', 's', '< 0', '> 0', '= 0'))\n",
    "print('{:-^5}  {:-^5}  {:-^5}  {:-^5}  {:-^5}'.format('', '', '', '', ''))\n",
    "\n",
    "for f in [ -1.0,\n",
    "            0.0,\n",
    "            1.0,\n",
    "            float('-inf'),\n",
    "            float('inf'),\n",
    "            float('-nan'),\n",
    "            float('nan'),\n",
    "            ]:\n",
    "    s = int(math.copysign(1, f))\n",
    "    print('{:5.1f}  {:5d}  {!s:5}  {!s:5}  {!s:5}'.format(f, s, f < 0, f > 0, f==0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Commonly Used Calculations\n",
    "\n",
    "Representing precise values in binary floating point memory is challenging. Some values cannot be represented exactly, and the more often a value is manipulated through repeated calculations, the more likely a representation error will be introduced. math includes a function for computing the sum of a series of floating point numbers using an efficient algorithm that minimize such errors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input values: [0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1]\n",
      "sum()       : 0.99999999999999988898\n",
      "for-loop    : 0.99999999999999988898\n",
      "math.fsum() : 1.00000000000000000000\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "values = [ 0.1 ] * 10\n",
    "\n",
    "print('Input values:', values)\n",
    "\n",
    "print('sum()       : {:.20f}'.format(sum(values)))\n",
    "\n",
    "s = 0.0\n",
    "for i in values:\n",
    "    s += i\n",
    "print('for-loop    : {:.20f}'.format(s))\n",
    "    \n",
    "print('math.fsum() : {:.20f}'.format(math.fsum(values)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given a sequence of ten values each equal to 0.1, the expected value for the sum of the sequence is 1.0. Since 0.1 cannot be represented exactly as a floating point value, however, errors are introduced into the sum unless it is calculated with **fsum()**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**factorial()** is commonly used to calculate the number of permutations and combinations of a series of objects. The factorial of a positive integer n, expressed n!, is defined recursively as (n-1)! * n and stops with 0! == 1. **factorial()** only works with whole numbers, but does accept float arguments as long as they can be converted to an integer without losing value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 0       1\n",
      " 1       1\n",
      " 2       2\n",
      " 3       6\n",
      " 4      24\n",
      " 5     120\n",
      "Error computing factorial(6.1): factorial() only accepts integral values\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "for i in [ 0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.1 ]:\n",
    "    try:\n",
    "        print('{:2.0f}  {:6.0f}'.format(i, math.factorial(i)))\n",
    "    except ValueError as err:\n",
    "        print('Error computing factorial(%s):' % i, err)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The modulo operator (%) computes the remainder of a division expression (i.e., 5 % 2 = 1). The operator built into the language works well with integers but, as with so many other floating point operations, intermediate calculations cause representational issues that result in a loss of data. fmod() provides a more accurate implementation for floating point values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " x     y      %    fmod \n",
      "----  ----  -----  -----\n",
      " 5.0   2.0   1.00   1.00\n",
      " 5.0  -2.0  -1.00   1.00\n",
      "-5.0   2.0   1.00  -1.00\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "print('{:^4}  {:^4}  {:^5}  {:^5}'.format('x', 'y', '%', 'fmod'))\n",
    "print('----  ----  -----  -----')\n",
    "\n",
    "for x, y in [ (5, 2),\n",
    "              (5, -2),\n",
    "              (-5, 2),\n",
    "              ]:\n",
    "    print('{:4.1f}  {:4.1f}  {:5.2f}  {:5.2f}'.format(x, y, x % y, math.fmod(x, y)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A potentially more frequent source of confusion is the fact that the algorithm used by fmod for computing modulo is also different from that used by %, so the sign of the result is different. mixed-sign inputs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exponents and Logarithms\n",
    "\n",
    "Exponential growth curves appear in economics, physics, and other sciences. Python has a built-in exponentiation operator (“\\*\\*”), but pow() can be useful when you need to pass a callable function as an argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  2.0 ** 3.000 =  8.000\n",
      "  2.1 ** 3.200 = 10.742\n",
      "  1.0 ** 5.000 =  1.000\n",
      "  2.0 ** 0.000 =  1.000\n",
      "  2.0 **   nan =    nan\n",
      "  9.0 ** 0.500 =  3.000\n",
      " 27.0 ** 0.333 =  3.000\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "for x, y in [\n",
    "    # Typical uses\n",
    "    (2, 3),\n",
    "    (2.1, 3.2),\n",
    "\n",
    "    # Always 1\n",
    "    (1.0, 5),\n",
    "    (2.0, 0),\n",
    "\n",
    "    # Not-a-number\n",
    "    (2, float('nan')),\n",
    "\n",
    "    # Roots\n",
    "    (9.0, 0.5),\n",
    "    (27.0, 1.0/3),\n",
    "    ]:\n",
    "    print('{:5.1f} ** {:5.3f} = {:6.3f}'.format(x, y, math.pow(x, y)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Raising 1 to any power always returns 1.0, as does raising any value to a power of 0.0. Most operations on the not-a-number value nan return nan. If the exponent is less than 1, pow() computes a root."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since square roots (exponent of 1/2) are used so frequently, there is a separate function for computing them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.0\n",
      "1.7320508075688772\n",
      "Cannot compute sqrt(-1): math domain error\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "print(math.sqrt(9.0))\n",
    "print(math.sqrt(3))\n",
    "try:\n",
    "    print(math.sqrt(-1))\n",
    "except ValueError as err:\n",
    "    print('Cannot compute sqrt(-1):', err)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Computing the square roots of negative numbers requires complex numbers, which are not handled by math. Any attempt to calculate a square root of a negative value results in a ValueError."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are two variations of **log()**. Given floating point representation and rounding errors the computed value produced by **log(x, b)** has limited accuracy, especially for some bases. **log10()** computes **log(x, 10)**, using a more accurate algorithm than **log()**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i        x              accurate             inaccurate       mismatch\n",
      "--  ------------  --------------------  --------------------  --------\n",
      " 0           1.0  0.000000000000000000  0.000000000000000000       \n",
      " 1          10.0  1.000000000000000000  1.000000000000000000       \n",
      " 2         100.0  2.000000000000000000  2.000000000000000000       \n",
      " 3        1000.0  3.000000000000000000  2.999999999999999556    *  \n",
      " 4       10000.0  4.000000000000000000  4.000000000000000000       \n",
      " 5      100000.0  5.000000000000000000  5.000000000000000000       \n",
      " 6     1000000.0  6.000000000000000000  5.999999999999999112    *  \n",
      " 7    10000000.0  7.000000000000000000  7.000000000000000000       \n",
      " 8   100000000.0  8.000000000000000000  8.000000000000000000       \n",
      " 9  1000000000.0  9.000000000000000000  8.999999999999998224    *  \n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "print('{:2}  {:^12}  {:^20}  {:^20}  {:8}'.format('i', 'x', 'accurate', 'inaccurate', 'mismatch'))\n",
    "print('{:-^2}  {:-^12}  {:-^20}  {:-^20}  {:-^8}'.format('', '', '', '', ''))\n",
    "\n",
    "for i in range(0, 10):\n",
    "    x = math.pow(10, i)\n",
    "    accurate = math.log10(x)\n",
    "    inaccurate = math.log(x, 10)\n",
    "    match = '' if int(inaccurate) == i else '*'\n",
    "    print('{:2d}  {:12.1f}  {:20.18f}  {:20.18f}  {:^5}'.format(i, x, accurate, inaccurate, match))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The lines in the output with trailing * highlight the inaccurate values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As with other special-case functions, the function **exp()** uses an algorithm that produces more accurate results than the general-purpose equivalent math.pow(math.e, x)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7.38905609893064951876\n",
      "7.38905609893064951876\n",
      "7.38905609893065040694\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "x = 2\n",
    "\n",
    "fmt = '%.20f'\n",
    "print(fmt % (math.e ** 2))\n",
    "print(fmt % math.pow(math.e, 2))\n",
    "print(fmt % math.exp(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For more information about other mathematical functions, including trigonometric ones, we refer to <a href=\"https://pymotw.com/2/math/\">https://pymotw.com/2/math/</a>\n",
    "\n",
    "The python references can be found at <a href=\"https://docs.python.org/2/library/math.html\">https://docs.python.org/2/library/math.html</a>"
   ]
  }
 ],
 "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}