閉じる

【C#】浮動小数点数の比較で発生する誤差の回避策と推奨される実装パターン

広告

C#を用いてアプリケーションを開発する際、多くのエンジニアが一度は直面するのが「浮動小数点数の計算誤差」という問題です。

数値計算の結果を比較演算子で判定しようとしたところ、期待通りの挙動を示さずバグの原因になってしまった経験を持つ方も多いのではないでしょうか。

浮動小数点数はコンピュータの内部でバイナリ（2進数）として表現されるため、人間が日常的に使用する10進数の数値を正確に表現できないケースが存在します。

本記事では、2026年現在のC#開発において標準的とされる浮動小数点数の比較手法と、誤差によるトラブルを回避するための実践的な実装パターンを詳しく解説します。

目次 [ close ]
  1. 浮動小数点数で誤差が発生する根本的な理由
  2. 許容誤差（エプシロン）を用いた比較手法
    1. 絶対誤差による比較
    2. 相対誤差による比較の必要性
  3. C#における型選択と精度の使い分け
  4. モダンC#における汎用的な数値比較の実装
  5. 浮動小数点数の比較で避けるべきアンチパターン
  6. 実務で役立つ「ほぼ等しい」の拡張メソッド
  7. パフォーマンスへの影響と最適化
  8. まとめ

浮動小数点数で誤差が発生する根本的な理由

C#で一般的に利用されるfloat（単精度浮動小数点数）やdouble（倍精度浮動小数点数）は、IEEE 754規格に基づいています。

この規格では、数値を「符号」「指数部」「仮数部」に分けてビット列として管理しています。

しかし、10進数における「0.1」や「0.2」といった単純な数値であっても、2進数に変換すると無限小数になってしまいます。

有限のビット数で無限小数を表現しようとすると、必ずどこかで値を切り捨てる必要が生じ、これが「丸め誤差」として蓄積されます。

例えば、以下のコードを実行すると、直感に反する結果が得られます。

C#
double a = 0.1;
double b = 0.2;
double sum = a + b;

// 0.3になることを期待するが、実際にはfalseになる
bool isEqual = (sum == 0.3);

Console.WriteLine($"Sum: {sum}");
Console.WriteLine($"Is Equal: {isEqual}");
実行結果
Sum: 0.30000000000000004
Is Equal: False

このように、わずか 0.00000000000000004 の差によって、等価比較が失敗してしまいます。

これが、浮動小数点数を直接==演算子で比較してはいけない最大の理由です。

許容誤差（エプシロン）を用いた比較手法

浮動小数点数の等価比較を行うための最も標準的な方法は、「2つの値の差が十分に小さいかどうか」を判定することです。

この「十分に小さい値」のことを「エプシロン（Epsilon）」と呼びます。

絶対誤差による比較

絶対誤差による比較は、2つの数値の差の絶対値を求め、それが定義した許容範囲内にあるかを確認するシンプルな手法です。

C#にはdouble.Epsilonという定数が存在しますが、これは「0より大きい最小の正の数」を表すものであり、比較時の許容誤差としてそのまま使うには小さすぎます。

実務では、計算の精度要件に合わせて1e-9（0.000000001）などの独自の定数を使用するのが一般的です。

C#
public static bool AreClose(double value1, double value2, double epsilon = 1e-9)
{
    // 差の絶対値が許容範囲内であれば等しいとみなす
    return Math.Abs(value1 - value2) < epsilon;
}

この手法は実装が容易であり、計算負荷も低いため、多くのシーンで推奨されます。

相対誤差による比較の必要性

絶対誤差には、扱う数値が非常に大きい場合や非常に小さい場合に判定が狂うという欠点があります。

例えば、数兆という巨大な数値を扱っている場合、1e-9という誤差は無視できるほど小さいものになります。

一方で、ナノ単位の微細な数値を扱っている場合、1e-9は非常に大きな差となってしまいます。

このようなケースでは、数値の大きさに応じて許容誤差を調整する「相対誤差」を用いた比較が有効です。

C#
public static bool AreCloseRelative(double a, double b, double epsilon = 1e-9)
{
    if (a == b) return true;

    double diff = Math.Abs(a - b);
    double absA = Math.Abs(a);
    double absB = Math.Abs(b);
    double max = (absA > absB) ? absA : absB;

    // 数値の大きさに比例した誤差を許容する
    return diff < epsilon * max;
}

このロジックを導入することで、値のスケールに依存しない堅牢な比較が可能になります。

C#における型選択と精度の使い分け

計算誤差の問題を解決するもう一つのアプローチは、適切なデータ型を選択することです。

C#には、用途に応じて異なる特性を持つ数値型が用意されています。

型サイズ精度（有効桁数）特徴・推奨される用途
float4バイト約6～9桁グラフィックス処理、メモリ節約が必要な場合
double8バイト約15～17桁一般的な科学技術計算、デフォルトの浮動小数点数
decimal16バイト28～29桁金融・財務計算、通貨の取り扱い

特に重要なのが、decimal型の存在です。

decimalは内部的に10進数ベースの表現形式を採用しているため、「0.1」を正確に保持することができます。

財務システムや請求処理など、1円の狂いも許されない計算においては、必ずdecimalを使用するようにしてください。

