Эвристика, чтобы определить, является ли серия 4-байтовых блоков данных целыми числами или плаваниями

Похоже, проблема сложности колмогорова . По сути, из того, что вы показываете в качестве примера, более короткое число (при печати в виде строки для чтения человеком), будь то целое или с плавающей запятой, является правильным ответом для вашей эвристики.

Кроме того, очевидно, что если значение является неправильным с плавающей запятой, оно является целым числом: -)

Кажется достаточно прямым для реализации.

Вы, вероятно, сможете «обнаружить» это, посмотрев на старшие биты, с плавающей точкой они обычно не равны нулю, с целыми числами, если вы не имеете дело с очень большим числом. Итак ... вы можете попробовать и посмотреть, возвращает ли (2 ^ 30) & number 0 или нет.

Человек может сделать это легко

Человек вообще не может этого сделать. Ergo не может и компьютер. Имеется 2 ^ 32 допустимых значений типа int. Многие из них также являются допустимыми значениями с плавающей запятой. Нет другого способа отличить цель данных, кроме как пометить их или вообще не попасть в такой беспорядок.

Не пытайтесь это сделать.

Если вы знаете, что все ваши числа с плавающей запятой будут фактическими значениями (без NaN, INF, денормальных значений или других отклоняющихся значений), вы можете использовать этот критерий. Как правило, массив целых чисел с высокой вероятностью содержит «плохие» значения с плавающей запятой.

Если оба числа положительны, ваши числа с плавающей запятой достаточно большие ( больше 10 ^ -42), а ваши целые числа достаточно малы (меньше 8 * 10 ^ 6), то проверка довольно проста. Рассматривайте данные как число с плавающей запятой и сравнивайте с наименее нормализованным числом с плавающей запятой.

union float_or_int {
    float f;
    int32_t i;
};

bool is_positive_normalized_float( float_or_int &u ) {
    return u.f >= numeric_limits<float>::min();
}

Предполагается, что IEEE float и одинаковая конечная скорость между CPU и FPU.

Эвристика "здравого смысла" из вашего примера, по-видимому, в основном сводится к проверке диапазона. Если одна интерпретация очень большая (или крошечная дробь, близкая к нулю), это, вероятно, неверно. Проверьте показатель степени интерпретации числа с плавающей запятой и сравните его с показателем степени, который является результатом правильного статического преобразования целочисленной интерпретации в число с плавающей запятой.

Упрощая то, что сказал Алан, я бы посмотрел ТОЛЬКО на целочисленную форму. и скажем, если число больше 99999999, то это почти наверняка число с плавающей запятой.

Это имеет то преимущество, что это быстро, легко и позволяет избежать проблем с нанотехнологиями.

У него есть недостаток в том, что он в значительной степени полон дерьма ... Я на самом деле не смотрел, какие поплавки они будут представлять или что-то в этом роде, но из ваших примеров это выглядит разумным ...

В любом случае, это это эвристика, так что ГОННА будет полная чушь, да и не всегда срабатывает ...

Измерьте микрометром, отметьте мелом, отрежьте топором.

Я предполагаю следующее:

• вы имеете в виду числа с плавающей запятой одинарной точности IEEE 754.
• что знаковый бит числа с плавающей запятой сохраняется в старшем разряде int.

Итак, начнем:

static boolean probablyFloat(uint32_t bits) {
  bool sign = (bits & 0x80000000U) != 0;
  int exp = ((bits & 0x7f800000U) >> 23) - 127;
  uint32_t mant = bits & 0x007fffff;

  // +- 0.0
  if (exp == -127 && mant == 0)
    return true;

  // +- 1 billionth to 1 billion
  if (-30 <= exp && exp <= 30)
    return true;

  // some value with only a few binary digits
  if ((mant & 0x0000ffff) == 0)
    return true;

  return false;
}

int main() {
  assert(probablyFloat(1065353216));
  assert(probablyFloat(1084227584));
  assert(probablyFloat(1085276160));
  assert(probablyFloat(1068149391));
  assert(probablyFloat(1083179008));
  assert(probablyFloat(1120403456));
  assert(probablyFloat(0));
  assert(probablyFloat(-1110651699));
  assert(probablyFloat(1195593728));
  return 0;
}