Разбираем float на части

Совсем немного теории

Я буду использовать в статье стандартное 32-х битное представление числа IEEE 754 для примера. Другие форматы, в основном отличаются только размером, структура та же. Биты считаются справа налево.

• 31-й бит - это знак числа, 0 - плюс, 1 - минус

• с 23-го по 30-й идут биты степени двойки

• с 0-го по 22-й - дробная часть или мантисса

Знак

Это самое простое, тут не надо ничего придумывать:

int sign = (int) Math.signum(floatNumber);

Экспонента

Для работы с битами числа, float надо конвертировать в двоичное представление:

int bits = Float.floatToIntBits(floatNumber);

Чтобы вытащить экспоненту, воспользуемся операцией сдвига. Сначала нужно обнулить 31-й знаковый бит, для этого сдвинем биты влево на 1, затем без учета знака сдвинем на 24 бита вправо, получим 24 нуля слева и само значение:

int exponent = bits << 1 >>> 24;

Экспонента - это 1 байт кода со сдвигом, минимальное значение -126 представляется нулём, максимальное 127 как 255. Т.е. при кодировании к числу надо прибавить 127, для раскодирования вычесть:

exponent -= 127;

Дробная часть

Мантисса - это двоичная дробь от 0 до 1 к которой еще прибавляется 1. Для ее раскодирования пройдём от 22-го бита до 0-го, переводя их в десятичный формат. Перевод целого числа осуществляется при помощи умножения разрядов на степень двойки, дробного при помощи деления. Получить значение i-го бита можно так:

• Сдвинуть 1 на i бит влево, получим степень двойки

• Выполнить логическое И, тогда на i-м бите будет 0 или 1

• Сдвинем обратно на i бит вправо, получим десятичные 0 или 1 - bitValue

• Полученное значение разделать на 2 в степени

Код будет следующий:

float fraction = 1, div = 2;
for (int i = 22; i >= 0; i--) {
  int bitValue = ((1 << i) & bits) >>> i;
  fraction += bitValue / div;
  div *= 2;
}

Ограничения точности как раз и происходят из невозможности представить некоторые десятичные дроби в двоичном формате.

Но есть и другой способ. Дробная часть у нас уже есть в двоичном представлении числа, всё что нужно - это вместо экспоненты подставить 0, чтобы степень двойки стала единицей. Сделать это можно следующим образом:

• Обнулить биты с 23-го по 31-й, сдвинув влево на 9 бит и затем вправо на 9 без учёта знака:

  (bits << 9 >>> 9) = 00000000011100101110010111001100

• В экспоненту подставить 0 закодированный со сдвигом, для этого 127 сдвинем влево на 23:

  (127 << 23) = 00111111100000000000000000000000

• Выполнив логическое ИЛИ с этими числами, получим дробную часть с нулевой экспонентой:

float fractionFormula = Float.intBitsToFloat((bits << 9 >>> 9) | (127 << 23));

Проверка

Подставим знак, экспоненту и дробь в формулу:

float check = (float)  (sign * Math.pow(2, exponent) * fraction);
assert check == floatNumber;
assert fractionFormula == fraction;

Всё вместе

private static void parseFloat(float floatNumber) {
  int sign = (int) Math.signum(floatNumber);
  
  int bits = Float.floatToIntBits(floatNumber);
  int exponent = bits << 1 >>> 24;
  exponent -= 127;
  
  float fraction = 1, div = 2;
  for (int i = 22; i >= 0; i--) {
    int bitValue = ((1 << i) & bits) >>> i;
    fraction += bitValue / div;
    div *= 2;
  }
  float fractionFormula = Float.intBitsToFloat((bits << 9 >>> 9) | (127 << 23));
  
  float check = (float)  (sign * Math.pow(2, exponent) * fraction);
  assert check == floatNumber;
  assert fractionFormula == fraction;
  System.out.println("Binary: " + Integer.toBinaryString(bits));
  System.out.printf("parseFloat(%.10f) = %d * 2^%d * %.10f\n", floatNumber, sign, exponent, fraction);    
}

Пример:

parseFloat(2.3164524E-4F);
parseFloat(3.6F);

Binary: 111001011100101110010111001100
parseFloat(0,0002316452) = 1 * 2^-13 * 1,8976378441
Binary: 1000000011001100110011001100110
parseFloat(3,5999999046) = 1 * 2^1 * 1,7999999523

Другие форматы

Формат IEEE 754 является самым распространённым, но есть и другие, например:

• Microsoft Binary Format (MBF) - содержит знаковый бит между экспонентой и мантиссой

• bfloat16 - позволяет увеличить скорость вычислений и сократить место для хранения без значительных потерь в точности

Что ещё почитать

Если вам понравилось двигать биты влево и вправо, рекомендую вот этот фундаментальный труд. То что там описано применяется в жизни. Например, метод вычисления десятичного логарифма числа используется в Java BigDecimal.precision() для получения точности.