Standards compliant way to compare float to integral?

Question

Let's say I have two objects i and f of respective types I and F. I know that std::is_integral<I>::value is true, and std::is_floating_point<F>::value is true.

Is there a fully standards-compliant way to find out if the value of i is smaller than the value of f? Note the emphasis on 'fully standards-compliant', for this question I'm only interested in answers that are backed up by guarantees from the C++ standard.

---

The trivial implementation i < I(f) doesn't work, because the value of f may not fit inside i. The trivial implementation F(i) < f doesn't work either, because the precision of f may not be enough to represent i, causing i to get rounded to a value equal to f (if you have IEEE754 floats, 16777219 < 16777220.f fails).

But here comes the real dilemma: if you want to use std::numeric_limits::max to alleviate these problems, your back to the original problem of comparing floats and integers! This is because the type of std::numeric_limits::max is equal to the original type.

Answer 1

1. If f is outside the range of I, you can tell the result just by its sign.

2. If f is inside the range of I but too big to have a fractional part, compare it as an integer.

3. Otherwise, it's safe to cast i to F because the rounding will not change the result of the comparison: f is already smaller than any value of I that would be rounded.

.

template< typename I, typename F >
std::enable_if_t< std::is_integral_v< I > && std::is_floating_point_v< F >,
bool > less( I i, F f ) {
    // Return early for operands of different signs.
    if ( i < 0 != f < 0 ) return i < 0;

    bool rev = i >= 0;
    if ( rev ) {
        f = - f; // Make both operands non-positive.
        i = - i; // (Negativity avoids integer overflow here.)
    }

    if ( f < /* (F) */ std::numeric_limits<I>::min() ) {
        // |i| < |f| because f is outside the range of I.
        return rev;
    }
    if ( f * std::numeric_limits<F>::epsilon() <= -1 ) {
        // f must be an integer (in I) because of limited precision in F.
        I fi = f;
        return rev? fi < i : i < fi;
    }
    // |f| has better than integer precision.
    // If (F) |i| loses precision, it will still be greater than |f|.
    return rev? f < i : i < f;
}

Demo: http://coliru.stacked-crooked.com/a/b5c4bea14bc09ee7

Answer 2

This is how I would do it:

I presume that f is finite, the cases of infinite and NaN are to be handled elsewhere.

1. compare f and F(i), if not equal, you're done, f and i are either < or >

2. if equal, then compare I(f) and i

The only assumptions are:

• if there is a float having exactly the value i, then F(i) gives that value

• if there is an integer having exactly same value as f, then I(f) gives that value

• monotonicity of functions F and I

EDIT

To be more explicit, above tricks are for writing a comparison function, not just testing equality...

floatType F(intType i);
intType I(floatType f);
int cmpfi(floatType f,intType i)
{
  assert(isfinite(f));
  if(f < F(i)) return -1;
  if(f == F(i))
  {
    if( I(f) < i ) return -1;
    return I(f) > i;
  }
  return 1;
}

Up to you to transform this draft into a C++ code that can handle several different floatType/intType