.ipynb .pdf

repository open issue

Binder Live Code

Contents

2022-01-19 Conditioning

• Office hours: Monday 9-10pm, Tuesday 2-3pm, Thursday 2-3pm

• More on floating point

• Discuss Taylor Series activity

• Condition numbers

• Forward and backward error

• Computing volume of a polygon

using Plots
default(linewidth=4)

Floating point representation is relative

Let \(\operatorname{fl}\) round to the nearest floating point number.

\[ \operatorname{fl}(x) = x (1 + \epsilon), \quad \text{where} |\epsilon| \le \epsilon_{\text{machine}} \]

This also means that the relative error in representing \(x\) is small:

\[ \frac{|\operatorname{fl}(x) - x|}{|x|} \le \epsilon_{\text{machine}} \]

plot(x -> (1 + x) - 1, xlims=(-1e-15, 1e-15))
plot!(x -> x)

Exact arithmetic, correctly rounded

Take an elementary math operation \(*\) (addition, subtraction, multiplication, division), and the discrete operation that our computers perform, \(\circledast\). Then

\[x \circledast y := \operatorname{fl}(x * y)\]

with a relative accuracy \(\epsilon_{\text{machine}}\),

\[ \frac{|(x \circledast y) - (x * y)|}{|x * y|} \le \epsilon_{\text{machine}} . \]

Seems easy, how do operations compose?

Is this true?

\[ \frac{\Big\lvert \big((x \circledast y) \circledast z\big) - \big((x * y) * z\big) \Big\rvert}{|(x * y) * z|} \le^? \epsilon_{\text{machine}} \]

f(x; y=1, z=-1) = (x+y)+z # The best arbitrary numbers are 0, 1, and -1
plot(x -> abs(f(x) - x)/abs(x), xlims=(-1e-15, 1e-15))

Which operation caused the error?

1. \(\texttt{tmp} = \operatorname{fl}(x + 1)\)

2. \(\operatorname{fl}(\texttt{tmp} - 1)\)

Use Julia’s BigFloat

@show typeof(big(.1))
@show big(.1)          # Or BigFloat(.1); parsed as Float64, then promoted
@show BigFloat(".1");  # Parse directly to BigFloat

typeof(big(0.1)) = BigFloat
big(0.1) = 0.1000000000000000055511151231257827021181583404541015625
BigFloat(".1") = 0.1000000000000000000000000000000000000000000000000000000000000000000000000000002

tmp = 1e-15 + 1
tmp_big = big(1e-15) + 1 # Parse as Float64, then promote
abs(tmp - tmp_big) / abs(tmp_big)

1.102230246251563524952071662733800140614440125894379682676737388538642032894338e-16

r = tmp - 1
r_big = big(tmp) - 1
abs(r - r_big) / abs(r_big)

0.0

Activity: 2022-01-12-taylor-series

• Use Julia, Jupyter, Git

• Look at how fast series converge when taking only finitely many terms

• Explore instability, as is occuring for large negative x above, but not for the standard library expm1

function myexp(x, k)
    sum = 0
    term = 1
    n = 1
    # modify so at most k terms are summed
    while sum + term != sum
        sum += term
        term *= x / n
        # YOUR CODE HERE
        if n == k
            break
        end
        n += 1
    end
    sum
end

rel_error(x, k) = abs(myexp(x, k) - exp(x)) / exp(x)
ks = 2 .^ (0:10)  # [1, 2, 4, ..., 1024];

plot(ks, k -> rel_error(-20, k), xscale=:log10, yscale=:log10)

plot(x -> rel_error(x, 1000) + 1e-17, xlims=(-20, 20), yscale=:log10)

What happened?

Let’s look at the terms for positive and negative \(x\)

function expterms(x, k=50)
    term = 1.
    terms = [term]
    for n in 1:k
        term *= x / n
        push!(terms, term)
    end
    terms
end
x = -10
@show sum(expterms(x)) - exp(x)
@show (sum(expterms(x)) - exp(x)) / exp(x)
expterms(x)

sum(expterms(x)) - exp(x) = 1.2092180894291739e-12
(sum(expterms(x)) - exp(x)) / exp(x) = 2.6634800885273225e-8

51-element Vector{Float64}:
     1.0
   -10.0
    50.0
  -166.66666666666669
   416.66666666666674
  -833.3333333333335
  1388.8888888888891
 -1984.1269841269846
  2480.1587301587306
 -2755.7319223985896
  2755.7319223985896
 -2505.2108385441725
  2087.6756987868107
     ⋮
    -4.902469756513546e-8
     1.2256174391283866e-8
    -2.9893108271424062e-9
     7.117406731291443e-10
    -1.655210867742196e-10
     3.761842881232264e-11
    -8.359650847182808e-12
     1.81731540156148e-12
    -3.866628513960596e-13
     8.055476070751242e-14
    -1.64397470831658e-14
     3.28794941663316e-15

