Mixed-Precision Arithmetic

In the world of scientific computing, there exists a fundamental trade-off. On one hand, we have high-precision formats like double-precision, which offer the accuracy needed to capture the fine details of physical phenomena but come at a significant cost in speed, memory, and energy. On the other hand, low-precision formats are fast and efficient but are more susceptible to round-off errors that can compromise a calculation's validity. This dilemma forces a choice between accuracy and performance. Is it possible to get the best of both worlds?

This article introduces mixed-precision arithmetic, a sophisticated strategy that resolves this conflict. By not treating precision as an all-or-nothing choice, but rather as a resource to be allocated strategically, we can design algorithms that are fast, memory-efficient, and highly accurate. This article explores how to achieve this computational harmony.

In the upcoming chapters, we will first delve into the "Principles and Mechanisms," exploring the origins of numerical error and how mixed-precision techniques like iterative refinement and high-precision accumulation surgically correct for them. Following that, in "Applications and Interdisciplinary Connections," we will journey through diverse scientific fields—from linear algebra and quantum chemistry to molecular dynamics and artificial intelligence—to witness how this powerful principle is unlocking the next generation of discovery.

Imagine you are a sculptor, and your block of wood is the real, continuous world of mathematics. Your chisels are the algorithms you use to carve out a solution to a problem. But there's a catch: you're working in a digital universe. Your computer can't represent the infinitely smooth curves of the real world. It can only work with a finite set of points, much like a picture made of pixels. This fundamental limitation is the birthplace of round-off error.

In the world of scientific computing, we primarily use ​​floating-point numbers​​ to approximate real numbers. Think of them as a form of scientific notation, storing a number as a mantissa (the significant digits) and an exponent. The most common formats are single precision (often called float or binary32) and double precision (double or [binary64](/sciencepedia/feynman/keyword/binary64)). A double uses more bits, allowing it to store more significant digits and represent a much wider range of numbers than a float. The precision of these formats is quantified by the ​​unit roundoff​​, $\epsilon_{\text{mach}}$, which is roughly the smallest number that, when added to $1$, gives a result different from $1$. For single precision, $\epsilon_{\text{mach}} \approx 10^{-7}$, while for double precision, it's a fantastically smaller $\epsilon_{\text{mach}} \approx 10^{-16}$.

When we solve a problem numerically, say, using a finite difference method with grid spacing $h$, the total error in our answer comes from two competing sources:

1. ​​Truncation Error​​: This is the error we knowingly introduce by approximating a continuous problem with a discrete one. For a well-behaved method of order $p$, this error is proportional to $h^p$. As we make our grid finer (decrease $h$), this error shrinks rapidly. This is like choosing to carve a smoother, more detailed sculpture by making smaller, more careful cuts.

2. ​​Round-off Error​​: This is the "sawdust" of computation. Every time the computer performs an operation, it rounds the true mathematical result to the nearest representable floating-point number. These tiny errors, on the order of $\epsilon_{\text{mach}}$, accumulate. Worse, in many numerical schemes, the formulas involve dividing by powers of $h$. As $h$ becomes tiny, this division dramatically amplifies the round-off error, which can grow like $\epsilon_{\text{mach}} / h^k$ for some power $k$.

This creates a fundamental tension. As we decrease $h$ to reduce our truncation error, we amplify the round-off error. If you plot the total error against $h$, you'll see a characteristic U-shaped curve. Initially, as $h$ shrinks, the error goes down, following the theoretical $h^p$ path. But at a certain point, the growing round-off noise begins to swamp the signal, and the error flattens out and may even start to rise again. The higher unit roundoff of single precision means this "round-off floor" is hit much earlier, for a much larger value of $h$, than with double precision. This limits the maximum accuracy we can achieve.

Given this, why wouldn't we just use double precision for everything? The answer is simple: cost. High precision comes at a steep price in performance, memory, and energy.

A double-precision number takes up twice as much memory as a single-precision one. For the colossal problems in modern science—simulating a galaxy, designing a wing, or training a large language model—this can be the difference between a problem fitting into a computer's memory or not.

