Introduction

If a platform has fast float support but slow or unavailable double, you can represent one high-precision value as the sum of two single-precision values. This technique is often called double-single arithmetic: one float stores the leading digits and the second stores the rounding error.

It does not produce a true IEEE double, and it does not automatically solve all numerical problems. Still, it can give substantially more precision than a plain float and is useful in graphics, DSP, and specialized numeric code.

The Core Idea

Suppose you store a number as hi + lo, where hi is the main value and lo is a correction term. The pair should be normalized so that hi contains the dominant part and lo is small compared with it.

A simple way to create such a pair from a float is:

1struct ds_float {
2    float hi;
3    float lo;
4};
5
6inline ds_float make_ds(float value) {
7    return ds_float{value, 0.0f};
8}

The hard part is keeping the pair accurate after arithmetic. For addition, a common strategy is the two_sum algorithm, which computes both the rounded sum and the lost low-order bits.

1#include <cmath>
2#include <iostream>
3
4struct ds_float {
5    float hi;
6    float lo;
7};
8
9inline ds_float normalize(float hi, float lo) {
10    float s = hi + lo;
11    float e = lo - (s - hi);
12    return ds_float{s, e};
13}
14
15inline ds_float add(ds_float a, ds_float b) {
16    float s = a.hi + b.hi;
17    float v = s - a.hi;
18    float e = (a.hi - (s - v)) + (b.hi - v);
19    e += a.lo + b.lo;
20    return normalize(s, e);
21}
22
23int main() {
24    ds_float a = make_ds(10000000.0f);
25    ds_float b = make_ds(1.0f);
26    ds_float c = add(a, b);
27
28    std::cout << "hi=" << c.hi << " lo=" << c.lo << '\n';
29    std::cout << "combined=" << static_cast<double>(c.hi) + c.lo << '\n';
30}

On a normal float, 10000000.0f + 1.0f may round back to 10000000.0f. With a double-single representation, the missing unit can often be preserved in lo.

What You Gain and What You Do Not

This representation can deliver roughly twice the precision of a single float in many operations, but it is not a perfect substitute for hardware double.

Important limits:

• The exponent range is still basically the float exponent range.
• Every arithmetic operation must be implemented carefully.
• Transcendental functions such as sin or log need custom versions if you want consistent extra precision.
• Compiler optimizations that reorder floating-point expressions can break carefully designed error tracking.

In other words, two floats can emulate higher precision arithmetic, but they do not magically become the built-in double type.

Where This Technique Is Useful

Historically, GPUs and older SIMD pipelines made double-single arithmetic attractive because single-precision math was much faster. It also appears in code that wants predictable storage layouts or must run on systems where double support is restricted.

For application code on modern desktop or server CPUs, native double is usually the better choice. It is simpler, faster to maintain, and integrates cleanly with math libraries. Emulating double with two float values only makes sense when you have a concrete platform or compatibility constraint.

If you need even more precision, libraries based on arbitrary-precision arithmetic are often a better investment than hand-rolled multi-float types.

Common Pitfalls

A common misconception is that storing two unrelated float values gives you extra precision automatically. It does not. The pair only works when each arithmetic operation is designed to preserve the rounding residual in the low component.

Another pitfall is ignoring normalization. If lo becomes too large relative to hi, later operations lose the benefit of the split representation. Normalize after arithmetic so that hi carries the main magnitude and lo stays small.

Performance can also disappoint. Double-single arithmetic often uses many more instructions than native double, so it is only worthwhile when the target hardware strongly favors float.

Finally, test with adversarial inputs, not only easy values. Large plus small, cancellation, and repeated accumulation are the cases that reveal whether the implementation is actually preserving precision.

Summary

• A higher-precision value can be represented as hi + lo using two float values.
• The technique is usually called double-single arithmetic.
• Extra precision only appears if operations preserve the rounding error explicitly.
• The exponent range still behaves like float, not true IEEE double.
• Use it only when native double is unavailable, too slow, or otherwise unsuitable.