Introducing single precision separation as double precision multiplication

Question

Question

For the C99 compiler implements exact arithmetic IEEE 754, there are values f, divisorsuch as float, such that f / divisor != (float)(f * (1.0 / divisor))?

EDIT: "By doing the exact arithmetic of IEEE 754," I mean a compiler that rightly defines FLT_EVAL_METHOD as 0.

Context

The AC compiler, which provides IEEE 754 floating point compatibility, can only replace single-point division by constant by one multiplication by the opposite, if the specified inverter itself is represented exactly as float.

In practice, this happens only for the powers of the two. Therefore, programmer Alex can be sure that it f / 2.0fwill be compiled as if it were f * 0.5f, but if it is permissible for Alex to multiply by 0.10finstead of dividing by 10, Alex must express this by writing multiplication in the program or using a compiler parameter such as GCC -ffast-math.

This question is related to the conversion of division with one precision into multiplication with double precision. Does it always give the correct rounded result? Is it likely that this could be cheaper, and therefore be an optimization that compilers can do (even without -ffast-math)?

(float)(f * 0.10) f / 10.0f f 1 2, . float, .

:

#include <float.h>
#include <math.h>
#include <stdio.h>

int main(void){
  for (float divisor = 1.0; divisor != 2.0; divisor = nextafterf(divisor, 2.0))
    {
      double factor = 1.0 / divisor; // double-precision inverse
      for (float f = 1.0; f != 2.0; f = nextafterf(f, 2.0))
        {
          float cr = f / divisor;
          float opt = f * factor; // double-precision multiplication
          if (cr != opt)
            printf("For divisor=%a, f=%a, f/divisor=%a but (float)(f*factor)=%a\n",
                   divisor, f, cr, opt);
        }
    }
}

, (2 ⁴⁶). . - , - , , , , ?

Answer 1

, . :

, f divisor 1.0 2.0. , f = a / 2^23 divisor = b / 2^23 a b [2^23, 2^24). divisor = 1.0 , , b > 2^23.

, (float)(f * (1.0 / divisor)) , , f / divisor (.. ), f * (1.0 / divisor) .

. , f >= divisor, [1.0, 2.0). [1.0, 2.0) c / 2^24 c 2^24 < c < 2^25. f / divisor a / b, f / divisor - c / 2^24 1 / (2^24 b), 1 / 2^48 ( b < 2^24). , , 16 double-precision ulps , , 16 ulps. ( , , 3 ulps.)

, f / divisor . , f / divisor : c , c 2^24 , , c / 2^24 = a / b, - b 2^24. b (2^23, 2^24), .

, f < divisor : c / 2^25, , abs(f / divisor - c / 2^25) , 1 / 2^49, 16 , .

Answer 2

, , , . , 3.0f / 3.0f 3.0f * C C , , , C , .

, , , . , -.

Answer 3

.

It seems that when the result is a “denormal / subnormal” number, this inequality is possible. But then, maybe my platform does not comply with IEEE 754?

f        0x1.7cbff8p-25 
divisor -0x1.839p+116
q       -0x1.f8p-142
q2      -0x1.f6p-142

int MyIsFinite(float f) {
  union {
    float f;
    unsigned char uc[sizeof (float)];
    unsigned long ul;
  } x;
  x.f = f;
  return (x.ul & 0x7F800000L) != 0x7F800000L;
}

float floatRandom() {
  union {
    float f;
    unsigned char uc[sizeof (float)];
  } x;
  do {
    size_t i;
    for (i=0; i<sizeof(x.uc); i++) x.uc[i] = rand();
  } while (!MyIsFinite(x.f));
  return x.f;
}

void testPC() {
  for (;;) {
    volatile float f, divisor, q, qd;
    do {
      f = floatRandom();
      divisor = floatRandom();
      q = f / divisor;
    } while (!MyIsFinite(q));
    qd = (float) (f * (1.0 / divisor));
    if (qd != q) {
      printf("%a %a %a %a\n", f, divisor, q, qd);
      return;
    }
  }

}

PC Eclipse Version: Juno Service Release 2 Build ID: 20130225-0426