Потеря точности из Double во Float или «Куда пропадали копейки?»

    99999999.33333333 -> 100000000.0000000     98888888.33333333 ->  98888888.0000000      2974815.78000000 ->   2974815.7500000 

Давайте разберемся, к чему приводит такое преобразование и почему все происходит именно так. Ведь казалось бы, раз используемые в проекте числа далеки от максимальных значений типов float и double, то конвертация его из первого во второй не должна повлечь за собой отрицательных последствий в большинстве случаев.

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

public class Main {      static void testDoubleToFloat(double d) {         float f = (float) d;          System.out.println();         System.out.println(String.format("double %.10f\t%s", d, Long.toBinaryString(Double.doubleToRawLongBits(d))));         System.out.println(String.format("float  %.10f\t   %s", f, Integer.toBinaryString(Float.floatToRawIntBits(f))));     }      public static void main(String[] args) {         System.out.println(String.format("double: %.10f / %.10f", Double.MIN_VALUE, Double.MAX_VALUE));         System.out.println(String.format("float: %.10f / %.10f", Float.MIN_VALUE, Float.MAX_VALUE));          /*             По умолчанию, вычисления с плавающей точкой ведутся с помощью double.         */         testDoubleToFloat(99999999.0 + 1.0 / 3.0); // Добавим периодичности         testDoubleToFloat(98888888.0 + 1.0 / 3.0); // Вариант без округления девяток         testDoubleToFloat(2974815.78);         testDoubleToFloat(-2974815.78);     } } 

double: 0.0000000000 / 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0000000000 float: 0.0000000000 / 340282346638528860000000000000000000000.0000000000  double 99999999.3333333300  100000110010111110101111000001111111101010101010101010101010101 float  100000000.0000000000    1001100101111101011110000100000  double 98888888.3333333300  100000110010111100100111011001011100001010101010101010101010101 float  98888888.0000000000     1001100101111001001110110010111  double 2974815.7800000000   100000101000110101100100010111111100011110101110000101000111101 float  2974815.7500000000      1001010001101011001000101111111  double -2974815.7800000000  1100000101000110101100100010111111100011110101110000101000111101 float  -2974815.7500000000    11001010001101011001000101111111 

/opt/jdk1.7/bin/java -version java version "1.7.0_25" Java(TM) SE Runtime Environment (build 1.7.0_25-b15) Java HotSpot(TM) 64-Bit Server VM (build 23.25-b01, mixed mode) 

java -version java version "1.7.0_25" OpenJDK Runtime Environment (IcedTea 2.3.12) (7u25-2.3.12-4ubuntu3) OpenJDK 64-Bit Server VM (build 23.7-b01, mixed mode) 

Способ конвертации

Для демонстрации того, что разнообразные конструкции одинаково конвертируют double во float, добавим разнообразные способы и сравним результаты:

public class Main {      static void testDoubleToFloat(double d) {         float f = (float) d;         Float f2 = new Float(d);         float f3 = Float.parseFloat(new Double(d).toString());         float f4 = Float.parseFloat(String.format("%.10f", d));          System.out.println();         System.out.println(String.format("double %.10f\t%s", d, Long.toBinaryString(Double.doubleToRawLongBits(d))));         System.out.println(String.format("float  %.10f\t   %s", f, Integer.toBinaryString(Float.floatToRawIntBits(f))));         System.out.println(String.format("Float  %.10f\t   %s", f2, Integer.toBinaryString(Float.floatToRawIntBits(f2))));         System.out.println(String.format("float  %.10f\t   %s", f3, Integer.toBinaryString(Float.floatToRawIntBits(f3))));          System.out.println(String.format("float  %.10f\t   %s", f4, Integer.toBinaryString(Float.floatToRawIntBits(f4))));     }      public static void main(String[] args) {         System.out.println(String.format("double: %.10f / %.10f", Double.MIN_VALUE, Double.MAX_VALUE));         System.out.println(String.format("float: %.10f / %.10f", Float.MIN_VALUE, Float.MAX_VALUE));          testDoubleToFloat(99999999.0 + 1.0 / 3.0);         testDoubleToFloat(98888888.0 + 1.0 / 3.0);         testDoubleToFloat(2974815.78);         testDoubleToFloat(-2974815.78);     } } 

