浮動小数点の比較はどのようにすればよいですか？

Question 1

私は現在、次のようなコードを書いています。

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なので、大きい数だけでなく小さい数でも作業する必要があります。

使用している言語に関係なく、これをどのように達成できるかに興味があるため、これを言語に依存しないものとしてタグ付けしました。

Question 2

フロート/倍精度の制限の端で作業している場合を除いて、大きい/小さいの比較は実際には問題ではありません。

「あいまいな等しい」比較のために、これ（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;
    }
}

テストスイートが付属しています。1つの値が0、2つの非常に小さい値がゼロの反対、または無限大であるなど、一部のエッジケースでは失敗することが事実上保証されているため、そうでないソリューションはすぐに却下する必要があります。

別の方法（詳細については上記のリンクを参照）は、floatのビットパターンを整数に変換し、固定整数距離内のすべてを受け入れることです。

いずれにせよ、すべてのアプリケーションに最適なソリューションはおそらくありません。理想的には、実際のユースケースをカバーするテストスイートを使用して独自に開発/適応します。

Question 3

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);
}

グラフィックをお願いします？

浮動小数点数を比較する場合、2つの「モード」があります。

最初のものは、相対差モードxとは、yそれらの振幅に比較的考えられます|x| + |y|。2Dでプロットすると、次のプロファイルが得られます。ここで、緑はとの等しいことを意味xしyます。（epsilon説明のために0.5を取りました）。

相対モードは、「通常の」または「十分に大きい」浮動小数点値に使用されるものです。（これについては後で詳しく説明します）。

2つ目は、それらの差を固定数と単純に比較する絶対モードです。これにより、次のプロファイルが得られます（ここでも、説明のためepsilonに0.5とrelth1を使用しています）。

この絶対比較モードは、「小さな」浮動小数点値に使用されるものです。

ここで問題となるのは、これら2つの応答パターンをどのようにつなぎ合わせるかです。

Michael Borgwardtの回答では、切り替えはの値に基づいており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に変更してMichaelを修正するという別のソリューションよりも優れていると思います。これにより、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（おそらく議論するのはあまり明白ではありません）。

これらのプロパティは、可能なほぼ等式の関数にすでに強い制約を与えています。上で提案された機能はそれらを検証します。おそらく、1つまたはいくつかの明らかなプロパティが欠落しています。

とによってパラメータ化された=~平等関係のファミリーと考えると、次のように追加することもできます。=~[Ɛ,t]Ɛrelth

Ɛ1 < Ɛ2それがa =~[Ɛ1,t] b意味する場合a =~[Ɛ2,t] b（与えられた許容範囲の平等は、より高い許容範囲での平等を意味します）
if t1 < t2thenがa =~[Ɛ,t1] b意味するa =~[Ɛ,t2] b（与えられた不正確さの平等は、より高い不正確さでの平等を意味する）

提案されたソリューションは、これらも検証します。

Question 4

浮動小数点数の比較に問題が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");
}

ファブ（絶対値）は、それらが本質的に等しいかどうかを処理します。

Question 5

フロート数を比較するには、許容レベルを選択する必要があります。例えば、

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

1つのメモ。あなたの例はかなり面白いです。

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!")

Question 6

浮動小数点をすばやく比較するために私が持っていたアイデア

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)
}

Question 7

Michael Borgwardtとbosonixの回答によるPHPへの適応：

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;
            }
        }
    }
}

Question 8

なぜ数字を比較しているのか自問する必要があります。比較の目的がわかっている場合は、必要な数値の精度も知っておく必要があります。これは、状況やアプリケーションのコンテキストごとに異なります。しかし、ほとんどすべての実際のケースでは、絶対的な精度が必要です。相対的な精度が適用できることはめったにありません。

例を挙げると、目標が画面上にグラフを描画することである場合、浮動小数点値が画面上の同じピクセルにマップされていれば、浮動小数点値を等しく比較する必要があります。画面のサイズが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;
}

Question 9

標準的なアドバイスは、いくつかの小さな「イプシロン」値（おそらくアプリケーションに応じて選択）を使用し、互いにイプシロン内にあるフロートが等しいと見なすことです。例：

#define EPSILON 0.00000001

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

浮動小数点エラーは非常に微妙であり、推論が混乱するため、より完全な答えは複雑です。正確な意味での平等を本当に気にしているのであれば、おそらく浮動小数点を含まないソリューションを探しているでしょう。

Question 10

上記のコメントを念頭に置いて、等式関数を書いてみました。これが私が思いついたものです：

編集：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);
}

考え？私はまだ大なり記号と小なり記号を計算する必要があります。

Question 11

切り捨てエラーは相対的なものであることを考慮する必要があります。2つの数値は、それらの差がulp（最後の単位）とほぼ同じである場合、ほぼ等しくなります。

ただし、浮動小数点計算を行う場合は、操作ごとにエラーの可能性が高くなるため（特に、減算に注意してください）、それに応じてエラー許容度を上げる必要があります。

Question 12

ダブルスの等式/不等式を比較する最良の方法は、それらの差の絶対値を取得し、それを十分に小さい（コンテキストに応じて）値と比較することです。

double eps = 0.000000001; //for instance

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

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