Furthermore, speed matters. On modern computer hardware, and especially on Graphics Processing Units (GPUs) that power so much of high-performance computing, arithmetic operations on lower-precision numbers can be dramatically faster. These chips are often designed with specialized silicon that can execute, for instance, two single-precision operations or even more half-precision operations in the time it takes to perform one double-precision operation. This performance advantage, which we can represent by a ratio $\gamma 1$, creates a powerful incentive to avoid double precision wherever possible.

We are thus caught in a dilemma: we want the accuracy of double, but we crave the speed and efficiency of float. Is there a way to get the best of both worlds?

This is where the elegant idea of ​​mixed-precision arithmetic​​ comes into play. The core principle is to strategically combine different precisions within a single computation: use fast, low precision for the heavy lifting, but deploy slow, high precision only for the few, critical parts of the calculation that are most vulnerable to error.

Let's look at a simple, concrete example: evaluating a long polynomial. We can do this in three ways:

• ​​Single Precision:​​ We store the polynomial's coefficients as floats and do all math in single precision. This is fast and memory-efficient, but the round-off errors accumulate with each multiplication and addition, potentially leading to an inaccurate final result.
• ​​Double Precision:​​ We store everything as doubles and compute in double precision. This is highly accurate but uses twice the memory for storage.
• ​​Mixed Precision:​​ We store the coefficients in single precision, saving memory. But for the actual computation, we temporarily convert the numbers to double precision inside the calculation loop.

The result is remarkable. The mixed-precision strategy yields an answer with an error nearly as small as the full double-precision strategy, while retaining the low memory footprint of the single-precision approach. The reason this magic trick works is that the error from the initial storage of the data is a one-time hit. The most insidious errors are those that compound at each step of a long calculation. By performing the arithmetic in a more precise "workspace," we keep this devastating error accumulation at bay.

So, what are these "critical parts" of a calculation that demand our utmost care? It turns out they often fall into a few categories.

​​1. Big Sums and Accumulation​​

Many scientific computations involve summing up a vast number of terms, like calculating a dot product. Each term in the sum may be computed with a small error. When you add thousands or millions of these terms, the errors can pile up. A brilliant strategy is to compute the individual products in low precision, but add them into a high-precision ​​accumulator​​.

This is like trying to find the total weight of a million grains of dust. You might use a cheap, fast scale for each individual grain (the low-precision multiplication), but you would be wise to collect them all in a hyper-accurate, industrial-grade container (the high-precision accumulator) to get a trustworthy final weight. Mathematical analysis, using statistical models of error, confirms that this approach scales remarkably well, with the total error growing much slower than the number of terms would suggest. This very principle is etched into the silicon of modern GPUs, forming the basis of "Tensor Cores" that have revolutionized machine learning.

​​2. Tiny Differences and Iterative Refinement​​

The other great numerical villain is "catastrophic cancellation"—the error that results from subtracting two nearly identical numbers. The tiny difference you are left with can be dominated by noise from the initial rounding of the large numbers.

This issue is central to ​​iterative refinement​​, a powerful technique for solving linear systems of equations $A\mathbf{x} = \mathbf{b}$. The process often goes like this:

1. Find an approximate solution $\mathbf{x}_0$, perhaps using a fast, low-precision solver.
2. Calculate how wrong you are. This "wrongness" is measured by the residual vector: $\mathbf{r} = \mathbf{b} - A\mathbf{x}_0$.
3. Solve for a correction, $\Delta\mathbf{x}$, using the residual (i.e., solve $A(\Delta\mathbf{x}) = \mathbf{r}$).
4. Update your solution: $\mathbf{x}_1 = \mathbf{x}_0 + \Delta\mathbf{x}$. Repeat.

The trap lies in Step 2. If $\mathbf{x}_0$ is already a good approximation, then $A\mathbf{x}_0$ will be extremely close to $\mathbf{b}$. If you compute this subtraction using low precision, you might get a result of zero—not because your answer is perfect, but because your computational tool is too crude to measure the minuscule remaining error. The algorithm would then halt, thinking its job is done.

