Glossary

The plain, un-scaled gap between an exact value and an approximation to it.

Whether a numerical method's own error stays bounded (rather than growing without limit) when it's run on a simple decaying test equation.

Subdividing an interval only where a local accuracy check actually fails, instead of using the same panel width everywhere.

Letting a numerical method choose its own step size as it runs, shrinking h where the solution changes fast and growing it where the solution is calm.

A value that stands in for the exact answer because the exact one is unavailable or impractical to compute.

A value or formula that stands in for an exact one because the exact one is unavailable, too costly to compute, or unnecessary at the precision needed.

Approximating a derivative from the current point and one point behind it.

A matrix whose nonzero entries all sit within a fixed distance of the main diagonal -- a tridiagonal matrix (Chapter 4's own spline system) is the narrowest common case.

A matrix with nonzero entries only on the main diagonal and one immediate neighbor diagonal -- half of a tridiagonal matrix's band.

The root-finding method that repeatedly cuts a bracket in half, always keeping the half where the sign change (so the root) still lives.

How far a shooting attempt's own landing value, y(b) for the guessed slope used, sits from the boundary-value problem's actual target.

A differential equation with one condition given at EACH of two different points, instead of a complete starting state at a single point.

An interval [a, b] known to contain a root because f(a) and f(b) have opposite signs.

Newton's method for systems, but the Jacobian is only ever computed once -- every later iteration cheaply patches the last approximation instead of recomputing it.

The precision that vanishes when two nearly equal floating-point numbers are subtracted, because the leading digits they shared cancel out and only rounding error is left behind.

Approximating a derivative from one point ahead and one point behind, straddling x symmetrically -- one order of accuracy better than using either side alone.

The polynomial whose roots are exactly a matrix's eigenvalues -- built directly from the matrix itself.

A specific, non-equally-spaced choice of interpolation nodes -- clustered near the ends of the interval -- that suppresses the Runge phenomenon.

The LU factorization's specialization to a symmetric positive-definite matrix: A = LL^T, using roughly half the arithmetic and never needing a pivot swap.

A rounding rule that simply drops every digit beyond the format's own limit, instead of rounding to the nearest representable value.

Closing a spline's system by forcing its slope at both endpoints to match two known values, instead of assuming nothing about them.

A picture of fixed-point iteration: alternating vertical moves to the curve y=g(x) and horizontal moves to the line y=x, tracing a staircase (converging) or a widening spiral (diverging).

The fixed number multiplying a variable or basis term in a polynomial, equation, or linear combination.

Applying a simple quadrature rule (midpoint, trapezoidal, or Simpson's) separately on each of many small panels covering [a,b], instead of once across the whole interval.

A single number estimating how much a problem magnifies a small relative error in its input into a relative error in its output.

How much a linear system A x = b can amplify a small relative error in b (or in A) into a relative error in the solution x -- the abstract condition number from Chapter 1, made concrete for exactly this one problem.

How sensitive a mathematical problem's own answer is to a small change in its input -- a property of the problem itself, not of whatever method is used to solve it.

An iterative method for symmetric, positive-definite systems that picks a smarter search direction every step instead of always following the steepest descent.

A precise label (C0, C1, C2, ...) for how many derivatives of a function stay continuous, used to compare exactly how smooth two curves each are.

A function that always shrinks the distance between two inputs by at least some fixed fraction k < 1 -- the property that makes fixed-point iteration provably converge.

To settle in, getting steadily closer to a fixed limiting value as a process continues, rather than wandering or blowing up.

The signed area under a curve between two fixed endpoints -- a single number, unlike the general antiderivative.

Once one eigenvalue is known, mathematically removing it so the SAME method can be reused, unmodified, to find the next one.

The highest polynomial degree a quadrature rule integrates exactly, every time -- not just approximately close.

The instantaneous rate of change of a function -- how fast its output moves as its input moves, at a single point.

A single number computed from a square matrix that is zero exactly when the matrix is singular -- has no inverse.

A matrix where every row's diagonal entry outweighs, in absolute value, the sum of every other entry in that same row -- a simple, cost-free check that guarantees Jacobi and Gauss-Seidel both converge.

Replacing a continuous problem -- an interval, a derivative, an integral -- with a finite set of numbers a computer can actually store and compute with.

A running average-of-slopes built recursively from data points, written f[x0,...,xk] -- the building block of Newton's interpolating-polynomial form.

Whichever eigenvalue of a matrix has the largest absolute value -- the one that ends up controlling A^k v for large k.

A nonzero vector that a matrix only stretches or shrinks, never rotates off its own line -- the direction that survives being multiplied by the matrix.

The three families a second-order PDE splits into, decided by the discriminant B^2-4AC of its second-derivative coefficients -- the same test, and the same three names, used for conic sections.

A numerical guess at a quantity, expected to be close but not exact -- an error estimate says roughly how far off it might be.

The true mathematical answer, computed with no approximation at all.

Two separate questions about a problem: does a solution exist at all, and if so, is it the only one?

The power-of-two scale factor stored alongside a floating-point number's digits, which sets its overall magnitude.

Using an interpolating polynomial to estimate f outside the range of the nodes it was built from -- a genuinely different, and much riskier, act than interpolating inside that range.

Replace y-prime-prime and y-prime at every interior grid point with a difference formula, all at once, and solve the resulting system for every unknown simultaneously -- no marching direction at all.

The rule that an elliptic problem's discretized interior grid point equals the plain average of its four immediate neighbors -- turning Laplace's equation into one large linear system this course's own Chapter 8 already knows how to solve.

A value p where a function g leaves its input unchanged: g(p) = p.

Doing +,-,\times,\div on floating-point numbers, where each result gets rounded back to a fixed number of stored digits instead of kept exactly.

A computer's usual way to store a real number: a sign, a fixed number of significant digits (the mantissa), and a power-of-two exponent that slides the decimal point.

Approximating a derivative from the current point and one point ahead of it.

The row-by-row method for solving a linear system: turn it into an equivalent triangular system, then solve that by back-substitution.

A quadrature rule that chooses BOTH where to sample and how much weight to give each sample, to maximize accuracy for a fixed number of evaluations -- unlike a composite rule's fixed, equally spaced grid.

The total error at a given point, after every step's own local error has compounded along the way.

Bisection's own idea, aimed at a minimum instead of a root: narrow a bracket by comparing two interior points, reusing one function value every step.

The vector of a multivariable function's partial derivatives -- it points in the direction that function grows fastest.

Interpolation that matches not just function values at each node but derivative values too, using each node twice.

Almost triangular: every entry below the FIRST subdiagonal is zero, one diagonal's worth of extra room past strictly triangular.

Morphing an easy problem with a known answer into the hard target problem, one small step at a time, re-solving with Newton's method at every stage from the previous stage's own answer.

A mirror-flip transformation, chosen to send one particular vector straight onto a coordinate axis while leaving lengths unchanged.

The function built to pass exactly through a given set of data points -- the output of an interpolation method, whatever form it takes.

The one polynomial of degree at most n that passes exactly through n+1 given data points.

Running the power method on A inverse instead of A, so it converges to the SMALLEST eigenvalue instead of the largest.

One step's output in an iterative method -- the current approximation, on its way toward (hopefully) the true answer.

Cheaply improving an already-computed approximate solution by solving one more, small system for the correction, reusing the same factorization instead of re-solving from scratch.

The iterative method for solving a linear system that updates every unknown at once, each time using only the previous round's values for the others.

The matrix of every partial derivative of a vector-valued function -- what an ordinary derivative becomes once there's more than one equation and more than one unknown.

One of the fixed points where two neighboring pieces of a spline meet.

One of n+1 building-block polynomials, each equal to 1 at its own node and 0 at every other node -- combining them with the data values assembles the interpolating polynomial directly.

The error a numerical ODE method introduces in a single step, if that step had started from an exact value.

Splitting a matrix A into a lower-triangular L and an upper-triangular U, with A = LU -- L records elimination's own multipliers, U is the result of eliminating with no row swaps.

The size of the smallest gap a floating-point format can represent right around the number 1 -- a direct measure of the format's own precision.

The size of a number or vector, ignoring its sign or direction -- how large it is, not which way it points.

The digits of a floating-point number's value, stored separately from its exponent -- together they give the number its magnitude.

How much a matrix can stretch a vector, at most -- extending a vector norm's own 'how big is this' question one level up, to 'how much can this matrix amplify any vector's size.'

A bracketing method that, like the secant method, replaces the midpoint with the chord's x-intercept -- but always keeps a valid bracket the way bisection does.

The two-stage Runge-Kutta method that predicts the slope at the step's MIDPOINT (instead of its far end) and uses that single slope for the whole step.

How many times a factor (x - p) divides a polynomial -- a root of multiplicity 1 crosses the x-axis, a root of even multiplicity only touches it.

The number Gaussian elimination multiplies a row by before subtracting it from another row, chosen to zero out one entry.

A method that reuses several of the SOLUTION's own recent slopes, already computed at earlier steps, instead of computing several new slopes within the current step.

Closing a spline's system by forcing zero curvature at both endpoints, the way an unforced flexible strip settles at its own free ends.

A way to evaluate the interpolating polynomial at one specific point by repeatedly blending shorter interpolants, without ever writing down the polynomial's coefficients.

Newton's method, one dimension higher: solve a linear system built from the Jacobian for the step, instead of dividing by a single derivative.

Not expressible as a straight line or a linear combination of the unknowns -- an equation where doubling the input does not simply double the output.

To rescale a vector so its length (norm) equals exactly 1, while keeping its direction unchanged.

A root-finding method (fixed-point iteration, Newton's method, the secant method) that tracks a single running guess instead of a shrinking bracket -- and so is never guaranteed to converge.

One arithmetic step -- one addition, subtraction, multiplication, or division -- the unit an algorithm's cost is counted in.

The step size h that minimizes TOTAL error -- small enough that truncation error is small, but not so small that round-off error, amplified by dividing by h, takes over.

The power of h that a method's truncation error shrinks like -- read directly off the exponent, or off the slope of a log-log error-vs-h plot.

How fast a sequence of approximations closes in on its limit -- whether each new error is a fixed fraction of the last, or shrinks much faster than that.

A set of basis functions built to be mutually perpendicular, so fitting with them needs no system to solve at all.

What happens when a computed number is too large in magnitude for the floating-point format to store at all.

The U-shaped curve traced by a degree-2 (quadratic) polynomial -- the graph of y=ax^2+bx+c.

A curve traced by two independent splines, x(t) and y(t), evaluated together at the same parameter t -- able to loop or cross itself, unlike any single y = S(x) spline.

Before eliminating a column, swapping in the row with the largest available entry there -- not just any nonzero one -- so the elimination multiplier that column produces never exceeds 1 in size.

The simplest spline: straight-line segments connecting each pair of neighboring data points.

A spline of quadratic pieces, chosen so the slope (but not necessarily the curvature) matches at every interior node.

Repeatedly multiplying a vector by A and rescaling it, so it swings around to point along A's own dominant eigen-direction.

Take a rough step with an explicit formula, then use that rough answer to plug into a MORE ACCURATE (but otherwise unusable) implicit formula and refine it.

Repeatedly factoring a matrix as Q times R, then multiplying the two factors back together in the OPPOSITE order -- somehow this drives the matrix toward triangular.

The single best number-guess for an eigenvalue you can squeeze out of a vector that's only approximately an eigenvector.

Solve a BVP by minimizing a single NUMBER attached to an entire candidate curve (a functional), rather than solving a difference equation.

A formula that defines each term of a sequence using one or more of the terms that came before it.

Defined in terms of a smaller version of itself -- computing the answer for n pieces of data by combining answers already computed for fewer pieces.

The absolute error measured as a fraction of the exact value's own size, so a gap of 1 can be tiny or huge depending on the context.

The dial \omega in SOR that scales how big a step each Gauss-Seidel update takes -- push past the plain update (\omega>1) to converge faster, or hold back (\omega<1) to steady a shaky iteration.

What a truncated approximation leaves out -- the exact gap between a finite formula and the true value it is approximating.

How far a candidate answer's outputs miss the target -- what's left over after plugging an approximate solution back into the original equation.

Combining two approximations computed at different step sizes to cancel their shared leading error term, producing a new approximation accurate to a higher order.

The most widely used Runge-Kutta method: four slope samples per step, weighted 1-2-2-1, buying two more orders of accuracy than Euler's method for four times the work per step.

Richardson extrapolation, applied repeatedly to a table of composite trapezoidal-rule estimates at doubling panel counts, to accelerate convergence dramatically.

The error introduced because a computer stores only finitely many digits of a number.

Wild, growing oscillation near the ends of the interval when a smooth function is interpolated at equally spaced nodes of increasing degree -- more nodes make it worse, not better.

A family of one-step methods that sample the slope at several cleverly chosen points within a single step, then combine them into one weighted-average step.

An open method that replaces Newton's tangent line with the line through the last two iterates, trading the need for f' for one extra stored point.

Half of a circle -- the geometric shape used to derive where Chebyshev nodes fall on the interval.

The inverse power method aimed at a specific target eigenvalue by first subtracting a guess for it off every diagonal entry.

Guess the missing initial slope, integrate forward as an ordinary IVP, and use how far the landing spot misses the target boundary value to correct the guess.

The number of leading digits in an approximation that are actually trustworthy, once the relative error is small enough.

A square matrix with no inverse -- one that collapses some nonzero vector down to zero, so it can't be undone.

The value, or set of values, that makes an equation or system true -- exact if it satisfies the equation perfectly, approximate if it only comes close.

The largest magnitude among a matrix's own eigenvalues -- the exact number that decides whether a linear iteration converges, no matter how it was built.

A curve built from several low-degree polynomial pieces glued together at shared points, instead of one polynomial spanning all the data.

Whether an algorithm keeps small round-off errors from growing out of control as it runs -- a property of the algorithm, not of the problem it's solving.

Moving opposite the gradient of the total squared residual, to guarantee SOME progress when Newton's own step is too risky or undefined.

An ODE where an EXPLICIT method's stability (not its accuracy) is what actually forces the step size to be tiny.

Convergence faster than a fixed fraction per step (linear) but not quite the squaring speed of quadratic convergence -- the secant method's own rate.

A square matrix that equals its own transpose -- flipping it across the main diagonal leaves it unchanged.

A mathematical statement that has been proved true, given its stated assumptions -- as opposed to an observation that merely looks true.

A fast method for solving a tridiagonal system by one forward sweep and one backward sweep, instead of full Gaussian elimination.

How close is close enough -- the error threshold an iterative method is allowed to stop at, chosen by whoever runs it.

The quadrature rule that approximates the area under a curve on each subinterval by the area of the trapezoid connecting its two endpoint values.

A square matrix whose entries are all zero on one side of the main diagonal -- upper triangular above, lower triangular below.

A system of linear equations where each equation only involves its own unknown and its two immediate neighbors.

The error from replacing an exact mathematical process (an infinite sum, a limit) with a finite number of steps.

What happens when a computed number is too small in magnitude for the floating-point format to represent as a normal number, and gets rounded down to zero instead.

A function that decreases, hits one minimum, then increases -- the one-dimensional-optimization analogue of a bracket where f changes sign.

A matrix built entirely from powers of one set of values -- 1, x, x^2, and so on -- whether solved exactly (Chapter 3) or fit by least squares (Chapter 9).