diff --git a/README.md b/README.md
index aaa16c2..5cc2836 100644
--- a/README.md
+++ b/README.md
@@ -391,3 +391,17 @@ Fourier series vs. DFT: If we view the DFT as a [Riemann sum](https://en.wikiped
 * [Graph partitioning](https://en.wikipedia.org/wiki/Graph_partition): spectral partitioning via the [Fiedler vector](https://en.wikipedia.org/wiki/Algebraic_connectivity), corresponding to the **second-smallest** eigenvalue of L
 
 **Further reading:** Textbook sections VI.6–VI.7 and [OCW lecture 35](https://ocw.mit.edu/courses/18-065-matrix-methods-in-data-analysis-signal-processing-and-machine-learning-spring-2018/resources/lecture-35-finding-clusters-in-graphs-second-project-handwriting/).  Using incidence matrices to identify cycles and spanning trees in graphs is also covered in 18.06 and in Strang's *Introduction to Linear Algebra* book (5th ed. section 10.1 or 6th ed. section 3.5), as well as in [this interactive Julia notebook](https://github.com/mitmath/1806/blob/1a9ff5c359b79f28c534bf1e1daeadfdc7aee054/notes/Graphs-Networks.ipynb).  A popular software package for graph and mesh partitioning is [METIS](https://github.com/KarypisLab/METIS).  The Google [PageRank algorithm](https://en.wikipedia.org/wiki/PageRank) is another nice application of linear algebra to graphs, in this case to rank web pages by "importance".  Direct methods (e.g. Gaussian elimination) for sparse-matrix problems turn out to be all about analyzing sparsity patterns via graph theory; see e.g. the [book by Timothy Davis](https://epubs.siam.org/doi/book/10.1137/1.9780898718881).
+
+## Lecture 38 (May 15)
+
+* [Floating-point introduction](notes/Floating-Point-Intro.ipynb)
+
+If you want to continue with "numerical computing" in any form — whether it be for data analysis, machine learning, scientific/engineering modeling, or other areas — at some point you will need to learn more about **computational errors**.  The mathematical field that studies **algorithms + approximations** is called [numerical analysis](https://en.wikipedia.org/wiki/Numerical_analysis), covered by courses such as [18.335](https://github.com/mitmath/18335) at MIT.
+
+One of the most basic sources of computational error is that **computer arithmetic is generally inexact**, leading to [roundoff errors](https://en.wikipedia.org/wiki/Round-off_error).  The reason for this is simple: computers can only work with numbers having a **finite number of digits**, so they **cannot even store** arbitrary real numbers.  Only a _finite subset_ of the real numbers can be represented using a particular number of "bits", and the question becomes _which subset_ to store, how arithmetic on this subset is defined, and how to analyze the errors compared to theoretical exact arithmetic on real numbers.
+
+In **floating-point** arithmetic, we store both an integer coefficient and an exponent in some base: essentially, scientific notation. This allows large dynamic range and fixed _relative_ accuracy: if fl(x) is the closest floating-point number to any real x, then |fl(x)-x| < ε|x| where ε is the _machine precision_. This makes error analysis much easier and makes algorithms mostly insensitive to overall scaling or units, but has the disadvantage that it requires specialized floating-point hardware to be fast. Nowadays, all general-purpose computers, and even many little computers like your cell phones, have floating-point units.
+
+Went through some simple definitions and examples in Julia (see notebook above), illustrating the basic ideas and a few interesting tidbits.  In particular, we looked at **error accumulation** during long calculations (e.g. summation), as well as examples of [catastrophic cancellation](https://en.wikipedia.org/wiki/Loss_of_significance) and how it can sometimes be avoided by rearranging a calculation.
+
+**Further reading:** [Trefethen & Bau's *Numerical Linear Algebra*](https://people.maths.ox.ac.uk/trefethen/text.html), lecture 13. [What Every Computer Scientist Should Know About Floating Point Arithmetic](http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.22.6768) (David Goldberg, ACM 1991). William Kahan, [How Java's floating-point hurts everyone everywhere](http://www.cs.berkeley.edu/~wkahan/JAVAhurt.pdf) (2004): contains a nice discussion of floating-point myths and misconceptions.   A brief but useful summary can be found in [this Julia-focused floating-point overview](https://discourse.julialang.org/t/psa-floating-point-arithmetic/8678) by Prof. John Gibson. Because many programmers never learn how floating-point arithmetic actually works, there are [many common myths](https://github.com/mitmath/18335/blob/spring21/notes/fp-myths.pdf) about its behavior.
diff --git a/notes/Floating-Point-Intro.ipynb b/notes/Floating-Point-Intro.ipynb
new file mode 100644
index 0000000..7177382
--- /dev/null
+++ b/notes/Floating-Point-Intro.ipynb
@@ -0,0 +1,1712 @@
+{
+ "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",
+    "More concisely, in the usual \"binary\" floating point (β=2), **floating-point numbers (𝔽) are p-digit integers times powers of 2**.\n",
+    "\n",
+    "One goal of [numerical analysis](https://en.wikipedia.org/wiki/Numerical_analysis) 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",
+    "A basic tool for analysis of floating-point arithmetic, following the notation in [Trefethen & Bau's *Numerical Linear Algebra*](https://people.maths.ox.ac.uk/trefethen/text.html), is the following two axioms:\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": "DomainError with -1.0:\nsqrt will only return a complex result if called with a complex argument. Try sqrt(Complex(x)).",
+     "output_type": "error",
+     "traceback": [
+      "DomainError with -1.0:\nsqrt will only return a complex result if called with a complex argument. Try sqrt(Complex(x)).",
+      "",
+      "Stacktrace:",
+      " [1] throw_complex_domainerror(f::Symbol, x::Float64)",
+      "   @ Base.Math ./math.jl:33",
+      " [2] sqrt(x::Float64)",
+      "   @ Base.Math ./math.jl:591",
+      " [3] top-level scope",
+      "   @ In[43]:1"
+     ]
+    }
+   ],
+   "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 series for $e^x$:\n",
+    "\n",
+    "$$\n",
+    "e^x = 1 + x + \\frac{x^2}{2} + \\cdots + \\frac{x^n}{n!} + \\cdots\n",
+    "$$\n",
+    "\n",
+    "From this, we immediately see that floating-point arithmetic *must* give `exp(x) == 1.0` for $|x| < \\epsilon_\\mathrm{machine}$, because in that case $(1 \\oplus x) \\oplus \\cdots = 1$.\n",
+    "\n",
+    "In contrast, $e^x - 1$ has a Taylor series:\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 could 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": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  0.020385 seconds (16.67 k allocations: 39.050 MiB, 30.65% compilation time)\n"
+     ]
+    },
+    {
+     "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')"
+      ]
+     },
+     "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 (single precision)\")\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`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  0.024061 seconds (79.19 k allocations: 42.253 MiB, 47.20% compilation time)\n"
+     ]
+    },
+    {
+     "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(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 (single-precision)\")\n",
+    "xlabel(\"# summands\")\n",
+    "title(\"Julia's 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": [
+    "Julia's `cumsum` is using an algorithm called [pairwise summation](https://en.wikipedia.org/wiki/Pairwise_summation), which simply does the same summation in a different order to get much greater accuracy for essentially the same performance.  To understand how this works requires a deeper analysis."
+   ]
+  },
+  {
+   "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": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\u001b[32m\u001b[1m   Resolving\u001b[22m\u001b[39m package versions...\n",
+      "\u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m `~/.julia/environments/v1.8/Project.toml`\n",
+      " \u001b[90m [3cc68bcd] \u001b[39m\u001b[92m+ SetRounding v0.2.1\u001b[39m\n",
+      " \u001b[90m [221a10cb] \u001b[39m\u001b[93m~ StripRTF v1.0.0-DEV `~/.julia/dev/StripRTF` ⇒ v1.0.0 `~/.julia/dev/StripRTF`\u001b[39m\n",
+      "\u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m `~/.julia/environments/v1.8/Manifest.toml`\n",
+      " \u001b[90m [3cc68bcd] \u001b[39m\u001b[92m+ SetRounding v0.2.1\u001b[39m\n",
+      " \u001b[90m [221a10cb] \u001b[39m\u001b[93m~ StripRTF v1.0.0-DEV `~/.julia/dev/StripRTF` ⇒ v1.0.0 `~/.julia/dev/StripRTF`\u001b[39m\n",
+      "\u001b[32m\u001b[1mPrecompiling\u001b[22m\u001b[39m project...\n",
+      "\u001b[32m  ✓ \u001b[39mSetRounding\n",
+      "  1 dependency successfully precompiled in 2 seconds. 409 already precompiled.\n"
+     ]
+    }
+   ],
+   "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 (single-precision)\")\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\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "@webio": {
+   "lastCommId": null,
+   "lastKernelId": null
+  },
+  "kernelspec": {
+   "display_name": "Julia 1.8.3",
+   "language": "julia",
+   "name": "julia-1.8"
+  },
+  "language_info": {
+   "file_extension": ".jl",
+   "mimetype": "application/julia",
+   "name": "julia",
+   "version": "1.8.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}