The solution is to be selectively careful: ​​compute the residual $\mathbf{r}$ in high precision.​​ This allows you to accurately resolve that tiny difference, which contains the essential information for the next correction. The correction step itself (Step 3) can then be done in fast, low precision. This allows us to "polish" a low-precision result to high-precision accuracy, often faster than solving the whole problem in high precision from the start.

​​3. The Villain's Power: Ill-Conditioning​​

This refinement trick is wonderfully effective, but it has an Achilles' heel: ​​ill-conditioning​​. Some matrices $A$ are inherently sensitive, meaning they amplify small input errors into large output errors. The "condition number," $\kappa(A)$, measures this sensitivity.

For iterative refinement to work, the problem must not be too sensitive for the low precision being used. There's a rule of thumb: the method converges if $\kappa(A) \cdot u_{\text{low}} 1$, where $u_{\text{low}}$ is the unit roundoff of the low-precision arithmetic. If this product is greater than one, the error amplification from the matrix is so severe that the correction calculated in low precision is essentially noise, and the refinement process fails to make progress.

This same principle applies to more advanced iterative algorithms like the Conjugate Gradient (CG) method, which are workhorses for solving the massive linear systems that arise from physical simulations [@problem_id:2395219, @problem_id:2580646]. To maintain stability and convergence, critical calculations like dot products and residual updates must be done in high precision, while the computationally heavy matrix-vector products can be relegated to low precision for speed.

Mixed-precision arithmetic is not a messy hack; it is a sophisticated and principled strategy. It is about deeply understanding the structure of an algorithm, identifying its most sensitive components, and allocating our finite computational budget accordingly.

You can think of it as conducting a symphony. The full orchestra doesn't play at maximum volume all the time. The vast string section might represent the bulk computations—the matrix-vector products—which can be performed quickly and efficiently in low precision. But at a critical moment, a solo trumpet—a high-precision residual calculation—must ring out with perfect clarity to guide the entire piece.

This is not just a beautiful analogy. Engineers can write down rigorous mathematical proofs, starting from the basic axioms of floating-point error, to derive error bounds and formally validate that a mixed-precision algorithm will perform as expected. By composing this symphony of precisions, we create computations that are faster, leaner, and more energy-efficient, all without sacrificing the accuracy that scientific progress demands. It is a stunning example of the harmony between abstract mathematics, computer engineering, and the practical art of solving real-world problems.

We have spent some time understanding the rules of this game of computation, the different ways we can represent numbers with a finite number of bits. You might be left with the impression that the game is about always choosing the highest precision possible to get the most accurate answer. But that, my friends, is like using a Swiss watchmaker's toolkit to hammer a nail. It's not just overkill; it's clumsy. The real art of scientific computation, the true mark of an expert, is knowing exactly how much precision is needed for each part of a job, and no more. It is the art of being "just precise enough." This philosophy, of mixing and matching precisions like a master chef combines ingredients, is what we call mixed-precision arithmetic. It is not a compromise on quality; it is a profound strategy that has revolutionized our ability to simulate the universe, from the dance of galaxies to the flutter of a protein.

Let us embark on a journey through the vast landscape of science and engineering to see this beautiful principle in action.

At the core of nearly every scientific simulation lies a system of linear equations, often written as the deceptively simple $A\mathbf{x} = \mathbf{b}$. Whether we are modeling the stress on a bridge, the flow of air over a wing, or the electronic structure of a molecule, we eventually face the task of solving for $\mathbf{x}$. For large problems, this is the most demanding part of the entire calculation. Here, mixed precision performs its most fundamental and elegant trick.

Imagine you are trying to find the solution to a very difficult, "ill-conditioned" system of equations—one where tiny changes in the problem lead to huge changes in the answer. A brute-force approach in high precision (like $64$-bit double) is safe, but slow and memory-hungry. The mixed-precision strategy is far more cunning. It's a process of "guess, check, and correct."