    double: 0.0000000000 / 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0000000000     float: 0.0000000000 / 340282346638528860000000000000000000000.0000000000      double 99999999.3333333300  100000110010111110101111000001111111101010101010101010101010101     float  100000000.0000000000    1001100101111101011110000100000     Float  100000000.0000000000    1001100101111101011110000100000     float  100000000.0000000000    1001100101111101011110000100000     float  100000000.0000000000    1001100101111101011110000100000      double 98888888.3333333300  100000110010111100100111011001011100001010101010101010101010101     float  98888888.0000000000     1001100101111001001110110010111     Float  98888888.0000000000     1001100101111001001110110010111     float  98888888.0000000000     1001100101111001001110110010111     float  98888888.0000000000     1001100101111001001110110010111      double 2974815.7800000000   100000101000110101100100010111111100011110101110000101000111101     float  2974815.7500000000      1001010001101011001000101111111     Float  2974815.7500000000      1001010001101011001000101111111     float  2974815.7500000000      1001010001101011001000101111111     float  2974815.7500000000      1001010001101011001000101111111      double -2974815.7800000000  1100000101000110101100100010111111100011110101110000101000111101     float  -2974815.7500000000    11001010001101011001000101111111     Float  -2974815.7500000000    11001010001101011001000101111111     float  -2974815.7500000000    11001010001101011001000101111111     float  -2974815.7500000000    11001010001101011001000101111111 

Как можно убедиться, выражения «new Float(d)» и "(float) d" дают одинаковый результат, т.к. первое использует второе:

/*  * Copyright (c) 1994, 2010, Oracle and/or its affiliates. All rights reserved.  * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.  */ ... public final class Float extends Number implements Comparable<Float> { ...     public Float(double value) {         this.value = (float)value;     } ... } 

Если разбираться с функцией Float.parseFloat, то она отсылает нас через несколько других функций до следующей строки:

    return (float)Double.longBitsToDouble( lbits ); 

Которая точно таким же образом конвертирует double-переменную во float.
Таким образом, мы убедились, что, по крайней мере, в openjdk наиболее очевидные пути преобразования double во float сводятся к одной конструкции:

float f = (float) d; 

Форматы хранения float и double

В каждом примере мы вызывали функции Long.toBinaryString для Double и Integer.toBinaryString для Float, чтобы продемонстрировать форматы низкоуровневого хранения созданных переменных. Прекрасная статья об этом уже была написана (Что нужно знать про арифметику с плавающей запятой, которая стала отличным переводом английской вики, где хорошо рассказано и про двойную точность), поэтому здесь мы рассмотрим только то, касается округления.
Представленные выше программы вернули следующие результаты:

    double 2974815.7800000000   100000101000110101100100010111111100011110101110000101000111101     float  2974815.7500000000      1001010001101011001000101111111 

Тип double занимает 64 бита, а тип float 32, но мы видим 63 и 31 знак — это издержка реализации вывода, который заканчивается, когда остаются только нули. Следовательно, эти числа должны выглядеть так:

    double 2974815.7800000000   0 10000010100 0110101100100010111111100011110101110000101000111101     float  2974815.7500000000      0 10010100 01101011001000101111111 

Первый бит — это знак числа. Далее 11 (для double) или 8 бит (для float) — экспонента. После — мантисса, которая и играет самую интересную роль. Первое впечатление: просто теряются все числа после 23-его бита при конвертации из double во float. Но давайте сначала попробуем восстановить эти числа, чтобы разобраться во всем по порядку:

• 1-ые биты 0 => знаки положительные
• Далее экспоненты: 010000010100₂-1023₁₀=21

  и 10010100₂-127₁₀=21

• Мантиссы: 1.0110101100100010111111100011110101110000101000111101₂*2^{21 — 52}=2974815.779999749

  и 1.01101011001000101111111₂*2^{21 — 23}=2974815.75

Таким образом, отсекая от двоичного 0110 1011 0010 0010 1111 1110 0011 1101 0111 0000 1010 0011 1101 из double последние 29 цифр, мы получаем 011 0101 1001 0001 0111 1111 во float, которое дает нам несколько другое число.

Вывод

Таким образом, конвертация из формата большей точности может привести к нетривиальным потерям достоверности используемых чисел. Что же касается непосредственно Java, то в ней лучше использовать тип Double, т.к. работа с Float чревата конвертациями из Double с потерями. В своей же системе, мы просто перешли на повсеместное использование типа Double, как только выявили факты подобных конвертаций, тем более, что сервера давно уже x64.

P.S.

В системе отслеживания ошибок проекта OpenJDK нашлись плотно связанные с данной темой:

• Fix Float.parseFloat to round correctly and preserve monotonicity. — мы-то с Вами уже разобрались, почему такое происходит
• Direct String-to-float conversion does not preserve monotonicity — то же самое

В качетве обхода для этих задач написано:

CUSTOMER SUBMITTED WORKAROUND:
Avoiding direct String-to-float conversion by using intermediate doubles.