Finding next IEEE 754 representable number (towards -INF) with C?

Question

I am trying to write a function that takes in a 32-bit floating point number (that has been converted from a 32-bit binary string) and returns the previous representable float in 32-bit binary. So far I have the conversion from binary to float down, but I am having troubles understanding how to find the next representable IEEE 754 value. Can't you just subtract the smallest representable value possible (000 0000 0000 0000 0000 0001)? Also, what (if any) are the benefits of converting from IEEE 754 to Float before finding the closest representable binary value?

So far I only have a function that converts a floating point number to simple precision 32-bit binary. I would include my code, but this is for school so I feel iffy about putting it online/getting explicit corrections and advice.

1) Post what you have. 2) Hint: float-->binary, binary ++ or --, binary --> float. — chux - Reinstate Monica, Oct 19 '14 at 18:00
What is this "conversion" from a 32-bit binary bit string to a 32-bit `float`? — Keith Thompson, Oct 19 '14 at 19:23
My program takes in a binary in the form of an int array[32], and then translates the sign, exponent, and mantissa into the floating point number. — user3614396, Oct 19 '14 at 21:43

chux - Reinstate Monica · Accepted Answer · 2014-10-19T18:34:25.837

Q: Can't you just subtract the smallest representable value possible?
A: No. Floating point numbers are distributed logarithmically, not linearly. Subtracting any fixed value like 0.000001 would have no effect on large float and have overly large effects on tiny float values.

Q: what ... are the benefits of converting from IEEE 754 to Float before finding the closest representable binary value?
A: "IEEE 754" to "Float" are typically the same type - no conversion occurs. Both are 32-bit numeric representations.

Following depends on float being IEEE 754 binary32. It also depend on the endian of the int32_t and float to match. It returns NaN when the input is -INF.

float nextdown(float x) {
  union {
    float x;
    int32_t i;
  } u;
  u.x = x;
  if (u.i > 0) {
    u.i--;
  }
  else if (u.i < 0) {
    u.i++;
  }
  else {
    u.i = 0x80000001;
  }
  return u.x;
}

The above does not well handle NaN. A simple extra test:

float nextdown(float x) {
  // catch NaN
  if (x != x) return x;

  union {
    float x;
    int32_t i;
  } u;
  ...

Note: OP's desired function is nearly the exact same as <math.h> nextafterf(x,-1.0f/0.0f) which was used to test this code. Differences in NaN and -INF.

I've looked at the nextafterf() function from math.h, but couldn't make sense of it enough to effectively apply aspects of it to my code. — user3614396, Oct 19 '14 at 18:41
@user3614396 `nextafterf()` takes 2 arguments `x` and `y`. It returns the _next_ representable `float` nearest `x` in the direction of `y`. So `nextafterf(1.0f, 2.0f)` returns a number just larger than 1.0f. `nextafterf(1.0f, 0.0f)` returns a number just smaller than 1.0f. `nextafterf(1.0f, 1.0f)` returns `1.0f`. — chux - Reinstate Monica, Oct 19 '14 at 18:43

Finding next IEEE 754 representable number (towards -INF) with C?

1 Answers1