First, you perform the most computationally expensive step—the factorization of the matrix $A$—in a lower, faster precision, say $32$-bit single. This gives you a quick and dirty approximate solution, $\hat{\mathbf{x}}$. Now comes the clever part. You take this rough answer and, in high precision (double), you calculate how wrong it is. You compute the "residual," $\mathbf{r} = \mathbf{b} - A \hat{\mathbf{x}}$. Because this subtraction is the moment of truth where you find a small error, it must be done carefully. With your precisely-calculated error $\mathbf{r}$, you then use your fast, low-precision solver again to find a correction, $\mathbf{\delta}$, by solving $A \mathbf{\delta} = \mathbf{r}$. Finally, you update your solution in high precision: $\mathbf{x} \leftarrow \hat{\mathbf{x}} + \mathbf{\delta}$. This process, known as ​​iterative refinement​​, can be repeated. Each step polishes the solution, using the speed of low-precision arithmetic for the heavy lifting and the accuracy of high-precision for the delicate checks and balances. This allows us to achieve full double-precision accuracy while performing the bulk of the computation at single-precision speeds, a remarkable feat of computational thrift.

This "work fast, check carefully" philosophy is the soul of modern iterative solvers. In methods like the ​​Conjugate Gradient (CG)​​ or ​​GMRES​​, the most frequent operation is the matrix-vector product, $A\mathbf{p}$. This can often be performed in a very low precision, like $16$-bit half, especially on specialized hardware. However, the parts of the algorithm that ensure convergence—calculating inner products to determine step sizes or performing Gram-Schmidt orthogonalization to build a stable basis—are exquisitely sensitive to error. These are kept in $64$-bit double. The algorithm thus runs in a two-speed rhythm: a furious, low-precision gallop for the matrix products, punctuated by careful, high-precision steps to stay on course.

Sometimes, the matrix $A$ is so difficult that the solver needs a "guide"—a ​​preconditioner​​ $M$ that approximates $A$ but is much easier to deal with. Since the preconditioner is already an approximation, it's a natural candidate for lower-precision arithmetic. We can construct an Incomplete LU factorization, for instance, using $32$-bit floats and use it to guide a high-precision solver, again saving time and memory where it is most effective.

These algorithmic ideas do not exist in a vacuum. They are deeply intertwined with the very design of modern computer hardware. Today's Graphics Processing Units (GPUs) contain specialized circuits, like NVIDIA's Tensor Cores, that are paragons of mixed-precision computing. They can perform certain low-precision operations, like a $16$-bit multiply followed by a $32$-bit add, at blistering speeds far beyond what is possible with standard $64$-bit arithmetic.

However, this power comes with a fascinating subtlety. One of the first things we learn in arithmetic is that addition is associative: $(a+b)+c = a+(b+c)$. For floating-point numbers, this is not true! The order of operations matters. In a matrix-free method, where the effect of matrix $A$ is computed on-the-fly by summing up contributions from thousands of independent elements in parallel, the order of summation can be different every time. This can cause the computed operator, $\widetilde{A}$, to have a small but significant ​​non-symmetric​​ part, even if the true operator $A$ is perfectly symmetric. This is a disaster for an algorithm like Conjugate Gradient, which relies absolutely on symmetry.

But here too, cleverness prevails. We can restore the lost symmetry, for example, by explicitly applying $\frac{1}{2}(\widetilde{A} + \widetilde{A}^\top)$, or by using more sophisticated accumulation schemes. Techniques like ​​compensated summation​​ act like a diligent bookkeeper, tracking the tiny rounding errors from each addition and adding them back into the total, dramatically improving accuracy. This allows us to harness the immense power of specialized hardware without falling victim to its numerical quirks. Ultimately, for the most demanding problems, we can wrap our fast, mixed-precision inner solver inside a high-precision outer loop of iterative refinement. This two-level approach gives us the best of both worlds: the raw speed of specialized hardware and the guaranteed accuracy of a high-precision framework.

