18. Math and CMath.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*********************************************************************************************************\n",
    "# A Tour of Python 3  \n",
    "version 1.0.1  \n",
    "Authors: Phil Pfeiffer, Zack Bunch, and Feyisayo Oyeniyi  \n",
    "East Tennessee State University  \n",
    "Last updated June 2021  \n",
    "\n",
    "Chapter 18: author Brandon Beaudry; ed. Phil Pfeiffer  \n",
    "*********************************************************************************************************"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 18. Math and CMath  \n",
    " 18.1 [Overview](#MaCM-Overview)  \n",
    " 18.2 [Math Module](#MaCM-Math-Module)  \n",
    " &ensp; 18.2.1 [Basic Functions](#MaCM-Basic-Functions)  \n",
    " &ensp; 18.2.2 [Constants](#MaCM-Constants)  \n",
    " &ensp; 18.2.3 [Trigonometry](#MaCM-Trigonometry)  \n",
    " &ensp; 18.2.4 [Combinations and Permutations](#MaCM-Combinations-and-Permutations)  \n",
    " &ensp; 18.2.5 [Functions with Multiple Values](#MaCM-Functions-with-Multiple-Values)  \n",
    " 18.3 [CMath Module](#MaCM-CMath-Module)  \n",
    " &ensp; 18.3.1 [Basic Complex Functions](#MaCM-Basic-Complex-Functions)  \n",
    " &ensp; 18.3.2 [Complex Constants](#MaCM-Complex-Constants)  \n",
    " &ensp; 18.3.3 [Complex Trigonometry](#MaCM-Complex-Trigonometry)  \n",
    " 18.4 [Interactivity](#MaCM-Interactivity)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 18.1  Overview <a name='MaCM-Overview'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python's `math` and `cmath` modules are Python interfaces to C-language-based math routines. \n",
    "- `math` functions provide operations on integer and floating point, most of which have no corresponding Python operators. \n",
    "  `math` also provides access to algebraic and trigonometric functions, as well as other functions on real numbers. \n",
    "- `cmath` functions, as a rule, are extensions of `math` library functions that operate on complex as well as real numbers. \n",
    "  `cmath` also provides access to polar functions; these, however, are beyond the scope of this module. \n",
    "\n",
    "`math` and `cmath` are part of Python's standard library.  To use them, import them, as follows:\n",
    "- `import math`\n",
    "- `import cmath`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 18.2  Math Module <a name='MaCM-Math-Module'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 18.2.1 Basic Functions <a name='MaCM-Basic-Functions'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Tour's unit on [Values](./2.%20%20Values.ipynb#Values) covers `math` functions `floor` and `log10`. Other `math` library basic functions include\n",
    "- `ceil`, which returns the smallest integer greater than or equal to its argument.\n",
    "- `exp`, which returns e raised to the power of its argument.\n",
    "- `sqrt`, which returns the square root of its argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 18.2.1 demonstration of basic math library functions:\n",
    "#\n",
    "# math - math library for floating point arithmetic\n",
    "#   math.floor - return the largest integer equal to or smaller than the argument\n",
    "#   math.ceil - return the smallest integer equal to or greater than the argument\n",
    "#   math.log10 - return the argument’s logarithm, base 10\n",
    "#   math.exp - return e to the power of the argument\n",
    "#   math.sqrt - return the square root of the argument\n",
    "\n",
    "import math\n",
    "\n",
    "print(\"floor of 4.8 is\", math.floor(4.8))\n",
    "print(\"ceiling of 6.2 is\", math.ceil(6.2))\n",
    "print(\"log 10 of 96 is\", math.log10(96))\n",
    "print(\"log 10 of 100 is\", math.log10(100))\n",
    "print(\"e cubed is\", math.exp(3))\n",
    "print(\"the square root of 9 is\", math.sqrt(9))\n",
    "print(\"the square root of 7 is\", math.sqrt(7))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 18.2.1.1:**\n\n",
    "</span>",
    "<span style='color:navy' >",
    "In the following code cell, ",
    "replicate the function of `exp` without using `exp` itself.",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 18.2.2 Constants <a name='MaCM-Constants'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `math` module provides the following constants:\n",
    "- `pi`, the value 3.14159...\n",
    "- `e`, the value 2.718281...\n",
    "- `tau`, the value 2&ast;pi.\n",
    "- `inf`, the representation of infinity.\n",
    "- `nan`, the representation of not a number.\n",
    "\n",
    "`math` identifier functions include\n",
    "- `isfinite`, which returns True iff the numerical argument is a finite number\n",
    "- `isinf`, which returns True iff the numerical argument is infinite\n",
    "- `isnan`, which returns True iff the numerical argument is not a number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 18.2.2 demonstration of constants and identifiers:\n",
    "#\n",
    "# math - math library for floating point arithmetic\n",
    "#   math.isfinite - boolean function for determining if the argument is finite\n",
    "#   math.isinf - boolean function for determining if the argument is infinite\n",
    "#   math.isnan - boolean function for determining if the argument is not a number\n",
    "#   math.inf - representation of an infinite value\n",
    "#   math.nan - representation of not a number\n",
    "\n",
    "import math\n",
    "\n",
    "print(\"4.8 is %s\" % ('finite' if math.isfinite(4.8) else 'not finite'))\n",
    "print(\"math.inf is %s\" % ('finite' if math.isfinite(math.inf) else 'not finite'))\n",
    "print(\"math.nan is %s\" % ('finite' if math.isfinite(math.nan) else 'not finite'), \"\\n\")\n",
    "\n",
    "print(\"4.8 is %s\" % ('infinite' if math.isinf(4.8) else 'not infinite'))\n",
    "print(\"math.inf is %s\" % ('infinite' if math.isinf(math.inf) else 'not infinite'), \"\\n\")\n",
    "\n",
    "print(\"4.8 is %s\" % ('not a number' if math.isnan(4.8) else 'a number'))\n",
    "print(\"math.inf is %s\" % ('not a number' if math.isnan(math.inf) else 'a number'))\n",
    "print(\"math.nan is %s\" % ('not a number' if math.isnan(math.nan) else 'not nan'), \"\\n\")\n",
    "\n",
    "try:\n",
    "    print(\"'a' is %s\" % ('not a number' if math.isnan('a') else 'not nan'))\n",
    "except TypeError:\n",
    "    print(\"'a' is not compatible with math functions\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 18.2.2.1:**\n\n",
    "</span>",
    "<span style='color:navy' >",
    "In the following markdown cell, ",
    " explain why `isnan` raises an error when 'a' is the argument, despite 'a' clearly not being a number.",
    "</span>\n",
    "***\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 18.2.3 Trigonometry <a name='MaCM-Trigonometry'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`math` module trigonometric functions include `sin`, `cos`, and `tan`:\n",
    "- `sin`, the sine of the argument, returns in radians.\n",
    "- `cos`, the cosine of the argument, returns in radians.\n",
    "- `tan`, the tangent of the argument, returns in radians."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 18.2.3.a  demonstration of trigonometric functions:\n",
    "#\n",
    "# math - math library for floating point arithmetic\n",
    "#   math.sin - the sine of the argument\n",
    "#   math.cos - the cosine of the argument\n",
    "#   math.tan - the tangent of the argument\n",
    "#   math.pi - the value pi\n",
    "\n",
    "import math\n",
    "\n",
    "print(\"sine of 1.1 is\", math.sin(1.1))\n",
    "print(\"sine of pi is\", math.sin(math.pi), \"\\n\")\n",
    "\n",
    "print(\"cosine of 3.9 is\", math.cos(3.9))\n",
    "print(\"cosine of pi is\", math.cos(math.pi), \"\\n\")\n",
    "\n",
    "print(\"tangent of 4.2 is\", math.tan(4.2))\n",
    "print(\"tangent of pi is\", math.tan(math.pi))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 18.2.3.1:**\n\n",
    "</span>",
    "<span style='color:navy' >",
    "In the following code cell, ",
    "demonstrate the following:</span>\n",
    "- <span style='color:navy' >$cos^{2}x$ + $sin^{2}x$ = $1$</span>\n",
    "- <span style='color:navy' >$cosx$ / $sinx$ - $tanx$ = $0$</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`math` also supports inverse trig functions, including\n",
    "- `asin`, which returns the inverse sine $(sin^{-1})$ of its argument; outputs range from -π/2 to <= π/2 inclusive\n",
    "- `acos`, which returns the inverse cosine $(cos^{-1})$ of its argument; outputs range from 0 to π inclusive\n",
    "- `atan`, which returns the inverse tangent $(tan^{-1})$ of its argument; outputs range from -π/2 to <= π/2 inclusive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 18.2.3.b  demonstration of inverse trigonometric functions:\n",
    "#\n",
    "# math - math library for floating point arithmetic\n",
    "#   math.asin - the arc sine of the argument\n",
    "#   math.acos - the arc cosine of the argument\n",
    "#   math.atan - the arc tangent of the argument\n",
    "\n",
    "import math\n",
    "\n",
    "print(\"inverse sine of -0.6 is\", math.asin(-0.6))\n",
    "print(\"inverse sine of sin(1) is\", math.asin(math.sin(1)), \"\\n\")\n",
    "\n",
    "print(\"inverse cosine of 0.1 is\", math.acos(0.1))\n",
    "print(\"inverse cosine of cos(0.6) is\", math.acos(math.cos(0.6)), \"\\n\")\n",
    "\n",
    "print(\"inverse tangent of 10000 is\", math.atan(10000))\n",
    "print(\"inverse tangent of tan(1.5) is\", math.atan(math.tan(1.5)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 18.2.3.c  demonstration of erroneous and nondefault ranges for inverse trig functions:\n",
    "#\n",
    "# math - math library for floating point arithmetic\n",
    "#   math.asin - the arc sine of the argument\n",
    "#   math.acos - the arc cosine of the argument\n",
    "#   math.atan - the arc tangent of the argument\n",
    "\n",
    "import math\n",
    "\n",
    "try:\n",
    "    print(\"inverse sine of -2 is\", math.asin(-2), \"\\n\")\n",
    "except ValueError:\n",
    "    print(\"-2 is outside the allowed range of inverse sine\", \"\\n\")\n",
    "\n",
    "try:\n",
    "    print(\"inverse cosine of 4 is\", math.acos(4), \"\\n\")\n",
    "except ValueError:\n",
    "    print(\"4 is outside the allowed range of inverse cosine\", \"\\n\")\n",
    "\n",
    "print(\"inverse sine of sin(2) is\", math.asin(math.sin(2)))\n",
    "print(\"inverse cosine of cos(4.1) is\", math.acos(math.cos(4.1)))\n",
    "print(\"inverse tangent of tan(1.6) is\", math.atan(math.tan(1.6)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 18.2.3.2:**\n\n",
    "</span>",
    "<span style='color:navy' >",
    "In the following code cell, ",
    "compute $sin(asin(x))$, $cos(acos(x))$, and $tan(atan(x))$ for an $x$ within each inverse trig function's range of valid values. ",
    "Using comments, account for your results.",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 18.2.4 Combinations and Permutations <a name='MaCM-Combinations-and-Permutations'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Combinations and permutations are computed using factorials. ",
    "The factorial of x, ordinarily denoted as x!, is defined as 1 for 0!; ",
    "otherwise, x! equals as the product of all integers between 1 and x inclusive. \n",
    "\n",
    "To use `math` to compute x!, write `math.factorial(x)`.\n",
    "\n",
    "`math` also provides functions that compute counts of permutations and combinations, as follows:\n",
    "- `comb(n, k)` returns the number of combinations of k items from n distinct items, calculated as n! / (k! * (n - k)!)\n",
    "- `perm(n, k)` returns the number of permutations of k items from n distinct items, calculated n! / (n - k)!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 18.2.4 demonstration of factorial, combination, and permutation:\n",
    "#\n",
    "# math - math library for floating point arithmetic\n",
    "#   math.factorial - the function for factorial\n",
    "#   math.comb - two argument function for combinations\n",
    "#   math.perm - two argument function for permutations\n",
    "\n",
    "import math\n",
    "\n",
    "print(\"7 factorial is\", math.factorial(7))\n",
    "print(\"there are\", math.comb(7,2), \"ways to choose 2 items from 7 total items\")\n",
    "print(\"there are\", math.perm(6,3), \"ways to order 3 items from 6 total items\")\n",
    "print(\"there are\", math.comb(2,7), \"ways to choose 7 items from 2 total items\")\n",
    "print(\"there are\", math.perm(3,6), \"ways to order 6 items from 3 total items\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 18.2.4.1:**\n\n",
    "</span>",
    "<span style='color:navy' >",
    "When k > n, the result is 0, despite the fact that negative factorials are technically undefined. ",
    "In the following markdown cell, ",
    "explain the logic for these results. You may use an example.  ",
    "*Hint*: Try counting how many combinations would be in (A, B, C) if you were to pick 2 elements, and then try with 4.",
    "</span>\n",
    "***\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 18.2.5 Functions with Multiple Values <a name='MaCM-Functions-with-Multiple-Values'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Certain `math` functions accept collections as arguments.\n",
    "- `fsum` sums a tuple of values, more accurate than `sum`.\n",
    "- `prod` multiples a tuple of values together.\n",
    "\n",
    "This includes collection-based functions that require integer arguments:\n",
    "- `gcd`, greatest common divisor, the largest value that evenly divides all of the arguments.\n",
    "- `lcm`, least common multiple, the smallest value that is a multiple of all the arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 18.2.5 demonstration of multiple value functions:\n",
    "#\n",
    "# math - math library for floating point arithmetic\n",
    "#   math.fsum - more precise floating point addition\n",
    "#   math.prod - multiplication of multiple elements\n",
    "#   math.gcd - greatest common divisor\n",
    "#   math.lcm - least common multiple\n",
    "\n",
    "import math\n",
    "\n",
    "print(\"fsum of 7, 0.6, 0.1, and 2.5 is\", math.fsum((7, 0.6, 0.1, 2.5)))\n",
    "print(\"prod of 7, 6, 1.4, and 2 is\", math.prod((7, 6, 1.4, 2)))\n",
    "print(\"the greatest common divisor of 20, 72, 28, and 44 is\", math.gcd(20, 72, 28, 44))\n",
    "print(\"the least common multiple of 3, 4, 5, and 7 is\", math.lcm(3, 4, 5, 7))\n",
    "\n",
    "value = 0.1\n",
    "vector = [value] * 10\n",
    "fsumval = math.fsum(vector) \n",
    "sumval = sum(vector) \n",
    "comparison = ('' if sumval==fsumval else 'not') + ' equal' \n",
    "print(f\"The sum ({sumval}) and math.fsum ({fsumval}) of {len(vector)} instances of {value} are {comparison}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 18.3  CMath Module <a name='MaCM-CMath-Module'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 18.3.1 Basic Complex Functions <a name='MaCM-Basic-Complex-Functions'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`cmath` shares function names with `math`, including these:\n",
    "- `exp`, which returns e raised to the power of its argument, which can be a complex number.\n",
    "- `log10`, which returns logarithm base 10 of its argument, even if the argument is negative.\n",
    "- `sqrt`, which returns the square root of its argument, even if the argument is negative."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 18.3.1 demonstration of complex functions:\n",
    "#\n",
    "# cmath - complex math library for complex arithmetic\n",
    "#   cmath.exp - complex exponentiation of e to the argument\n",
    "#   cmath.log10 - complex logarithm of base 10 of the argument\n",
    "#   cmath.sqrt - complex square root of the argument\n",
    "#   cmath.isclose - determine if a result is within roundoff error of another value\n",
    "\n",
    "import cmath\n",
    "\n",
    "print(\"e to the power of 2 is\", cmath.exp(2))\n",
    "print(\"e to the power of 3j is\", cmath.exp(3j))\n",
    "print(\"e to the power of 4 + 1j is\", cmath.exp(4 + 1j))\n",
    "epij = cmath.exp(cmath.pi * (0+1j))    # illustrating Euler's formula\n",
    "print(\"e to the power of pi*j is\", epij, ', or roughly -1' if cmath.isclose(epij,-1) else '', \"\\n\")\n",
    "\n",
    "print(\"log 10 of 7 is\", cmath.log10(7))\n",
    "print(\"log 10 of -3 is\", cmath.log10(-3))\n",
    "print(\"log 10 of 9j is\", cmath.log10(9j))\n",
    "print(\"log 10 of 2 + 7j is\", cmath.log10(2 + 7j), \"\\n\")\n",
    "\n",
    "print(\"the square root of 3 is\", cmath.sqrt(3))\n",
    "print(\"the square root of -6 is\", cmath.sqrt(-6))\n",
    "print(\"the square root of 7j is\", cmath.sqrt(7j))\n",
    "print(\"the square root of 9 + 6j is\", cmath.sqrt(9 + 6j))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 18.3.1.1:**\n\n",
    "</span>",
    "<span style='color:navy' >",
    "In the following code cell, ",
    "show what happens when a square root of a negative imaginary number is taken.",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 18.3.2 Complex Constants<a name='MaCM-Complex-Constants'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`cmath` shares the same constants as `math`, being `pi`, `e`, `tau`, `inf`, and `nan`. In addition, `cmath` has two additional constants:\n",
    "- `infj`, a complex number with 0 as the real part and `inf` as the imaginary part.\n",
    "- `nanj`, a complex number with 0 as the real part and `nan` as the imaginary part.\n",
    "\n",
    "The functions `isfinite`, `isinf`, and `isnan` are also shared, but accept complex values. The differences are as follows:\n",
    "- `isfinite`, the real and the imaginary part have to be finite, otherwise False is returned.\n",
    "- `isinf`, either the real or the imaginary part have to be infinite to return True.\n",
    "- `isnan`, either the real or the imaginary part have to be not a number to return True."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 18.3.2 demonstration of complex constants:\n",
    "#\n",
    "# cmath - complex math library for complex arithmetic\n",
    "#   cmath.isfinite - complex check for determining if the argument is finite\n",
    "#   cmath.isinf - complex check for determining if the argument is infinite\n",
    "#   cmath.isnan - complex check for determining if the argument is not a number\n",
    "#   cmath.inf - representation of a real infinite number\n",
    "#   cmath.infj - representation of an imaginary infinite number\n",
    "#   cmath.nan - representation of a real nan\n",
    "#   cmath.nanj- representation of an imaginary nan\n",
    "\n",
    "import cmath\n",
    "\n",
    "print(\"2 is %s\" % ('finite' if cmath.isfinite(2) else 'not finite'))\n",
    "print(\"9j is %s\" % ('finite' if cmath.isfinite(9j) else 'not finite'))\n",
    "print(\"7 + 8j is %s\" % ('finite' if cmath.isfinite(7 + 8j) else 'not finite'))\n",
    "\n",
    "print()\n",
    "\n",
    "print(\"cmath.inf + 8j is %sfinite\" % ('' if cmath.isfinite(cmath.inf + 8j) else 'in'))\n",
    "print(\"2 + cmath.infj is %sfinite\" % ('' if cmath.isfinite(2 + cmath.infj) else 'in'))\n",
    "print(\"cmath.nan + 8j is %sfinite\" % ('' if cmath.isfinite(cmath.nan + 8j) else 'in'))\n",
    "print(\"4 + cmath.nanj is %sfinite\" % ('' if cmath.isfinite(4 + cmath.nanj) else 'in'), \"\\n\")\n",
    "\n",
    "print(\"2 is %sfinite\"      % ('in' if cmath.isinf(2) else ''))\n",
    "print(\"9j is %sfinite\"     % ('in' if cmath.isinf(9j) else ''))\n",
    "print(\"2 + 8j is %sfinite\" % ('in' if cmath.isinf(2 + 8j) else ''), \"\\n\")\n",
    "\n",
    "print(\"cmath.inf + 3j is %sfinite\" % ('in' if cmath.isinf(cmath.inf + 3j) else ''))\n",
    "print(\"2 + cmath.infj is %sfinite\" % ('in' if cmath.isinf(2 + cmath.infj) else ''), \"\\n\")\n",
    "\n",
    "print(\"12 is %snumeric\" % ('non-' if cmath.isnan(12) else ''))\n",
    "print(\"6j is %snumeric\" % ('non-' if cmath.isnan(6j) else ''))\n",
    "print(\"7 + 5j is %snumeric\" % ('non-' if cmath.isnan(7 + 5j) else ''), \"\\n\")\n",
    "\n",
    "print(\"cmath.nan + 1j is %snumeric\"  % ('non-' if cmath.isnan(cmath.nan + 1j) else ''))\n",
    "print(\"11 + cmath.nanj is %snumeric\" % ('non-' if cmath.isnan(11 + cmath.nanj) else ''))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 18.3.3 Complex Trigonometry <a name='MaCM-Complex-Trigonometry'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `cmath` module shares `sin`, `cos`, `tan`, `asin`, `acos`, and `atan` with `math`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 18.3.3.a  demonstration of complex trigonometric functions:\n",
    "#\n",
    "# cmath - complex math library for complex arithmetic\n",
    "#   cmath.sin - complex calculation of sine\n",
    "#   cmath.cos - complex calculation of cosine\n",
    "#   cmath.tan - complex calculation of tangent\n",
    "\n",
    "import cmath\n",
    "\n",
    "print(\"sine of 1 is\", cmath.sin(1))\n",
    "print(\"sine of 5j is\", cmath.sin(5j))\n",
    "print(\"sine of 3 + 5j is\", cmath.sin(3 + 5j), \"\\n\")\n",
    "\n",
    "print(\"cosine of 4 is\", cmath.cos(4))\n",
    "print(\"cosine of 7j is\", cmath.cos(7j))\n",
    "print(\"cosine of 2 + 5j is\", cmath.cos(2 + 5j), \"\\n\")\n",
    "\n",
    "print(\"tangent of 6 is\", cmath.tan(6))\n",
    "print(\"tangent of 9j is\", cmath.tan(9j))\n",
    "print(\"tangent of 1 + 8j is\", cmath.tan(1 + 8j))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 18.3.3.1:**\n\n",
    "</span>",
    "<span style='color:navy' >",
    "In the following code cell, ",
    "demonstrate the following with imaginary numbers and complex numbers:</span>\n",
    "- <span style='color:navy' >$cos^{2}x$ + $sin^{2}x$ = $1$</span>\n",
    "- <span style='color:navy' >$cosx$ / $sinx$ - $tanx$ = $0$</span>\n",
    "\n",
    "<span style='color:navy' >",
    "Do these properties still hold true for imaginary numbers? How about complex numbers? Comment your answers.",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Besides allowing complex numbers, `cmath`'s inverse  functions differ from `math`'s in the following ways:\n",
    "- `asin`, if the argument is `-1` <= x <= `1`, the output will be real.\n",
    "- `acos`, if the argument is `-1` <= x <= `1`, the output will be real.\n",
    "- `atan`, if the argument is `-1j` < x < `1j`, the output will be imaginary, and if the argument = `1j` or `-1j`, an error will be raised.\n",
    "\n",
    "This assumes that the argument is real for `asin` and `acos`, and imaginary for `atan`. If the argument is complex, these bounds do not apply. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 18.3.3.b  demonstration of inverse complex trigonometric functions, in-range values\n",
    "#\n",
    "# cmath - complex math library for complex arithmetic\n",
    "#   cmath.asin - complex calculation of arc sine\n",
    "#   cmath.acos - complex calculation of arc cosine\n",
    "#   cmath.atan - complex calculation of arc tangent\n",
    "\n",
    "import cmath\n",
    "\n",
    "print(\"inverse sine of 1 is\", cmath.asin(1))\n",
    "print(\"inverse sine of 6j is\", cmath.asin(6j))\n",
    "print(\"inverse sine of 0.5 + 2j is\", cmath.asin(0.5 + 2j), \"\\n\")\n",
    "\n",
    "print(\"inverse cosine of 1 is\", cmath.acos(1))\n",
    "print(\"inverse cosine of 0.1j is\", cmath.acos(0.1j))\n",
    "print(\"inverse cosine of 1.1 + 0.4j is\", cmath.acos(1.1 + 0.4j), \"\\n\")\n",
    "\n",
    "print(\"inverse tangent of 0.4 is\", cmath.atan(0.4))\n",
    "print(\"inverse tangent of 0.4j is\", cmath.atan(0.4j))\n",
    "print(\"inverse tangent of 9 + 1j is\", cmath.atan(9 + 1j), \"\\n\")\n",
    "\n",
    "print(\"inverse sine of sin(1.3) is\", cmath.asin(cmath.sin(1.3)))\n",
    "print(\"inverse sine of sin(9j is\", cmath.asin(cmath.sin(9j)))\n",
    "print(\"inverse sine of sin(1 + 7j) is\", cmath.asin(cmath.sin(1 + 7j)), \"\\n\")\n",
    "\n",
    "print(\"inverse cosine of cos(2.4) is\", cmath.acos(cmath.cos(2.4)))\n",
    "print(\"inverse cosine of cos(7j) is\", cmath.acos(cmath.cos(7j)))\n",
    "print(\"inverse cosine of cos(3 + 7j) is\", cmath.acos(cmath.cos(3 + 7j)), \"\\n\")\n",
    "\n",
    "print(\"inverse tangent of tan(0.7) is\", cmath.atan(cmath.tan(0.7)))\n",
    "print(\"inverse tangent of tan(8j) is\", cmath.atan(cmath.tan(8j)))\n",
    "print(\"inverse tangent of tan(0.6 + 9j) is\", cmath.atan(cmath.tan(0.6 + 9j)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 18.3.3.c  demonstration of inverse complex trigonometric functions, out-of-range values\n",
    "#\n",
    "# cmath - complex math library for complex arithmetic\n",
    "#   cmath.asin - complex calculation of arc sine\n",
    "#   cmath.acos - complex calculation of arc cosine\n",
    "#   cmath.atan - complex calculation of arc tangent\n",
    "\n",
    "import cmath\n",
    "\n",
    "print(\"inverse sine of 3 is\", cmath.asin(3))\n",
    "print(\"inverse cosine of 3 is\", cmath.acos(3))\n",
    "\n",
    "try:\n",
    "  print(\"inverse tangent of 1j is\", cmath.atan(1j))\n",
    "except ValueError:\n",
    "  print(\"1j is outside the allowed range of inverse tangent\")\n",
    "\n",
    "print(\"inverse tangent of 2j is\", cmath.atan(2j), \"\\n\")\n",
    "\n",
    "print(\"inverse sine of sin(2) is\", cmath.asin(cmath.sin(2)))\n",
    "print(\"inverse sine of sin(3 + 11j) is\", cmath.asin(cmath.sin(3 + 11j)))\n",
    "\n",
    "print()\n",
    "\n",
    "print(\"inverse cosine of cos(4) is\", cmath.acos(cmath.cos(4)))\n",
    "print(\"inverse cosine of cos(11 + 5j) is\", cmath.acos(cmath.cos(11 + 5j)))\n",
    "print(\"inverse tangent of tan(4)is\", cmath.atan(cmath.tan(4)), \"\\n\")\n",
    "\n",
    "try:\n",
    "  print(\"inverse tangent of tan(68j) is\", cmath.atan(cmath.tan(68j)), \"\\n\")\n",
    "except ValueError:\n",
    "  print(\"tangent of 68j is outside the allowed range of inverse tangent\", \"\\n\")\n",
    "\n",
    "print(\"inverse tangent of tan(21 + 9j) is\", cmath.atan(cmath.tan(21 + 9j)))\n",
    "print(\"inverse tangent of tan(1.1 + 55j) is\", cmath.atan(cmath.tan(1.1 + 55j)))\n",
    "print(\"inverse tangent of tan(30.5 + 55j) is\", cmath.atan(cmath.tan(30.5 + 55j)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 18.3.3.2:**\n\n",
    "</span>",
    "<span style='color:navy' >",
    "In the following code cell, ",
    "evaluate $sin(asin(x))$, $cos(acos(x))$, and $tan(atan(x))$ with imaginary numbers and complex numbers. ",
    " Use comments to account for your results.",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 18.4  Interactivity <a name='MaCM-Interactivity'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Despite `math` and `cmath` being different modules, `math` constants and functions can be used with `cmath` functions,\n",
    " and some `cmath` constants can be used with `math` functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 18.4.a  demonstration of import order:\n",
    "#\n",
    "# cmath - complex math library for complex arithmetic\n",
    "#   cmath.sqrt - complex square root of the argument\n",
    "# math - math library for floating point arithmetic\n",
    "#   math.sqrt - return the square root of the argument\n",
    "\n",
    "# math imported after cmath\n",
    "import cmath\n",
    "from cmath import sqrt\n",
    "import math\n",
    "from math import sqrt\n",
    "\n",
    "try:\n",
    "    print(\"the square root of -3 is\", sqrt(-3))\n",
    "except ValueError:\n",
    "    print(\"-3 is outside the allowed range of square root\")\n",
    "\n",
    "# cmath imported after math\n",
    "import math\n",
    "from math import sqrt\n",
    "import cmath\n",
    "from cmath import sqrt\n",
    "\n",
    "try:\n",
    "    print(\"the square root of -3 is\", sqrt(-3))\n",
    "except ValueError:\n",
    "    print(\"-3 is outside the allowed range of square root\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As shown by this example, the order in which `math` and `cmath` are imported determines which function will be used. \n",
    "Fully qualifying a function's name with its source module will clarify which function is in use. \n",
    "If both modules are imported, import only those functions from each that are not shared, and declare the module for shared functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 18.4.b demonstration of shared functionality:\n",
    "#\n",
    "# cmath - complex math library for complex arithmetic\n",
    "# math - math library for floating point arithmetic\n",
    "\n",
    "import cmath\n",
    "import math\n",
    "\n",
    "print('math.pi and cmath.pi %s' % ('are the same' if math.pi == cmath.pi else 'differ'))\n",
    "print('math.e and cmath.e %s' % ('are the same' if math.e == cmath.e else 'differ'))\n",
    "print('math.tau and cmath.tau %s' % ('are the same' if math.tau == cmath.tau else 'differ'))\n",
    "\n",
    "print('math.inf and cmath.inf %s' % ('are the same' if math.inf == cmath.inf else 'differ'))\n",
    "print('math.isinf and cmath.isinf %s' % ('are the same' if math.isinf(math.inf) == cmath.isinf(cmath.inf) else 'differ'), \"\\n\")\n",
    "\n",
    "print('math.nan and math.nan %s' % ('are the same' if math.nan == math.nan else 'differ'))\n",
    "print('math.nan and cmath.nan %s' % ('are the same' if math.nan == cmath.nan else 'differ'))\n",
    "print('cmath.nan and cmath.nan %s' % ('are the same' if cmath.nan == cmath.nan else 'differ'), \"\\n\")\n",
    "\n",
    "print('math.isnan and math.isnan %s' % ('are the same' if math.isnan(math.nan) == math.isnan(math.nan) else 'differ'))\n",
    "print('math.isnan and cmath.isnan %s' % ('are the same' if math.isnan(math.nan) == cmath.isnan(cmath.nan) else 'differ'))\n",
    "print('cmath.isnan and cmath.isnan %s' % ('are the same' if cmath.isnan(cmath.nan) == cmath.isnan(cmath.nan) else 'differ'), \"\\n\")\n",
    "\n",
    "print('math.inf can%s be passed to cmath.isinf' % ('' if cmath.isinf(math.inf) else '\\'t'))\n",
    "print('cmath.inf can%s be passed to math.isinf' % ('' if math.isinf(cmath.inf) else '\\'t'), \"\\n\")\n",
    "\n",
    "print('math.nan %s be passed to cmath.isnan' % ('can' if cmath.isnan(math.nan) else '\\'t'))\n",
    "print('cmath.nan %s be passed to math.isnan' % ('can' if math.isnan(cmath.nan) else '\\'t'), \"\\n\")\n",
    "try:\n",
    "    print('cmath.infj %s be passed to math.isinf' % ('can' if math.isinf(cmath.infj) else '\\'t'))\n",
    "except TypeError:\n",
    "    print('cmath.infj is incompatible with math functions')\n",
    "try:\n",
    "    print('cmath.nanj %s be passed to math.isnan' % ('can' if math.isnan(cmath.nanj) else '\\'t'))\n",
    "except TypeError:\n",
    "    print('cmath.nanj is incompatible with math functions')\n",
    "\n",
    "compVar = (2 + 0j)\n",
    "print(\"\\nthe value of compVar is\", compVar)\n",
    "try:\n",
    "    print(\"compVar is %sfinite\" % ('' if math.isfinite(compVar) else 'in'))\n",
    "except TypeError:\n",
    "    print('complex values are incompatible with math functions')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 18.4.1:**\n\n",
    "</span>",
    "<span style='color:navy' >",
    "In the following markdown cell, ",
    "explain why compVar cannot be converted to float, despite its imaginary part being 0.",
    "</span>\n",
    "***\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  }
 ],
 "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.9.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}