На даний момент я пишу код, де у мене є щось на зразок:

double a = SomeCalculation1();
double b = SomeCalculation2();

if (a < b)
    DoSomething2();
else if (a > b)
    DoSomething3();

І тоді в інших місцях мені може знадобитися зробити рівність:

double a = SomeCalculation3();
double b = SomeCalculation4();

if (a == 0.0)
   DoSomethingUseful(1 / a);
if (b == 0.0)
   return 0; // or something else here

Коротше кажучи, у мене багато математики з плаваючою комою, і мені потрібно робити різні порівняння умов. Я не можу перетворити його на цілочисельну математику, оскільки в цьому контексті така річ не має сенсу.

Я вже читав, що порівняння з плаваючою комою може бути ненадійним, оскільки у вас можуть бути такі речі:

double a = 1.0 / 3.0;
double b = a + a + a;
if ((3 * a) != b)
    Console.WriteLine("Oh no!");

Коротше кажучи, я хотів би знати: як я можу надійно порівняти числа з плаваючою комою (менше, більше, ніж рівність)?

Діапазон чисел, який я використовую, становить приблизно від 10E-14 до 10E6, тому мені потрібно працювати як з малими числами, так і з великими.

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

Порівняння великих / менших насправді не є проблемою, якщо ви не працюєте прямо на межі поплавкової / подвійної точності.

Для порівняння "нечітких рівних", це (код Java, який повинен легко адаптуватись) - ось що я придумав для Керівництва з плаваючою крапкою після багато роботи та з урахуванням великої кількості критики:

public static boolean nearlyEqual(float a, float b, float epsilon) {
    final float absA = Math.abs(a);
    final float absB = Math.abs(b);
    final float diff = Math.abs(a - b);

    if (a == b) { // shortcut, handles infinities
        return true;
    } else if (a == 0 || b == 0 || diff < Float.MIN_NORMAL) {
        // a or b is zero or both are extremely close to it
        // relative error is less meaningful here
        return diff < (epsilon * Float.MIN_NORMAL);
    } else { // use relative error
        return diff / (absA + absB) < epsilon;
    }
}

Він поставляється з тестовим набором. Вам слід негайно відхилити будь-яке рішення, яке цього не робить, оскільки воно практично гарантовано не вдасться в деяких крайових випадках, таких як наявність одного значення 0, двох дуже малих значень, протилежних нулю, або нескінченностей.

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

У будь-якому випадку, мабуть, немає жодного рішення, яке ідеально підходить для всіх додатків. В ідеалі, ви могли б розробити / адаптувати свій власний за допомогою набору тестів, що охоплює ваші фактичні випадки використання.

TL; DR

• Використовуйте наведену нижче функцію замість прийнятого в даний час рішення, щоб уникнути небажаних результатів у певних обмежених випадках, але бути потенційно більш ефективним.
• Знайте очікувану неточність ваших цифр і відповідно подайте їх у функції порівняння.

bool nearly_equal(
  float a, float b,
  float epsilon = 128 * FLT_EPSILON, float relth = FLT_MIN)
  // those defaults are arbitrary and could be removed
{
  assert(std::numeric_limits<float>::epsilon() <= epsilon);
  assert(epsilon < 1.f);

  if (a == b) return true;

  auto diff = std::abs(a-b);
  auto norm = std::min((std::abs(a) + std::abs(b)), std::numeric_limits<float>::max());
  // or even faster: std::min(std::abs(a + b), std::numeric_limits<float>::max());
  // keeping this commented out until I update figures below
  return diff < std::max(relth, epsilon * norm);
}

Графіка, будь ласка?

При порівнянні чисел з плаваючою комою існує два "режими".

Перший - це відносний режим, де різниця між xі yрозглядається відносно їх амплітуди |x| + |y|. Якщо побудувати графік у 2D, це дає такий профіль, де зелений означає рівність xі y. (Я взяв epsilon0,5 для ілюстрації).

Відносний режим - це те, що використовується для "нормальних" або "досить великих" значень з плаваючою комою. (Докладніше про це пізніше).

Другий - це абсолютний режим, коли ми просто порівнюємо їх різницю з фіксованим числом. Він дає наступний профіль (знову ж epsilonіз 0,5 і relth1 для ілюстрації).

Цей абсолютний режим порівняння є тим, що використовується для "крихітних" значень із плаваючою комою.

Тепер питання полягає в тому, як ми з’єднаємо ці дві моделі відповіді.

У відповіді Майкла Боргвардта перехід базується на значенні diff, яке повинно бути нижче relth( Float.MIN_NORMALу його відповіді). Ця зона перемикання показана у вигляді штрихування на графіку нижче.