The principle of mixed precision extends far beyond solving linear equations. It is a universal strategy for computational science.

In ​​digital signal processing​​, when convolving a long signal with a filter, a common technique is to use the Fast Fourier Transform (FFT). The process can be done in blocks, where each block is transformed, multiplied in the frequency domain, and transformed back. The bulk of this work—the millions of multiplications and additions inside the FFTs—can be done rapidly in single precision. But the final step, where the processed blocks are stitched together ("overlap-add"), involves adding numbers that might have very different magnitudes. Performing this final accumulation in double precision ensures that no information is lost, yielding a high-fidelity result at a fraction of the full-precision cost.

Nowhere, however, is the impact of mixed precision more profound than in the simulation of the physical world.

In ​​quantum chemistry​​, calculating the interactions between electrons generates a colossal number of "two-electron integrals," whose count can scale as the fourth power of the system size, $N^4$. For even modest molecules, storing these integrals becomes a primary bottleneck. By simply changing their storage format from $64$-bit double to $32$-bit single, we instantly halve the memory and disk requirements—a monumental gain. While this introduces tiny perturbations in the final computed energy, the error is often far smaller than the intrinsic accuracy of the theoretical model itself. This simple change can make a previously impossible calculation feasible. This strategy extends to the most advanced and computationally demanding methods, like Coupled Cluster theory, where the complex web of tensor contractions can be safely accelerated by using single-precision products with double-precision accumulators, so long as the most sensitive parts of the algorithm remain in high precision.

In ​​molecular dynamics (MD)​​, we simulate the motion of atoms and molecules over time. Here, mixed precision reveals a beautiful and crucial lesson about numerical stability. In each tiny time step $\Delta t$, a particle's position $\mathbf{r}$ is updated by adding a small displacement, $\delta \mathbf{r}$. The problem is that $\mathbf{r}$ might be a large number (the particle's location in the simulation box), while $\delta \mathbf{r}$ is very small. If we store the position $\mathbf{r}$ in single precision, the addition $\mathbf{r} + \delta \mathbf{r}$ might completely swallow the displacement, as if trying to measure the width of a hair with a yardstick. The particle would simply get stuck! The simulation would grind to a halt or produce nonsensical results. The solution is to store and update the positions in double precision. However, the most expensive part of an MD simulation—calculating the forces between thousands of atoms—can often be done in single precision, as these forces are used to compute the small displacement, not to update the large position directly. This hybrid approach preserves the long-time stability and energy conservation of the simulation while dramatically speeding it up.

This brings us to the cutting edge of modern science: the use of ​​Artificial Intelligence​​ and ​​Neural Networks (NNs)​​ to model physical phenomena. Scientists now train NNs to act as "potential energy surfaces," which can calculate the forces on atoms orders of magnitude faster than traditional quantum methods. Training and running these massive NNs is a perfect arena for mixed precision. But here, the stakes are even higher. A small error in the predicted forces, caused by low-precision arithmetic, can act like a non-conservative "phantom force," continuously pumping or draining energy from the simulated system, leading to unphysical heating or cooling. Furthermore, these errors can alter the "stiffness" of the molecular system, which could violate the stability conditions of the integrator. Therefore, deploying a mixed-precision NN potential requires a new level of rigor: we must analyze how precision affects the predicted forces and ensure that the resulting energy drift remains below a tolerable threshold, a perfect marriage of machine learning, numerical analysis, and physics.

From linear algebra to machine learning, from signal processing to simulating the very fabric of matter, a single, unifying theme emerges. Mixed-precision arithmetic is not a shortcut or a hack. It is a deep-seated principle of computational science. It is the recognition that different parts of a problem have different structures, different sensitivities, and different demands. It is the art of understanding your problem so well that you know where you can afford to be approximate and where you must be exact. In a world where our hunger for computational power is insatiable, mixed precision is the key that unlocks the next generation of discovery, allowing us to solve problems bigger, faster, and more efficiently than ever before. It is the beautiful and powerful art of computational thrift.