Управление и сравнение с плавающей запятой в java

По общему правилу, числа с плавающей запятой никогда не следует сравнивать как (a == b), а как (Math.abs(a-b) < delta), где дельта - небольшое число.

Значение с плавающей запятой, имеющее фиксированное количество цифр в десятичной форме, не обязательно имеет фиксированное количество цифр в двоичной форме.

Дополнение для ясности:

Хотя строгое == сравнение чисел с плавающей запятой имеет очень мало практического смысла, строгое сравнение < и >, напротив, является допустимым вариантом использования (пример - логический запуск, когда определенное значение превышает пороговое значение: (val > threshold) && panic();)

Если вас интересуют числа с фиксированной точностью, вам следует использовать тип с фиксированной точностью, такой как BigDecimal, а не по своей сути приближенный (хотя и с высокой точностью) тип, например float. Существует множество похожих вопросов о переполнении стека, которые более подробно рассматриваются на многих языках.

Я думаю, что это не имеет ничего общего с Java, это происходит с любым числом с плавающей запятой IEEE 754. Это из-за природы представления с плавающей запятой. Любые языки, использующие формат IEEE 754, столкнутся с той же проблемой.

Как было предложено Дэвидом выше, вы должны использовать метод abs класса java.lang.Math, чтобы получить абсолютное значение (отбросьте положительный / отрицательный знак).

Вы можете прочитать это: http://en.wikipedia.org/wiki/IEEE_754_revision, а также Хороший учебник по численным методам решит эту проблему в достаточной степени.

public static void main(String[] args) {
    float a = 1.2f;
    float b = 3.0f;
    float c = a * b;
        final float PRECISION_LEVEL = 0.001f;
    if(Math.abs(c - 3.6f) < PRECISION_LEVEL) {
        System.out.println("c is 3.6");
    } else {
        System.out.println("c is not 3.6");
    }
}

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

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

/**
 * Compare two floating points for equality within a margin of error.
 * 
 * This can be used to compensate for inequality caused by accumulated
 * floating point math errors.
 * 
 * The error margin is specified in ULPs (units of least precision).
 * A one-ULP difference means there are no representable floats in between.
 * E.g. 0f and 1.4e-45f are one ULP apart. So are -6.1340704f and -6.13407f.
 * Depending on the number of calculations involved, typically a margin of
 * 1-5 ULPs should be enough.
 * 
 * @param expected The expected value.
 * @param actual The actual value.
 * @param maxUlps The maximum difference in ULPs.
 * @return Whether they are equal or not.
 */
public static boolean compareFloatEquals(float expected, float actual, int maxUlps) {
    int expectedBits = Float.floatToIntBits(expected) < 0 ? 0x80000000 - Float.floatToIntBits(expected) : Float.floatToIntBits(expected);
    int actualBits = Float.floatToIntBits(actual) < 0 ? 0x80000000 - Float.floatToIntBits(actual) : Float.floatToIntBits(actual);
    int difference = expectedBits > actualBits ? expectedBits - actualBits : actualBits - expectedBits;

    return !Float.isNaN(expected) && !Float.isNaN(actual) && difference <= maxUlps;
}

Вот версия для double точных поплавков:

/**
 * Compare two double precision floats for equality within a margin of error.
 * 
 * @param expected The expected value.
 * @param actual The actual value.
 * @param maxUlps The maximum difference in ULPs.
 * @return Whether they are equal or not.
 * @see Utils#compareFloatEquals(float, float, int)
 */
public static boolean compareDoubleEquals(double expected, double actual, long maxUlps) {
    long expectedBits = Double.doubleToLongBits(expected) < 0 ? 0x8000000000000000L - Double.doubleToLongBits(expected) : Double.doubleToLongBits(expected);
    long actualBits = Double.doubleToLongBits(actual) < 0 ? 0x8000000000000000L - Double.doubleToLongBits(actual) : Double.doubleToLongBits(actual);
    long difference = expectedBits > actualBits ? expectedBits - actualBits : actualBits - expectedBits;

    return !Double.isNaN(expected) && !Double.isNaN(actual) && difference <= maxUlps;
}