Оскільки relth * epsilonменший за розмір relth, зелені плями не злипаються, що, в свою чергу, надає рішенню погану властивість: ми можемо знайти такі триплети чисел, що x < y_1 < y_2і все ж, x == y2але x != y1.

Візьмемо цей яскравий приклад:

x  = 4.9303807e-32
y1 = 4.930381e-32
y2 = 4.9309825e-32

Ми маємо x < y1 < y2, і насправді y2 - xбільше, ніж у 2000 разів y1 - x. І все-таки з поточним рішенням,

nearlyEqual(x, y1, 1e-4) == False
nearlyEqual(x, y2, 1e-4) == True

На відміну від цього, у запропонованому вище рішенні зона перемикання базується на значенні |x| + |y|, яке представлене штриховим квадратом внизу. Це гарантує, що обидві зони витончено з'єднуються.

Крім того, код вище не має розгалуження, що може бути більш ефективним. Враховуйте, що такі операції, як maxі abs, які апріорі потребують розгалуження, часто мають спеціальні інструкції зі складання. З цієї причини, я думаю, що цей підхід перевершує інше рішення, яке полягало б у виправленні Майкла nearlyEqualшляхом зміни перемикача з diff < relthна diff < eps * relth, що в подальшому дало б по суті той самий шаблон відповіді.

Де перемикатися між відносним та абсолютним порівнянням?

Перемикання між цими режимами здійснюється навколо relth, що приймається як FLT_MINу прийнятій відповіді. Цей вибір означає, що подання - float32це те, що обмежує точність наших чисел із плаваючою комою.

Це не завжди має сенс. Наприклад, якщо числа, які ви порівнюєте, є результатами віднімання, можливо, щось із діапазону FLT_EPSILONмає більше сенсу. Якщо це квадрати коренів від відніманих чисел, числова неточність може бути ще вищою.

Це досить очевидно, коли ви розглядаєте порівняння плаваючої крапки з 0. Тут будь-яке відносне порівняння не вдасться, оскільки |x - 0| / (|x| + 0) = 1. Отже, порівняння повинно перейти в абсолютний режим, коли xвідбувається порядок неточності вашого обчислення - і рідко воно буває настільки низьким, як FLT_MIN.

Це є причиною введення relthпараметра вище.

Крім того, не помножуючи relthна epsilon, інтерпретація цього параметра є простою і відповідає рівню числової точності, який ми очікуємо щодо цих чисел.

Математичне бурчання

(зберігається тут здебільшого для власного задоволення)

У більш загальному плані я припускаю, що добре поведений оператор порівняння з плаваючою точкою =~повинен мати деякі основні властивості.

Далі досить очевидно:

• саморівність: a =~ a
• симетрія: a =~ bпередбачаєb =~ a
• інваріантність проти опозиції: a =~ bмається на увазі-a =~ -b

(У нас немає a =~ bі b =~ cмається на увазі a =~ c, =~це не відношення еквівалентності).

Я хотів би додати такі властивості, які є більш специфічними для порівняння з плаваючою комою

• якщо a < b < c, то a =~ cмається на увазіa =~ b (ближчі значення також повинні бути рівними)
• якщо a, b, m >= 0тоді a =~ bмає на увазі a + m =~ b + m(більші значення з однаковою різницею також повинні бути рівними)
• якщо 0 <= λ < 1тоді це a =~ bпередбачає λa =~ λb(можливо, менш очевидний аргумент за).

Ці властивості вже дають сильні обмеження щодо можливих функцій майже рівності. Запропонована вище функція перевіряє їх. Можливо, відсутня одна або декілька очевидних властивостей.

Коли один думати , =~як сімейство відносин рівності =~[Ɛ,t]параметризрвані Ɛі relth, можна також додати

• якщо Ɛ1 < Ɛ2тоді a =~[Ɛ1,t] bмається на увазі a =~[Ɛ2,t] b(рівність для даного допуску передбачає рівність при вищій допуску)
• якщо t1 < t2тоді a =~[Ɛ,t1] bмається на увазі a =~[Ɛ,t2] b(рівність для даної неточності передбачає рівність при вищій точності)

Запропоноване рішення також підтверджує їх.

У мене була проблема порівняння чисел із плаваючою комою, A < Bі A > B ось що, здається, працює:

if(A - B < Epsilon) && (fabs(A-B) > Epsilon)
{
    printf("A is less than B");
}

if (A - B > Epsilon) && (fabs(A-B) > Epsilon)
{
    printf("A is greater than B");
}

Fabs - абсолютна величина - подбає про те, якщо вони по суті рівні.

Нам потрібно вибрати рівень допуску для порівняння плаваючих чисел. Наприклад,

final float TOLERANCE = 0.00001;
if (Math.abs(f1 - f2) < TOLERANCE)
    Console.WriteLine("Oh yes!");

Одна примітка. Ваш приклад досить смішний.

