2つの等しくない浮動小数点数を引くことによって0を取得することは可能ですか？

次の例では、0（または無限大）による除算を取得できますか？

public double calculation(double a, double b)
{
     if (a == b)
     {
         return 0;
     }
     else
     {
         return 2 / (a - b);
     }
}

もちろん、通常はそうなりません。しかし、どのような場合aとb非常に接近している、できる(a-b)ことになり0、計算の精度が原因？

この質問はJavaに関するものですが、ほとんどのプログラミング言語に当てはまると思います。

Javaでは、a - bと0ifが等しくなることはありませんa != b。これは、Javaが非正規化数をサポートするIEEE 754浮動小数点演算を義務付けているためです。仕様から：

特に、Javaプログラミング言語では、IEEE 754非正規化浮動小数点数と段階的なアンダーフローのサポートが必要です。これにより、特定の数値アルゴリズムの望ましい特性を簡単に証明できます。計算結果が非正規化数である場合、浮動小数点演算は「ゼロにフラッシュ」されません。

FPUが非正規化数で機能する場合、等しくない数を減算すると（乗算とは異なり）ゼロが生成されることはありません。この質問も参照してください。

他の言語については、状況によって異なります。たとえば、CまたはC ++では、IEEE 754サポートはオプションです。

とはいえ、式2 / (a - b)がオーバーフローする可能性もa = 5e-308ありb = 4e-308ます。

回避策として、以下についてはどうですか？

public double calculation(double a, double b) {
     double c = a - b;
     if (c == 0)
     {
         return 0;
     }
     else
     {
         return 2 / c;
     }
}

そうすれば、どの言語でのIEEEサポートにも依存しません。

a - b0による浮動小数点除算では例外がスローされないため、の値に関係なく、ゼロによる除算は行われません。無限を返します。

現在、a == btrueを返す唯一の方法は、まったく同じビットaをb含む場合です。最下位ビットだけが異なる場合、それらの差は0にはなりません。

編集：

バトシェバが正しくコメントしたように、いくつかの例外があります：

1. 「数ではない」はそれ自体とは偽ですが、同じビットパターンになります。

2. -0.0は、+ 0.0とtrueを比較するように定義されており、それらのビットパターンは異なります。

両方の場合だaとbされているDouble.NaN、あなたは、else節に到達しますが、以降NaN - NaNも戻ってNaN、あなたはゼロ除算されることはありません。

ここでゼロによる除算が発生するケースはありません。

SMTソルバー Z3は、正確なIEEE浮動小数点演算をサポートします。Z3にa、次のbような数値などを見つけるように依頼してみましょうa != b && (a - b) == 0。

(set-info :status unknown)
(set-logic QF_FP)
(declare-fun b () (FloatingPoint 8 24))
(declare-fun a () (FloatingPoint 8 24))
(declare-fun rm () RoundingMode)
(assert
(and (not (fp.eq a b)) (fp.eq (fp.sub rm a b) +zero) true))
(check-sat)

結果はUNSATです。そのような数はありません。

上記のSMTLIB文字列により、Z3は任意の丸めモード（rm）を選択することもできます。これは、結果がすべての可能な丸めモード（5つある）に当てはまることを意味します。結果には、関係する変数がNaN無限または無限である可能性も含まれます。

a == b実装されているfp.eqように、品質+0fと-0f等しい比較。ゼロとの比較fp.eqも使用して実装されています。質問はゼロによる除算を回避することを目的としているため、これは適切な比較です。

同等性テストがビット単位の同等性を使用して実装されていて、ゼロにする方法だった+0fとし-0fたら、a - bこの回答の誤った以前のバージョンには、好奇心が強い人のために、そのケースに関するモードの詳細が含まれています。

Z3 OnlineはまだFPA理論をサポートしていません。この結果は、最新の不安定なブランチを使用して取得されました。次のように.NETバインディングを使用して再現できます。

var fpSort = context.MkFPSort32();
var aExpr = (FPExpr)context.MkConst("a", fpSort);
var bExpr = (FPExpr)context.MkConst("b", fpSort);
var rmExpr = (FPRMExpr)context.MkConst("rm", context.MkFPRoundingModeSort());
var fpZero = context.MkFP(0f, fpSort);
var subExpr = context.MkFPSub(rmExpr, aExpr, bExpr);
var constraintExpr = context.MkAnd(
        context.MkNot(context.MkFPEq(aExpr, bExpr)),
        context.MkFPEq(subExpr, fpZero),
        context.MkTrue()
    );

var smtlibString = context.BenchmarkToSMTString(null, "QF_FP", null, null, new BoolExpr[0], constraintExpr);

var solver = context.MkSimpleSolver();
solver.Assert(constraintExpr);

var status = solver.Check();
Console.WriteLine(status);

（のような例を見落とすことは困難であるため、IEEEフロートの質問に答えるためにZ3を使用するといいですNaN、-0f、+-inf）あなたは、任意の質問をすることができます。仕様を解釈して引用する必要はありません。「この特定のint log2(float)アルゴリズムは正しいですか？」のように、floatとintegerの混合の質問をすることもできます。

提供された関数は確かに無限大を返すことができます：

public class Test {
    public static double calculation(double a, double b)
    {
         if (a == b)
         {
             return 0;
         }
         else
         {
             return 2 / (a - b);
         }
    }    