Это слабость всех представлений с плавающей запятой, и это происходит потому, что некоторые числа, которые имеют фиксированное количество десятичных знаков в десятичной системе, на самом деле имеют бесконечное количество десятичных знаков в двоичной системе. Итак, то, что вы думаете, 1.2 на самом деле похоже на 1.199999999997, потому что при представлении его в двоичном формате он должен отбрасывать десятичные дроби после определенного числа, и вы теряете некоторую точность. Тогда умножение его на 3 фактически дает 3,5999999 ...

http://docs.python.org/py3k/tutorial/floatingpoint.html ‹- это могло бы объяснить это лучше (даже если это для python, это общая проблема представления с плавающей запятой)

Как писали другие:

Сравнить числа с плавающей запятой: if (Math.abs(a - b) < delta)

Вы можете написать хороший метод для этого:

public static int compareFloats(float f1, float f2, float delta)
{
    if (Math.abs(f1 - f2) < delta)
    {
         return 0;
    } else
    {
        if (f1 < f2)
        {
            return -1;
        } else {
            return 1;
        }
    }
}

/**
 * Uses <code>0.001f</code> for delta.
 */
public static int compareFloats(float f1, float f2)
{
     return compareFloats(f1, f2, 0.001f);
}

Итак, вы можете использовать это так:

if (compareFloats(a * b, 3.6f) == 0)
{
    System.out.println("They are equal");
}
else
{
    System.out.println("They aren't equal");
}

Существует класс apache для сравнения двойников: org.apache.commons.math3.util.Precision

Он содержит несколько интересных констант: SAFE_MIN и EPSILON, которые представляют собой максимально возможные отклонения при выполнении арифметических операций.

Он также предоставляет необходимые методы для сравнения, равных или округленных удвоений.

Округление - плохая идея. Используйте BigDecimal и при необходимости установите точность. Нравиться:

public static void main(String... args) {
    float a = 1.2f;
    float b = 3.0f;
    float c = a * b;
    BigDecimal a2 = BigDecimal.valueOf(a);
    BigDecimal b2 = BigDecimal.valueOf(b);
    BigDecimal c2 = a2.multiply(b2);
    BigDecimal a3 = a2.setScale(2, RoundingMode.HALF_UP);
    BigDecimal b3 = b2.setScale(2, RoundingMode.HALF_UP);
    BigDecimal c3 = a3.multiply(b3);
    BigDecimal c4 = a3.multiply(b3).setScale(2, RoundingMode.HALF_UP);

    System.out.println(c); // 3.6000001
    System.out.println(c2); // 3.60000014305114740
    System.out.println(c3); // 3.6000
    System.out.println(c == 3.6f); // false
    System.out.println(Float.compare(c, 3.6f) == 0); // false
    System.out.println(c2.compareTo(BigDecimal.valueOf(3.6f)) == 0); // false
    System.out.println(c3.compareTo(BigDecimal.valueOf(3.6f)) == 0); // false
    System.out.println(c3.compareTo(BigDecimal.valueOf(3.6f).setScale(2, RoundingMode.HALF_UP)) == 0); // true
    System.out.println(c3.compareTo(BigDecimal.valueOf(3.6f).setScale(9, RoundingMode.HALF_UP)) == 0); // false
    System.out.println(c4.compareTo(BigDecimal.valueOf(3.6f).setScale(2, RoundingMode.HALF_UP)) == 0); // true
}

Чтобы сравнить два числа с плавающей запятой, f1 и f2 с точностью до #.###, я считаю, что вам нужно сделать следующее:

((int) (f1 * 1000 + 0.5)) == ((int) (f2 * 1000 + 0.5))

f1 * 1000 поднимает 3.14159265... до 3141.59265, + 0.5 дает 3142.09265, а (int) отбрасывает десятичные числа, 3142. То есть он включает 3 десятичных знака и правильно округляет последнюю цифру.