@show exp(-10)
bar(expterms(-10))

exp(-10) = 4.5399929762484854e-5

Conditioning

What sort of functions cause small errors to become big?

Consider a function \(f: X \to Y\) and define the absolute condition number

\[ \hat\kappa = \lim_{\delta \to 0} \max_{|\delta x| < \delta} \frac{|f(x + \delta x) - f(x)|}{|\delta x|} = \max_{\delta x} \frac{|\delta f|}{|\delta x|}. \]

If \(f\) is differentiable, then \(\hat\kappa = |f'(x)|\).

Floating point offers relative accuracy, so it’s more useful to discuss relative condition number,

\[ \kappa = \max_{\delta x} \frac{|\delta f|/|f|}{|\delta x|/|x|} = \max_{\delta x} \Big[ \frac{|\delta f|/|\delta x|}{|f| / |x|} \Big] \]

or, if \(f\) is differentiable,

\[ \kappa = |f'(x)| \frac{|x|}{|f|} . \]

Condition numbers

\[ \kappa = |f'(x)| \frac{|x|}{|f|} \]

f(x) = x - 1; fp(x) = 1
plot(x -> abs(fp(x)) * abs(x) / abs(f(x)), xlims=(0, 2))

Back to \(f(x) = e^x - 1\)

f(x) = exp(x) - 1
fp(x) = exp(x)
plot(x -> abs(fp(x)) * abs(x) / abs(f(x)))

What does it mean?

• The function \(f(x) = e^x - 1\) is well-conditioned

• The function \(f_1(x) = e^x\) is well-conditioned

• The function \(f_2(x) = x - 1\) is ill-conditioned for \(x \approx 1\)

The algorithm is unstable

• f(x) = exp(x) - 1 is unstable

• Algorithms are made from elementary operations

• Unstable algorithms do something ill-conditioned

A stable algorithm

We used the series expansion previously.

• accurate for small \(x\)

• less accurate for negative \(x\) (see activity)

• we could use symmetry to fix

• inefficient because we have to sum lots of terms

Standard math libraries define a more efficient stable variant, \(\texttt{expm1}(x) = e^x - 1\).

plot([x -> exp(x) - 1,
      x -> expm1(x)],
    xlims = (-1e-15, 1e-15))

Another example \(\log(1 + x)\)

What is the condition number of \(f(x) = \log(1 + x)\) for \(x \approx 0\)?

plot([x -> log(1 + x),
      x -> log1p(x)],
    xlims = (-1e-15, 1e-15))

cond1(x) = abs(1/(1+x) * x / log1p(x))
cond2(x) = abs(1/x * x / log(x))
plot([cond1 cond2], xlims=(-1, 2), ylims=(0, 100))

Reliable = well-conditioned and stable

Mathematical functions \(f(x)\) can be ill-conditioned (big \(\kappa\))

• Modeling is how we turn an abstract question into a mathematical function

• We want well-conditioned models (small \(\kappa\))

• Some systems are intrinsically sensitive: fracture, chaotic systems, combustion

Algorithms f(x) can be unstable

• Unreliable, though sometimes practical

• Unstable algorithms are constructed from ill-conditioned parts

An ill-conditioned problem from Paul Olum

From Surely You’re Joking, Mr. Feynman (page 113)

So Paul is walking past the lunch place and these guys are all excited. “Hey, Paul!” they call out. “Feynman’s terrific! We give him a problem that can be stated in ten seconds, and in a minute he gets the answer to 10 percent. Why don’t you give him one?” Without hardly stopping, he says, “The tangent of 10 to the 100th.” I was sunk: you have to divide by pi to 100 decimal places! It was hopeless.

What’s the condition number?

\[ \kappa = |f'(x)| \frac{|x|}{|f|} \]

• \(f(x) = \tan x\)

• \(f'(x) = 1 + \tan^2 x\)

\[ \kappa = \lvert x \rvert \Bigl( \lvert \tan x \rvert + \bigl\lvert \frac{1}{\tan x} \bigr\rvert \Bigr)\]

tan(1e100)

-0.4116229628832498

tan(BigFloat("1e100", precision=500))

0.4012319619908143541857543436532949583238702611292440683194415381168718098221194

Go find some functions…

• Find a function \(f(x)\) that models something you’re interested in

• Plot its condition number \(\kappa\) as a function of \(x\)

• Plot the relative error (using single or double precision; compare using Julia’s big)

• Is the relative error ever much bigger than \(\kappa \epsilon_{\text{machine}}\)?

• Can you find what caused the instability?

• Share on Zulip

Further reading: FNC Introduction

previous

2022-01-14 Function errors

next

2022-01-21 Rootfinding