double a = 1.0 / 3.0;
double b = a + a + a;
if (a != b)
    Console.WriteLine("Oh no!");

Тут трохи математики

a = 1/3
b = 1/3 + 1/3 + 1/3 = 1.

1/3 != 1

О, так..

Ти маєш на увазі

if (b != 1)
    Console.WriteLine("Oh no!")

Ідея, яку я мала для швидкого порівняння з плаваючою комою

infix operator ~= {}

func ~= (a: Float, b: Float) -> Bool {
    return fabsf(a - b) < Float(FLT_EPSILON)
}

func ~= (a: CGFloat, b: CGFloat) -> Bool {
    return fabs(a - b) < CGFloat(FLT_EPSILON)
}

func ~= (a: Double, b: Double) -> Bool {
    return fabs(a - b) < Double(FLT_EPSILON)
}

Адаптація до PHP від ​​відповіді Майкла Борґвардта та bosonix:

class Comparison
{
    const MIN_NORMAL = 1.17549435E-38;  //from Java Specs

    // from http://floating-point-gui.de/errors/comparison/
    public function nearlyEqual($a, $b, $epsilon = 0.000001)
    {
        $absA = abs($a);
        $absB = abs($b);
        $diff = abs($a - $b);

        if ($a == $b) {
            return true;
        } else {
            if ($a == 0 || $b == 0 || $diff < self::MIN_NORMAL) {
                return $diff < ($epsilon * self::MIN_NORMAL);
            } else {
                return $diff / ($absA + $absB) < $epsilon;
            }
        }
    }
}

Вам слід запитати себе, чому ви порівнюєте цифри. Якщо ви знаєте мету порівняння, ви також повинні знати необхідну точність ваших цифр. Це різниться в кожній ситуації та в кожному контексті програми. Але майже у всіх практичних випадках є необхідний абсолют точність. Дуже рідко застосовується відносна точність.

Наведемо приклад: якщо ваша мета - намалювати графік на екрані, то ви, швидше за все, хочете, щоб значення з плаваючою точкою порівнювали, якщо вони відповідають одному пікселю на екрані. Якщо розмір вашого екрану становить 1000 пікселів, а ваші цифри знаходяться в діапазоні 1e6, то вам, швидше за все, буде потрібно 100 для порівняння, рівного 200.

Враховуючи необхідну абсолютну точність, тоді алгоритм стає:

public static ComparisonResult compare(float a, float b, float accuracy) 
{
    if (isnan(a) || isnan(b))   // if NaN needs to be supported
        return UNORDERED;    
    if (a == b)                 // short-cut and takes care of infinities
        return EQUAL;           
    if (abs(a-b) < accuracy)    // comparison wrt. the accuracy
        return EQUAL;
    if (a < b)                  // larger / smaller
        return SMALLER;
    else
        return LARGER;
}

Стандартна порада полягає у використанні деякого невеликого значення "епсилон" (вибирається, можливо, залежно від вашої програми), і вважайте поплавки, що знаходяться в межах епсилону один від одного, рівними. наприклад щось подібне

#define EPSILON 0.00000001

if ((a - b) < EPSILON && (b - a) < EPSILON) {
  printf("a and b are about equal\n");
}

Більш повна відповідь є складною, оскільки помилка з плаваючою комою надзвичайно тонка і незрозуміла. Якщо ви дійсно дбаєте про рівність у будь-якому точному сенсі, ви, мабуть, шукаєте рішення, яке не передбачає плаваючої крапки.

Я спробував написати функцію рівності з урахуванням наведених коментарів. Ось що я придумав:

Редагувати: змінити з Math.Max ​​(a, b) на Math.Max ​​(Math.Abs ​​(a), Math.Abs ​​(b))

static bool fpEqual(double a, double b)
{
    double diff = Math.Abs(a - b);
    double epsilon = Math.Max(Math.Abs(a), Math.Abs(b)) * Double.Epsilon;
    return (diff < epsilon);
}

Думки? Мені все одно потрібно розробити більше, і менше, ніж також.

Потрібно взяти до уваги, що помилка усічення є відносною. Дві цифри приблизно рівні, якщо їх різниця приблизно така ж велика, як їх ульп (одиниця останнього місця).

Однак, якщо ви виконуєте обчислення з плаваючою точкою, ваш потенціал помилок зростає з кожною операцією (особливо обережно з відніманням!), Тому ваша толерантність до помилок повинна відповідно збільшуватися.

Найкращий спосіб порівняти подвійні для рівності / нерівності - це взяти абсолютне значення їх різниці та порівняти його з досить малим (залежно від вашого контексту) значенням.

double eps = 0.000000001; //for instance

double a = someCalc1();
double b = someCalc2();

double diff = Math.abs(a - b);
if (diff < eps) {
    //equal
}