{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Floating-point arithmetic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arbitrary real numbers on computers are typically approximated by a set $\\mathbb{F}$ of [floating-point numbers](https://en.wikipedia.org/wiki/Floating_point).  Basically, you should think of these as numbers in \"scientific notation:\"\n",
    "$$\n",
    "\\pm\\underbrace{d_0.d_1 d_2 d_3 ... d_{p-1}}_\\textrm{significand} \\times \\beta^e, \\;\\; 0 \\le d_k < \\beta\n",
    "$$\n",
    "where the $d_k$ are digits of the **significand** in some base $\\beta$ (typically $\\beta=2$), the number of digits $p$ is the **precision**, and $e$ is the **exponent**.  That is, the computer actually stores a tuple (*sign*,*significand*,*exponent*), representing *a fixed number of significant digits over a wide range of magnitudes*.\n",
    "\n",
    "Our goal is to eventually understand the set $\\mathbb{F}$, how *rounding* occurs when you operate on floating-point values, how rounding errors *accumulate*, and how you analyze the accuracy of numerical algorithms.  In this notebook, however, we will just perform a few informal experiments in [Julia](http://julialang.org/) to get a feel for things."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Entering and working with floating-point values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.5e7"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1.5e7 # a floating-point value 1.5 × 10⁷"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.02040816326530612"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 1/49 # division of two integers produces a floating-point value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since $1/49 \\notin \\mathbb{F}$, however, $x$ is actually a *rounded* version of $1/49$, and multiplying it by $49$ will yield something that is close to but *not quite equal to 1*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9999999999999999"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x * 49"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.1102230246251565e-16"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 - x * 49"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is about $10^{-16}$ because the default floating-point precision in Julia is **double precision**, with $p=53$ bits of significand ($\\beta=2$).   Double precision, called the `Float64` type in Julia (64 bits overall), is used because it is **fast**: double-precision floating-point arithmetic is implemented by dedicated circuits in your CPU.\n",
    "\n",
    "The precision can also be described by $\\epsilon_\\mathrm{machine} = 2^{1-p}$, which bounds the *relative error* between any element of $\\mathbb{R}$ and the closest element of $\\mathbb{F}$.  It is returned by `eps()` in Julia:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2.220446049250313e-16, 2.220446049250313e-16, 2.220446049250313e-16, 2.220446049250313e-16)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2.0^-52, eps(), eps(1.0), eps(Float64) # these are all the same thing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* An error by 1 in the **last significant digit** is called a **1 [ulp](https://en.wikipedia.org/wiki/Unit_in_the_last_place)** (**u**nit in the **l**ast **p**lace) error, equivalent to a relative error of $\\epsilon_\\mathrm{machine}$.\n",
    "\n",
    "In fact, there is typically a small rounding error as soon as you enter a floating-point value, because most decimal fractions are not in $\\mathbb{F}$.   This can be seen by either:\n",
    "* converting to a higher precision with `big(x)` (converts to `BigFloat` [arbitrary-precision](https://en.wikipedia.org/wiki/Arbitrary-precision_arithmetic) value, by default with $p=256 \\mathrm{bits}$ or about $77 \\approx 256 \\times \\log_{10}(2)$ decimal digits)\n",
    "* comparing to an exact rational — in Julia, `p // q` produces a `Rational` type, which is stored as a pair of integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "256"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "setprecision(BigFloat, 256)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.02040816326530612244897959183673469387755102040816326530612244897959183673469376"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "big(1)/big(49)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-8.636168555094444625386351862800399571116000364436281385023703470168591803162427e-78"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "49 * (big(1)/big(49)) - 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3//2"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3//2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Rational{Int64}"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(3//2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rational{Int64}\n",
      "  num: Int64 3\n",
      "  den: Int64 2\n"
     ]
    }
   ],
   "source": [
    "dump(3//2) # dump lets us see how the underlying data of Rational is stored, as 2 integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(true, true)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 1.5 is exactly represented in binary floating point:\n",
    "big(1.5) == 3//2, 1.5 == 3//2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1/49 == 1//49"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.1000000000000000055511151231257827021181583404541015625, false)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 0.1 is *not* exactly represented\n",
    "big(0.1), 0.1 == 1//10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that when you enter a floating-point literal like `0.1` in Julia, it is immediately converted to the nearest `Float64` value.   So `big(0.1)` *first* rounds `0.1` to `Float64` and *then* converts to `BigFloat`.\n",
    "\n",
    "If, instead, you want to round `0.1` to the nearest `BigFloat` directly, you have to use a different \"string macro\" input format:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.1000000000000000000000000000000000000000000000000000000000000000000000000000002"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "big\"0.1\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0e+10"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 1e10 in 𝔽 for Float64 (about 15 decimal digits)\n",
    "big(1e10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.000000000000000015902891109759918046836080856394528138978132755774783877217038e+100"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 1e100 is also *not* exactly represented in Float64 precision,\n",
    "# since it not a \"small\" (≈15 digit) integer times a power of two,\n",
    "# but *is* exactly represented in 256-bit BigFloat:\n",
    "\n",
    "big(1e100) # rounds 1e100 to Float64 then extends to BigFloat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0e+100"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "big\"1e100\" # exact in 256-bit BigFLoat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fundamental Axioms of Floating-Point Arithmetic\n",
    "\n",
    "For analysis of floating-point in 18.335, following the notation in Trefethen & Bau, we define:\n",
    "\n",
    "* $\\operatorname{fl}(x) = $ **closest** floating point number $\\in \\mathbb{F}$ to $x \\in \\mathbb{R}$.\n",
    "* $\\oplus,\\ominus,\\otimes,\\oslash$ denote the *floating-point* versions of $+,-,\\times,/$.\n",
    "\n",
    "In analyzing roundoff errors theoretically, we mostly **ignore overflow/underflow** (discussed below), i.e. we ignore the limited range of the exponent $e$.  In this case, we have the following property:\n",
    "\n",
    "* $\\operatorname{fl}(x) = x (1 + \\epsilon)$ for some $|\\epsilon| \\le \\epsilon_\\mathrm{machine}$ \n",
    "* $\\boxed{x \\odot y = (x \\cdot y) (1 + \\epsilon)}$ for some $|\\epsilon| \\le \\epsilon_\\mathrm{machine}$ where \"$\\cdot$\" is one of $\\{+,-,\\times,/\\}$ and $\\odot$ is the floating-point analogue.\n",
    "\n",
    "That is these operations have **relative** error bounded above by $\\epsilon_\\mathrm{machine}$.   In fact, it turns out that floating-point operations have an even stronger guarantee in practice, called **correct rounding** or **exact rounding**:\n",
    "\n",
    "* $x \\odot y = \\operatorname{fl}(x \\cdot y)$\n",
    "\n",
    "That is, $\\{+,-,\\times,/\\}$ behave *as if* you computed the result *exactly* and then rounded to the **closest** floating-point value.   So, for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1.0 + 1.0 == 2.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "is guaranteed to be true — **integer arithmetic is exact** in floating-point until you exceed the largest exactly representable integer in your precision.\n",
    "\n",
    "(It is a common misunderstanding that floating-point addition/subtraction/multiplication of small integers might give \"random\" rounding errors, e.g. many people seem to think that `1.0 + 1.0` might give something other than `2.0`.   Similarly, floating-point arithmetic guarantees that `x * 0 == 0` for any finite `x`.)\n",
    "\n",
    "It is important to realize that these accuracy guarantees are **only for individual operations**.   If you perform many operations, the **errors can accumulate**, as we will discuss in more detail below."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Decimal input and output\n",
    "\n",
    "A confusing aspect of floating-point arithmetic is that, since the default types are *binary*, it means that some rounding occurs on human-readable *decimal* values for **both input and output**.  \n",
    "\n",
    "* There is something called [decimal floating point](https://en.wikipedia.org/wiki/Decimal_floating_point) (base $\\beta=10$) that avoids this issue, but it isn't supported by typical computer hardware so it is slow and only used for relatively specialized applications; you can do it in Julia with the [DecFP package](https://github.com/JuliaMath/DecFP.jl).\n",
    "\n",
    "We already said that a value like `1e-100` in Julia really means $\\operatorname{fl}({10^{-100}})$ (in `Float64` precision): the result is \"immediately\" rounded to the nearest `Float64` value by the parser.   But what does it mean when this value is *printed* as output?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0e-100"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1e-100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At first glance, the printed output is $10^{-100}$.  Technically, however, this answer **really** means that the output is $\\operatorname{fl}({10^{-100}})$.\n",
    "\n",
    "A lot of research has gone into the deceptively simple question of how to print (binary) floating-point values as human-readable decimal values.   Printing the *exact* decimal value is possible for any integer times a power of two, but might require a huge number of digits:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.00000000000000001999189980260288361964776078853415942018260300593659569925554346761767628861329298958274607481091185079852827053974965402226843604196126360835628314127871794272492894246908066589163059300043457860230145025079449986855914338755579873208034769049845635890960693359375e-100"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "setprecision(4096) do # even 256 digits isn't enough: temporarily increase BigFloat precision\n",
    "    big(1.0e-100)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We don't really want to see all of these digits every time we display floating-point values on a computer, however, particularly since most of them are \"garbage\" (roundoff errors).\n",
    "\n",
    "As a result, every popular computer language performs some kind of rounding when it *outputs* floating-point values.  The [algorithm used by Julia](https://dl.acm.org/doi/10.1145/3192366.3192369) actually prints the **shortest decimal value** that **rounds to the same floating-point value**!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Non-associativity:\n",
    "\n",
    "In particular, note that floating-point arithmetic is **not associative**: $(x \\oplus y) \\oplus z \\ne x \\oplus (y \\oplus z)$ in general (and similarly for $\\ominus, \\otimes$).  For example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0e-100"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1.0 + -1.0) + 1e-100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1.0 + (-1.0 + 1e-100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is an example of **catastrophic cancellation**: we lost *all* the significant digits.  We'll talk more about this below.\n",
    "\n",
    "Even 256 bits of precision (77 decimal digits) is not enough to avoid catastrophic cancellation here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "big\"1.0\" + (big\"-1.0\" + big\"1e-100\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This happens because $-1.0 \\oplus \\operatorname{fl}(10^{-100}) = -1.0$ in double precision — we only have about 15 decimal places of precision, so the exact result is rounded to $-1.0$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Overflow, Underflow, Inf, and NaN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because a floating-point value uses a finite number of bits to store the exponent `e`, there is a maximum and minimum magnitude for floating-point values.   If you go over the maximum, you **overflow** to a special `Inf` value (or `-Inf` for large negative values), representing $\\infty$.   If you go under the minimum, you **underflow** to $\\pm 0.0$, where $-0$ is used to represent e.g. a value that underflowed from the negative side."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0e300"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1e300 # okay: 10³⁰⁰ is in the representable range"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Inf"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1e300)^2 # overflows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-Inf"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "-Inf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 / Inf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can get the maximum representable magnitude via `floatmax`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.7976931348623157e308, 3.4028235f38)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "floatmax(Float64), floatmax(Float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0e-300"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1e-300 # okay"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1e-300)^2 # underflows to +0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use `floatmin` in Julia to find the minimum-magnitude floating-point value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2.2250738585072014e-308, 1.1754944f-38)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "floatmin(Float64), floatmin(Float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.0"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "-1e-300 * 1e-300 # underflows to -0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While -0 is printed differently from +0, they still compare equal.  However, you will notice the difference if you do something that depends on the sign:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "+0.0 == -0.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dividing by zero gives `Inf`, as you expect, or `-Inf` if you divide by \"negative zero\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Inf, -Inf)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 / +0.0, 1 / -0.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(false, true)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "signbit(+0.0), signbit(-0.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since 1/-Inf is -0.0, this has the nice property that:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-Inf"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 / (1 / -Inf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A special value `NaN` (\"not a number\") is used to represent the result of floating-point operations that can't be defined in a sensible way (e.g. [indeterminate forms](https://en.wikipedia.org/wiki/Indeterminate_form)):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(NaN, NaN, NaN, NaN)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0 * Inf, Inf / Inf, 0 / 0, 0 * NaN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, **non-finite** values are the exception to the rule that $0 \\otimes x == 0$ in floating-point arithmetic.\n",
    "\n",
    "In fact, `NaN` has the odd property that it is the *only* number that is not equal to itself:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "NaN == NaN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One way of viewing IEEE's semantics is that a `NaN` can be viewed as a stand-in for *any* value, or *none*, so `NaN` values arising from different sources are not equivalent.  (In some statistical software, `NaN` is also used to represent missing data, but Julia has a special [`missing` value](https://docs.julialang.org/en/v1/manual/missing/) for this.)\n",
    "\n",
    "(There is another function [`isequal` in Julia](https://docs.julialang.org/en/v1/base/base/#Base.isequal) that can be treats NaN values as equal in cases where that is needed.)\n",
    "\n",
    "You can check for non-finite values like this with `isnan`, `isinf`, and `isfinite`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(false, true, true, false)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinf(2.5), isinf(Inf), isinf(-Inf), isinf(NaN)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(false, false, false, true)"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isnan(2.5), isnan(Inf), isnan(-Inf), isnan(NaN)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(true, false, false, false)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isfinite(2.5), isfinite(Inf), isfinite(-Inf), isfinite(NaN)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In some other languages, `NaN` is also used to signal that a function cannot be evaluated.  For example, in C, `sqrt(-1.0)` returns `NaN`.  However, Julia typically [throws](http://docs.julialang.org/en/latest/manual/control-flow/#man-exception-handling) an [exception](https://en.wikipedia.org/wiki/Exception_handling) in these cases:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "\u001b[91mDomainError with -1.0:\u001b[39m\n\u001b[91msqrt will only return a complex result if called with a complex argument. Try sqrt(Complex(x)).\u001b[39m",
     "output_type": "error",
     "traceback": [
      "\u001b[91mDomainError with -1.0:\u001b[39m\n\u001b[91msqrt will only return a complex result if called with a complex argument. Try sqrt(Complex(x)).\u001b[39m",
      "",
      "Stacktrace:",
      " [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:33",
      " [2] sqrt(::Float64) at ./math.jl:573",
      " [3] top-level scope at In[43]:1",
      " [4] include_string(::Function, ::Module, ::String, ::String) at ./loading.jl:1091"
     ]
    }
   ],
   "source": [
    "sqrt(-1.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want a complex *output* from the `sqrt` function, you need to give it a complex *input*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0 + 1.0im"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sqrt(-1.0 + 0im)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The reason for this is a technical criterion called [type stability](http://docs.julialang.org/en/latest/manual/performance-tips/#write-type-stable-functions) that is essential for Julia code to be compiled to fast machine instructions.  (The lack of type stability in many standard-library functions is a key contributor to the difficulty of retrofitting fast compilers to languages like Python and Matlab.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cancellation error\n",
    "\n",
    "One common source of huge floating-point errors is a [catastrophic cancellation](https://en.wikipedia.org/wiki/Loss_of_significance): if you **subtract two nearly equal numbers** then most of the significant digits cancel, and the result can have a relative error $\\gg \\epsilon$.\n",
    "\n",
    "Catastrophic cancellation is not inevitable, however!  Often it can be avoided simply by **re-arranging your calculation**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The `expm1` function\n",
    "\n",
    "Suppose you are calculating the function $e^x - 1$ using floating-point arithmetic.   When $|x| \\ll 1$, we have $e^x \\approx 1$, and so a naive calculation $e^x \\ominus 1$ will experience catastrophic cancellation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 8.673617379884035e-19\n",
      "exp(x) = 1.0\n",
      "exp(x) - 1 = 0.0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 2.0^-60\n",
    "@show x\n",
    "@show exp(x)\n",
    "@show exp(x) - 1 # naive algorithm: catastrophic cancellation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This result `0.0` has **no correct digits**.  The correct answer is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8.673617379884035e-19"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# naive algorithm computed in BigFloat precision and rounded back to Float64:\n",
    "Float64(exp(big(x)) - 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also see this using the Taylor expansion of $e^x$:\n",
    "\n",
    "$$\n",
    "e^x - 1 = \\left(1 + x + \\frac{x^2}{2} + \\cdots + \\frac{x^n}{n!} + \\cdots\\right) - 1 = \\boxed{x + \\frac{x^2}{2} + \\cdots + \\frac{x^n}{n!} + \\cdots}\n",
    "$$\n",
    "which we can use to calculate this function accurately for small $x$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8.673617379884035e-19"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x + x^2/2 + x^3/6 # 3 terms is more than enough for x ≈ 8.7e-19"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8.673617379884035e-19"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x # in fact, just one term is enough"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The key is to **rearrange the calculation** to **perform the cancellation analytically**, and only use floating-point arithmetic *after* this is accomplished.\n",
    "\n",
    "In fact, Julia's standard library (and scientific-computing libraries in other languages) provides a function called `expm1(x)` that computes $e^x - 1$ accurately for all `x`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8.673617379884035e-19"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expm1(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Such [special functions](https://en.wikipedia.org/wiki/Special_functions) can be implemented in many ways.  One possible implementation of `expm1` might be:\n",
    "\n",
    "* Just do `exp(x) - 1` if $|x|$ is sufficiently large.\n",
    "* Use the Taylor series if $|x|$ is small.\n",
    "* In between (e.g. $|x| \\sim 1$), to avoid requiring many terms of the Taylor series, one could use some kind of fit, e.g. a [minimax polynomial](https://en.wikipedia.org/wiki/Minimax_approximation_algorithm) or [rational function](https://en.wikipedia.org/wiki/Rational_function).\n",
    "\n",
    "(In general, special-function implementations typically use some combination of Taylor series near zeros, minimax fits, continued-fraction expansions or asymptotic series, and function-specific identities.  This is a branch of numerical analysis that we won't delve into in 18.335.)\n",
    "\n",
    "Sometimes, a simple (but often non-obvious) algebraic rearrangement leads to a formula that is accurate for all $x$.  For example, in this case one can use the exact identities:\n",
    "$$\n",
    "e^x - 1 = \\left(e^x+1\\right)\\tanh(x/2) = \\frac{\\left(e^x - 1\\right) x}{\\log\\left(e^x\\right)}\n",
    "$$\n",
    "and it turns out that the catastrophic cancellation is avoided with either of the two expressions at right, at the cost of calling `tanh` or `log` in addition to `exp`.  See e.g. Higham, [*Accuracy and Stability of Numerical Algorithms*](https://epubs.siam.org/doi/book/10.1137/1.9780898718027?mobileUi=0) (2002), p. 30 for more explanation and references."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quadratic roots\n",
    "\n",
    "If you are finding solutions of the quadratic equation\n",
    "$$\n",
    "ax^2 + bx + c = 0\n",
    "$$\n",
    "you will surely reach for the [quadratic formula](https://en.wikipedia.org/wiki/Quadratic_formula):\n",
    "$$\n",
    "x_\\pm = \\frac{-b \\pm \\sqrt{b^2 - 4ac}}{2a}\n",
    "$$\n",
    "However, suppose $b > 0$ and $|ac| \\ll b^2$.   In this case, $\\sqrt{b^2 - 4ac} \\approx b$.  The $x_-$ root will be fine, but the $x_+$ root will suffer from a catastrophic cancellation because $-b + \\sqrt{\\cdots}$ is the difference of two nearly equal quantities.\n",
    "\n",
    "To compute $x_+$, we could again use a Taylor series, but it turns out that we can instead use a simple re-arrangement:\n",
    "$$\n",
    "x_\\pm = \\frac{2c}{-b \\mp \\sqrt{b^2 - 4ac}}\n",
    "$$\n",
    "which comes from dividing our quadratic equation by $x^2$ and applying the standard quadratic formula to $cy^2 + by + a = 0$ where $y = 1/x$.   This \"inverted\" form of the quadratic formula is accurate for $x_+$ (again assuming $b > 0$) but may have catastrophic cancellation for $x_-$.\n",
    "\n",
    "So, we just use the first quadratic formula for the $x_-$ root and the second \"inverted\" quadratic formula for the $x_+$ root:\n",
    "$$\n",
    "x_+, \\, x_- = \\frac{2c}{-b - \\sqrt{b^2 - 4ac}},\\;\\frac{-b - \\sqrt{b^2 - 4ac}}{2a} \\, .\n",
    "$$\n",
    "No increase in computational cost, just a little thought and rearrangement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Accumulation of roundoff errors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A common mistake is to confuse **precision** with **accuracy**.   A value can be *more accurate* or *less accurate* than the precision (number of digits) with which it is represented.\n",
    "\n",
    "For example, the value `3.0` in floating point (represented exactly in $\\mathbb{F}$) is an exact value for the number of sides of a triangle, but a rather inaccurate approximation for π.\n",
    "\n",
    "Most commonly, floating-point values are *less accurate* than the precision allows, because **roundoff errors accumulate** over the course of a long computation.   To see this, let us consider the function `y = cumsum(x)` in Julia, which computes\n",
    "$$\n",
    "y_k = \\sum_{i=1}^k x_i\n",
    "$$\n",
    "We will try this for random $x_i \\in [0,1)$, and compare to the \"exact\" value of the sum.  Although `cumsum` is built-in to Julia, we will write our own version so that we can see exactly what it is doing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "my_cumsum (generic function with 1 method)"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function my_cumsum(x)\n",
    "    y = similar(x) # allocate an array of the same type and size as x\n",
    "    y[1] = x[1]\n",
    "    for i = 2:length(x)\n",
    "        y[i] = y[i-1] + x[i]\n",
    "    end\n",
    "    return y\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, how to we get the \"exact\" sum for comparing the error?   One possible trick is that we can do the sum in **two precisions**: *double precision* and *single precision* (Julia `Float32` = 32 bits), where single precision is about 7-8 decimal digits ($p=24$ bits).  Since double precision has about twice as many digits as single precision, we can treat the double precision result as \"exact\" compared to the single-precision result in order to compute the accuracy in the latter.\n",
    "\n",
    "* Alternatively, there is a package called [Xsum.jl](https://github.com/stevengj/Xsum.jl) for Julia that computes exactly rounded sums in double precision using an [algorithm by Radford Neal](https://arxiv.org/abs/1505.05571) that uses a little bit of extra precision as needed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.1920929f-7, 2.220446049250313e-16)"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eps(Float32), eps(Float64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "Figure(PyObject <Figure size 640x480 with 1 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  0.044979 seconds (18.19 k allocations: 39.134 MiB)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "PyObject Text(0.5, 1.0, 'naive cumsum implementation')"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = rand(Float32, 10^7) # 10^7 single-precision values uniform in [0,1)\n",
    "@time y = my_cumsum(x)\n",
    "yexact = my_cumsum(Float64.(x)) # same thing in double precision\n",
    "err = abs.(y .- yexact) ./ abs.(yexact) # relative error in y\n",
    "\n",
    "using PyPlot\n",
    "n = 1:10:length(err) # downsample by 10 for plotting speed\n",
    "loglog(n, err[n])\n",
    "ylabel(\"relative error\")\n",
    "xlabel(\"# summands\")\n",
    "# plot a √n line for comparison\n",
    "loglog([1,length(err)], sqrt.([1,length(err)]) * 1e-7, \"k--\")\n",
    "text(1e3,1e-5, L\"\\sim \\sqrt{n}\")\n",
    "title(\"naive cumsum implementation\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the error starts around $10^{-7}$ (about `eps(Float32)`), but gets worse than the precision as the number of summands grows.\n",
    "\n",
    "As you can see, the relative error has an upper bound that scales roughly proportional $\\sqrt{n}$ where $n$ is the number of summands.   Intuitively, there is a little roundoff error from each addition, but the roundoff error is somewhat random in $[-\\epsilon,+\\epsilon]$ and hence the roundoff errors grow as a [random-walk](https://en.wikipedia.org/wiki/Random_walk) process $\\sim \\sqrt{n}$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, **one can do better than this**.  If you use the built-in `cumsum` function, you will see *very different* error growth: the mean errors actually grow as roughly $\\sqrt{\\log n}$.  Not only that, but the output of the `@time` macro indicates that the built-in `cumsum` (which is also written in Julia) is actually a bit *faster* than our `my_cumsum`.\n",
    "\n",
    "We will have to investigate summation in more detail to understand how this can be possible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "Figure(PyObject <Figure size 640x480 with 1 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  0.070438 seconds (185.04 k allocations: 47.735 MiB)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "PyObject Text(100.0, 3.3e-07, '$\\\\sim \\\\sqrt{\\\\log n}$')"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@time y2 = cumsum(x)\n",
    "err2 = abs.(y2 .- yexact) ./ abs.(yexact)\n",
    "loglog(n, err2[n])\n",
    "ylabel(\"relative error\")\n",
    "xlabel(\"# summands\")\n",
    "title(\"built-in cumsum function\")\n",
    "loglog(n, sqrt.(log.(n)) * 1e-7, \"k--\")\n",
    "text(1e2,3.3e-7, L\"\\sim \\sqrt{\\log n}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Rounding mode\n",
    "\n",
    "By default, each elementary floating-point operation (`+`, `-`, `*`, `/`) behaves as if it computed its result in infinite precision and then rounded the result to the *nearest* floating-point value (rounding to the nearest *even* value in the case of ties).  This is called **correct rounding** or **exact rounding**.\n",
    "\n",
    "The `rounding` function in Julia returns the current rounding behavior for a given type, and defaults to rounding to the nearest value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RoundingMode{:Nearest}()"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rounding(Float32)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, it is possible to *change* the rounding mode to always round *up* (or *down*) with the `setrounding` function from the [SetRounding.jl package](https://github.com/JuliaIntervals/SetRounding.jl).  (In C/C++ you would use the [`fesetround`](https://en.cppreference.com/w/c/numeric/fenv/feround) function.)\n",
    "\n",
    "First, let's install this package if needed.  We can do `import Pkg` followed by `Pkg.add(\"SetRounding\")`, but it is nicer to simply start an input cell with `]` at which point you are in \"package mode\" and have a set of [nice package-management commands](https://docs.julialang.org/en/v1/stdlib/Pkg/) available:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[2K\u001b[?25h[1mFetching:\u001b[22m\u001b[39m [========================================>]  100.0 %.0 %"
     ]
    }
   ],
   "source": [
    "] add SetRounding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "using SetRounding"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Changing the rounding mode is supported in the CPU hardware, so it doesn't change the speed of floating-point arithmetic.   It can be extremely useful to gain an understanding of the roundoff errors in a problem, and can even be used to implement [interval arithmetic](https://en.wikipedia.org/wiki/Interval_arithmetic), in which you compute a range `[a,b]` that bounds your error rather than a single rounded value — see [IntervalArithmetic.jl](https://github.com/JuliaIntervals/IntervalArithmetic.jl) in Julia. \n",
    "\n",
    "In the case of our summation problem, we can change to rounding up, which will result in a very different error growth: O(n) rather than O(√n).  The errors now all accumulate in the same direction, so they no longer form a random walk."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "Figure(PyObject <Figure size 640x480 with 1 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "PyObject Text(0.5, 1.0, 'naive cumsum implementation, rounded up')"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "errup = setrounding(Float32, RoundUp) do\n",
    "    # error in single-precision (Float32) sum, rounding temporarily set to RoundUp\n",
    "    abs.(my_cumsum(x) .- yexact) ./ abs.(yexact) # relative error in y\n",
    "end\n",
    "\n",
    "loglog(n, errup[n])\n",
    "ylabel(\"relative error\")\n",
    "xlabel(\"# summands\")\n",
    "# plot an O(n) line for comparison\n",
    "loglog([1,length(errup)], [1,length(errup)] * 1e-7, \"k--\")\n",
    "text(1e3,4e-4, L\"\\sim n\")\n",
    "title(\"naive cumsum implementation, rounded up\")"
   ]
  }
 ],
 "metadata": {
  "@webio": {
   "lastCommId": null,
   "lastKernelId": null
  },
  "kernelspec": {
   "display_name": "Julia 1.5.3",
   "language": "julia",
   "name": "julia-1.5"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.5.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}