Сравнение uint64_t и float для числовой эквивалентности

Конечно, есть числа, для которых это верно:

2^33 может быть прекрасно представлено как число с плавающей запятой, но явно не может быть представлено как 32-битное целое число. Следующий код должен работать как положено:

bool representable_as_float(int64_t value) {
    float repr = value;
    return repr >= -0x1.0p63 && repr < 0x1.0p63 && (int64_t)repr == value;
}

Однако важно отметить, что мы в основном делаем (int64_t)(float)value, а не наоборот - нас интересует, теряет ли точность приведение к float.

Проверка, чтобы увидеть, меньше ли repr, чем максимальное значение int64_t, важна, поскольку в противном случае мы могли бы вызвать неопределенное поведение, поскольку приведение к float может быть округлено до следующего большего числа (которое тогда может быть больше, чем максимальное значение, возможное в int64_t ). (Спасибо @tmyklebu за указание на это).

Два образца:

// powers of 2 can easily be represented
assert(representable_as_float(((int64_t)1) << 33));
// Other numbers not so much:
assert(!representable_as_float(std::numeric_limits<int64_t>::max())); 

Следующее основано на методе Джулии для сравнения чисел с плавающей запятой и целых чисел< /а>. Это не требует доступа к 80-битным long doubles или исключениям с плавающей запятой и должно работать в любом режиме округления. Я считаю, что это должно работать для любого типа C float (IEEE754 или нет) и не вызывать неопределенного поведения.

#include <stdio.h>
#include <stdint.h>

int cmp_flt_uint64(float x,uint64_t y) {
  return (x == (float)y) && (x != 0x1p64f) && ((uint64_t)x == y);
}

int main() {
  float x = 0x1p64f;
  uint64_t y = 0xffffffffffffffff;

  if (cmp_flt_uint64(x,y))
    printf("true\n");
  else 
    printf("false\n");
  ;
}

Нет, вам нужно сравнить (long double)x == (long double)y на архитектуре, где мантисса длинного двойника может содержать 63 бита. Это связано с тем, что некоторые большие длинные длинные целые числа теряют точность при преобразовании их в число с плавающей запятой и сравниваются как равные неэквивалентному числу с плавающей запятой, но если вы преобразуете в длинное двойное число, оно не потеряет точность в этой архитектуре.

Следующая программа демонстрирует такое поведение при компиляции с gcc -std=c99 -mssse3 -mfpmath=sse на платформе x86, потому что эти настройки используют достаточно широкое длинное удвоение, но предотвращают неявное использование типов более высокой точности в вычислениях:

#include <assert.h>
#include <stdint.h>

const int64_t x = (1ULL<<62) - 1ULL;
const float y = (float)(1ULL<<62);
// The mantissa is not wide enough to store
// 63 bits of precision.

int main(void)
{
  assert ((float)x == (float)y);
  assert ((long double)x != (long double)y);

  return 0;
}

Редактировать. Если у вас нет достаточно широких и длинных удвоений, может сработать следующее:

feclearexcept(FE_ALL_EXCEPT);
x == y;
ftestexcept(FE_INEXACT);

Я думаю, хотя я могу ошибаться, что реализация может округлить x во время преобразования таким образом, что потеряет точность.

Другая стратегия, которая может сработать, заключается в сравнении

extern uint64_t x;
extern float y;
const float z = (float)x;

y == z && (uint64_t)z == x;

Это должно выявить потери точности из-за ошибки округления, но предположительно может привести к неопределенному поведению, если преобразование в z округляется в большую сторону. Это будет работать, если преобразование настроено на округление до нуля при преобразовании x в z.