    /**
     * @param args
     */
    public static void main(String[] args) {
        double d1 = Double.MIN_VALUE;
        double d2 = 2.0 * Double.MIN_VALUE;
        System.out.println("Result: " + calculation(d1, d2)); 
    }
}

出力はResult: -Infinityです。

除算の結果がdoubleに格納されるほど大きい場合、分母がゼロ以外であっても無限大が返されます。

IEEE-754に準拠する浮動小数点実装では、各浮動小数点型は2つの形式で数値を保持できます。ほとんどの浮動小数点値には1（「正規化」）が使用されますが、それが表すことができる2番目に小さい数は、最小値よりもほんの少しだけ大きいため、それらの違いは同じ形式では表現できません。もう1つの（「非正規化」）形式は、最初の形式では表現できない非常に小さな数値に対してのみ使用されます。

非正規化浮動小数点形式を効率的に処理する回路は高価であり、すべてのプロセッサに含まれているわけではありません。一部のプロセッサは、非常に小さい数値での演算を他の値での演算よりもはるかに遅くするか、正規化された形式では小さすぎる数値をゼロと見なすかのどちらかを選択できます。

Java仕様は、実装が非正規化形式をサポートする必要があることを示唆しています。一方、一部の実装では、ほとんどの目的で問題には小さすぎる値のわずかにずさんな処理と引き換えに、コードをより高速に実行できるオプションを提供する可能性があります（値が小さすぎて問題にならない場合、それらを使用した計算は、重要な計算の10倍の時間がかかるので煩わしい場合があります。そのため、多くの実際の状況では、ゼロへのフラッシュは、遅いが正確な計算よりも便利です。

IEEE 754以前の昔は、a！= bがab！= 0を意味しておらず、その逆も可能でした。それがIEEE 754を最初に作成した理由の1つでした。

IEEE 754では、ほぼ保証されています。CまたはC ++コンパイラは、必要以上に高い精度で操作を実行できます。したがって、aとbが変数ではなく式である場合、（a + b）！= cは（a + b）-c！= 0を意味しません。より高い精度。

多くのFPUは、非正規化数を返さずに0に置き換えるモードに切り替えることができます。そのモードでは、aとbが小さな正規化数であり、差が最小正規化数よりも小さいが0より大きい場合、a ！= bもa == bを保証するものではありません。

「決して浮動小数点数を比較しない」はカーゴカルトプログラミングです。「イプシロンが必要です」というマントラを持っている人々の中で、ほとんどはそのイプシロンを適切に選択する方法を知りません。

あなたがこれを起こさせることができるかもしれないケースを考えることができます。これがベース10の類似のサンプルです。実際、これはベース2でも発生します。

浮動小数点数は多かれ少なかれ科学表記法で格納されます。つまり、35.2を参照する代わりに、格納される数値は3.52e2のようになります。

便宜上、10進数で動作し、3桁の精度を持つ浮動小数点ユニットがあると想像してください。10.0から9.99を引くとどうなりますか？

1.00e2-9.99e1

各値に同じ指数を与えるためのシフト

1.00e2-0.999e2

3桁に丸める

1.00e2-1.00e2

ええとああ！

これが最終的に発生するかどうかは、FPU設計に依存します。doubleの指数の範囲は非常に大きいため、ハードウェアはある時点で内部的に丸める必要がありますが、上記の場合、内部で1桁だけ追加することで問題を回避できます。

floatまたはdoubleが等しいかどうかを比較することはできません。なぜなら、floatまたはdoubleに割り当てる数値が正確であることを実際に保証することはできないからです。

floatが等しいかどうかを正しく比較するには、値が同じ値に「十分近い」かどうかを確認する必要があります。

if ((first >= second - error) || (first <= second + error)

ゼロによる除算は定義されていません。正の数からの制限は無限大になる傾向があるため、負の数からの制限は負の無限大になる傾向があります。

言語タグがないため、これがC ++であるかJavaであるかは不明です。

double calculation(double a, double b)
{
     if (a == b)
     {
         return nan(""); // C++

         return Double.NaN; // Java
     }
     else
     {
         return 2 / (a - b);
     }
}

核となる問題は、「小数が多すぎる」場合、たとえば数値として書き込めないdoubleを処理する場合など、double（別名float、または数学言語では実数）のコンピューター表現が間違っていることです。 piまたは1/3の結果）。

したがって、a == bは、aとbのdouble値では実行できません。OS対FPU対数対言語対0の後の3のカウントに応じて、trueまたはfalseになります。

とにかく、コンピューターで "二重値計算"を行う場合は、精度を処理する必要があるため、を行う代わりに、を行うa==b必要があります。absolute_value(a-b)<epsilonイプシロンは、その時点でアルゴリズムでモデル化しているものに相対的です。すべての二重比較でイプシロン値を使用することはできません。

簡単に言うと、a == bと入力すると、コンピューターでは変換できない数学的な式になります（浮動小数点数の場合）。

PS：ハム、私がここで答えるすべては、多かれ少なかれ、他の応答やコメントにあります。

@malarres応答と@Taemyrコメントに基づいて、これが私の小さな貢献です：

public double calculation(double a, double b)
{
     double c = 2 / (a - b);

     // Should not have a big cost.
     if (isnan(c) || isinf(c))
     {
         return 0; // A 'whatever' value.
     }
     else
     {
         return c;
     }
}

私のポイントは言うことです：除算の結果がnanまたはinfであるかどうかを知る最も簡単な方法は、実際に除算を実行することです。