How can double-precision addition be emulated using single-precision floats in embedded systems?

Emulating Double-Precision Arithmetic with Single-Precision Floats

In the realm of embedded systems with limited floating-point capabilities, the need arises to emulate double-precision data structures using single-precision ones. This article tackles the challenge of implementing double-precision addition and comparison operations using pairs of single-precision floats.

Comparison

Comparing two emulated double values is a straightforward affair. We employ lexicographic ordering, comparing the tuple elements sequentially. (d1.hi > d2.hi) OR ((d1.hi == d2.hi) AND (d1.low > d2.low))

Addition

Emulating double-precision addition proves trickier. We need to determine a base to use and a method to detect carries.

Base Selection

FLT_MAX is an unsuitable base because it introduces unwanted overflow and underflow issues. Instead, we adopt a floating-point format with a larger exponent range but reduced precision, referred to as "double-float."

Carry Detection

Let d1 and d2 be the two emulated double values to be added. We first sum d1.hi and d2.hi:

result.hi = d1.hi + d2.hi

If result.hi overflows, we know there's a carry. In this case, we decrement result.hi by 1 and add 1 to result.low. If result.hi underflows, we increment it by 1 and subtract 1 from result.low.

if (result.hi overflowed)
{
    result.hi--;
    result.low++;
}
else if (result.hi underflowed)
{
    result.hi++;
    result.low--;
}

We then add d1.low and d2.low to result.low:

result.low += d1.low + d2.low

If result.low overflows, we increment result.hi by 1. If it underflows, we decrement result.hi by 1.

if (result.low overflowed)
{
    result.hi++;
}
else if (result.low underflowed)
{
    result.hi--;
}

Finally, we return the emulated double result with (result.hi, result.low).

This methodology, based on the work of Dekker and Kahan, enables us to emulate double-precision addition with reasonable accuracy and efficiency in an environment constrained to single-precision arithmetic.

The above is the detailed content of How can double-precision addition be emulated using single-precision floats in embedded systems?. For more information, please follow other related articles on the PHP Chinese website!