ただし、decimalはdoubleに比べて処理速度が遅く、計算リソースを多く消費する点には注意が必要です。

モダンC#における汎用的な数値比較の実装

.NET 7以降で導入された「Generic Math（汎用数値演算）」を利用することで、floatやdoubleに関わらず動作する汎用的な比較メソッドを作成できます。

IFloatingPointIeee754<TSelf>インターフェースを活用した実装例を紹介します。

C#
using System.Numerics;

public static class NumericExtensions
{
    public static bool IsNearlyEqual<T>(T left, T right, T epsilon)
        where T : IFloatingPointIeee754<T>
    {
        // ジェネリックに絶対値の差を比較
        return T.Abs(left - right) < epsilon;
    }
}

// 使用例
double d1 = 0.3;
double d2 = 0.1 + 0.2;
bool result = NumericExtensions.IsNearlyEqual(d1, d2, 1e-12);

この方法であれば、型ごとにオーバーロードを作成する手間が省け、コードの再利用性が高まります。

2026年現在のモダンなプロジェクトにおいては、このようなインターフェース制約を活用した実装がスタンダードになりつつあります。

浮動小数点数の比較で避けるべきアンチパターン

良かれと思って実装したコードが、予期せぬ不具合を招くことがあります。

ここでは、比較において避けるべき典型的なアンチパターンを挙げます。

1. Math.Roundの結果を比較する

「四捨五入して桁数を合わせれば比較できる」と考えるのは危険です。

丸め処理自体に誤差が伴う可能性があり、境界値付近で判定が逆転するリスクがあります。

計算の最終出力として数値を整形する場合には有効ですが、ロジックの分岐条件に丸め処理を利用するのは推奨されません。

2. ループの終了条件に浮動小数点数を使用する

以下のようなコードは無限ループに陥る可能性があります。

C#
// 危険なループ条件
for (double x = 0; x != 1.0; x += 0.1)
{
    // xが正確に1.0にならないため、終了しない可能性がある
}

ループ回数を制御する場合は、必ず整数型（int）を使用し、その中で浮動小数点数を計算するようにしましょう。

3. ToString() の結果で文字列比較を行う

数値を文字列に変換して比較するのは、パフォーマンスが著しく低いうえに、文化圏（Locale）による表示形式の違いによって失敗する可能性があります。

数値は数値のまま、数学的なアプローチで比較するのが鉄則です。

実務で役立つ「ほぼ等しい」の拡張メソッド

開発効率を高めるために、プロジェクト内で共通して利用できる拡張メソッドを定義しておくことをお勧めします。

以下に、安全性と利便性を両立した実装例を示します。

C#
public static class DoubleExtensions
{
    private const double DefaultEpsilon = 1e-10;

    public static bool IsCloseTo(this double value, double target, double epsilon = DefaultEpsilon)
    {
        if (double.IsInfinity(value) || double.IsInfinity(target))
        {
            return value == target;
        }

        if (double.IsNaN(value) || double.IsNaN(target))
        {
            return false;
        }

        return Math.Abs(value - target) < epsilon;
    }
}

この実装では、Infinity（無限大）やNaN（非数）のチェックも含めており、より堅牢なプログラムとなります。

また、「拡張メソッド」として定義することで、if (myValue.IsCloseTo(0.3))のように直感的に記述できるようになります。

パフォーマンスへの影響と最適化

浮動小数点数の比較を厳密に行うことは重要ですが、ゲームエンジンやリアルタイムシミュレーションなどの分野では、パフォーマンスとのトレードオフが重要になります。

Math.Absの呼び出しは非常に軽量ですが、大量のパーティクル計算など、1フレームに数百万回の比較を行う場合は、計算コストが無視できなくなることもあります。

そのような極限の環境では、「厳密な一致が不要な場合は、比較をスキップする」あるいは「あらかじめ整数値にスケーリングして比較する」といった最適化が検討されます。

しかし、一般的なビジネスアプリケーションやWebサーバーのロジックにおいては、前述のMath.Absを用いたエプシロン比較によるオーバーヘッドを気にする必要はほとんどありません。

可読性と正確性を優先し、チーム内で統一された比較ロジックを使用することに重点を置いてください。

まとめ

C#における浮動小数点数の比較は、一見単純に見えて非常に奥が深く、注意が必要なトピックです。

==演算子による安易な比較は、プログラムの信頼性を損なう「サイレントなバグ」の原因となります。

誤差を完全に排除することは不可能ですが、「許容誤差（エプシロン）を用いた比較」や「decimal型の適切な使用」によって、その影響を適切に制御することは可能です。

本記事で紹介した実装パターンや、モダンC#のジェネリック数学を活用し、より堅牢で正確な数値計算処理を実装してください。

最後に、主要なポイントを整理します。

  • floatやdoubleの比較に==は原則使用しない。
  • 絶対誤差（Math.Abs(a - b) < epsilon）による比較を基本とする。
  • 値のスケールが大きい場合は相対誤差の利用を検討する。
  • お金に関わる計算には必ずdecimal型を使用する。
  • プロジェクト全体で統一された比較用の拡張メソッドを定義する。

これらのルールを徹底することで、浮動小数点数に起因するトラブルの多くを未然に防ぐことができるでしょう。

URLをコピーしました！