浮動小数点の合計誤差・NaN・-0.0 を実測する

数値講座6。1000万個の合計は396 ulpずれ、Python 3.12のsum()は誤差0。-ffast-mathはKahan補正を消し0/0を1にした。NaNでソートが壊れる様子とシリーズ総まとめ。

シリーズ:数値・お金の計算講座 6/6(上級)。 大量の浮動小数点数を足す人向けの最終回です。アクセス解析の集計、センサーデータ、スコア、統計、ゲームの物理計算、先月の数字と一致しなければならない月次レポート。読み終えると、合計の誤差がどう増えるか、どのアルゴリズムで消せてコストはいくらか、NaN と負のゼロがソート・max・JSON に何をするか、-ffast-math が C のコードから何を黙って消すかが分かります。最後にシリーズ全体のチェックリストを置きました。

第1回で 0.1 + 0.2 が 0.30000000000000004 になるのを見ました。17桁目が1つ違うだけなら害はなさそうです。今回はそれを 1000 万回繰り返したらどうなるか、そして比較の仕方が独特なせいでコードレビューをすり抜ける2つの特別な値、NaN と -0.0 を扱います。日本の業務システムでは円を整数で持つことが多いので金額そのものは安全ですが、ポイント還元率、単価×数量の按分、為替換算、平均や分散といった「途中で小数になる値」の集計で同じ問題が出ます。Apple Silicon Mac(M1 Pro)で Python 3.9.6 と 3.12.14、Apple clang 21、macOS の JavaScriptCore シェル jsc、PHP 8.5.6、Java 26、.NET 10.0.14、Swift 6.4.2、SQLite 3.51.0 を動かしました。乱数は random.Random(42) なので、どの数字も再現できます。

0.1 を 1000 万回足す

いちばん単純な実験です。0.1 を 10,000,000 回足します。正解は 1,000,000 です。

処理系 結果
Python 3.9.6 のループと sum() 999999.9998389754
Python 3.12.14 の sum() 1000000.0
Python math.fsum(両バージョン) 1000000.0
jsc の for ループ 999999.9998389754
PHP 8.5.6 のループ(var_export) 999999.9998389754
C# の double ループ 999999.9998389754
C# の decimal(0.1m)ループ 1000000.0
SQLite 3.51.0 で 10^7 行の sum(0.1) 1000000.0

誤差は 0.00016 で、帳票の合計を確かめる人には見えてしまう大きさです。静かな変化に注意してください。Python 3.12 の組み込み sum() は補正付きの加算(Neumaier 方式)に変わったので、同じスクリプトでも Python を上げただけで合計が変わります。SQLite の sum() もここでは正確でした。最近の SQLite は同系統の補正付き加算(Kahan-Babuska-Neumaier)を使っています。PHP の echo は 999999.99983898 と表示して3桁を隠し、var_export で全桁が見えました。

もう一つの定番は math.fsum([1e100, 1.0, -1e100]) です。fsum は 1.0、素朴なループと Python 3.9 の sum() は 0.0 でした。1e100 に足した時点で 1.0 が消えるからです。Python 3.12 の sum() は 1.0 を返しました。

個数 N とともに誤差はどう増えるか

+ のたびに結果は最も近い double に丸められるので、素朴なループは要素1つにつき1回の丸め誤差を作ります。誤差は一部打ち消し合うので N に比例するほどではありませんが、増えます。誤差は ulp(unit in the last place:その大きさでの隣の double との間隔)で測り、正しく丸めた合計を返す math.fsum を基準にしました。念のため、先頭 10^6 個を Fraction で厳密に足した結果が fsum とビット単位で一致することも確かめています。

def naive(xs):
    s = 0.0
    for x in xs: s += x
    return s

def kahan(xs):
    s = c = 0.0
    for x in xs:
        y = x - c; t = s + y; c = (t - s) - y; s = t
    return s

def neumaier(xs):
    s = c = 0.0
    for x in xs:
        t = s + x
        if abs(s) >= abs(x): c += (s - t) + x
        else: c += (x - t) + s
        s = t
    return s + c

[0, 1) の一様乱数(fsum との差、ulp):

N 素朴なループ 昇順ソート後 ペアワイズ Kahan Neumaier
10^3 1 2 0 0 0
10^4 0 5 0 0 0
10^5 54 50 0 0 0
10^6 33 102 0 0 0
10^7 396 64 1 0 0

符号と桁がばらばらな値(uniform(-1, 1) * 10**randint(-8, 8)):

N 素朴なループ 昇順ソート後 絶対値でソート ペアワイズ Kahan Neumaier
10^3 15 372 4 8 1 0
10^5 64 5,155 3 2 0 0
10^6 129 3,912 55 0 0 0
10^7 532 54,006 44 1 0 0
1000 万個を合計したときの誤差(ulp)の棒グラフ。素朴なループ 396、昇順ソート後のループ 64、ペアワイズ 1、Kahan 0、Neumaier と Python 3.12 の sum 0、math.fsum 0。
[0,1) の一様乱数 10^7 個(シード 42)を各方法で合計したときの誤差。基準は正しく丸めた合計(math.fsum、10^6 個で Fraction の厳密計算と一致を確認)。ここでの 1 ulp は約 9.3e-10。素朴なループは Python 3.9 の sum() と同じ値で、Python 3.12 の sum() は誤差 0 だった。

教訓は二つです。まず、誤差は N に対して単調ではありません(10^5 で 54、10^6 で 33)。ランダムウォークなので、あるデータで通ったテストが別のデータで落ちます。次に、「小さい順に並べてから足せ」という言い伝えは正の数では効きましたが、符号が混ざると 100 倍悪化しました。大きな負の値が先に足されて合計が巨大になり、小さな値を飲み込むからです。絶対値でソートすると改善しましたが、それでも 44 ulp 残りました。補正付きのアルゴリズムはどちらにも勝ちます。

正確さのコスト

10^6 個、5回の中央値、Apple Silicon Mac(M1 Pro):

方法 Python 3.9.6 Python 3.12.14
組み込み sum() 2.5 ms(補正なし) 2.5 ms(補正あり)
素朴な for ループ 19.2 ms 11.8 ms
math.fsum 16.6 ms 7.3 ms
Kahan の for ループ 59.8 ms 32.5 ms
sum(sorted(xs)) 169.0 ms 153.4 ms
Decimal の sum() 39.2 ms 41.7 ms

Python では答えは簡単です。3.12 なら sum() が最速でしかも補正付き、古いバージョンなら math.fsum が正確で、手書きのループより速いです。ソートは最も遅く、最も正確でもありません。

C で 10^7 個の double(clang -O2、5回中の最良)では、素朴なループ 9.71 ms、Kahan 37.37 ms でした。Kahan は各ステップが前のステップに依存するので CPU が加算を重ねられず、約4倍かかります。会計の集計なら安い代償、ゲームのフレーム処理なら高すぎる代償です。

float32 と float64

float(32ビット)は有効数字が10進で約7桁、double(64ビット)は約16桁です。同じ 10^7 個を C で足しました。

double naive             sum=4998269.0432556057  abs err=-3.69e-07  9.71 ms
double kahan             sum=4998269.0432559745  abs err=0          37.37 ms
float naive              sum=4998096.5           abs err=-173       9.32 ms
float data, double acc   sum=4998269.0432599643  abs err=3.99e-06   9.33 ms
float: add 1.0f twenty million times -> 16777216.0

float の変数に足し込むと、500万のうち 173 ずれました。4,194,304(2^22)を超えると隣の float との間隔が 0.5 になり、[0, 1) の値は 0、0.5、1 のどれかに丸められてから足されるからです。データは float のまま、合計だけ double で取ると時間は変わらず、誤差は保存値自体の丸め分の 4e-6 まで下がりました。最後の行が一番劇的で、float のカウンターは 2^24 = 16,777,216 で止まります。16,777,216 + 1 が丸められて 16,777,216 に戻るからです。Java の同じループは 1.6777216E7、jsc の Math.fround(16777217) は 16777216 でした。

原則:float32 は大きな配列の保存(機械学習の重み、頂点データ)や GPU 計算には十分です。合計・平均・分散は float64 で取ります。

-ffast-math:速く、結果が変わり、NaN が見えなくなる

-ffast-math は clang に「浮動小数点を実数の代数のように扱ってよい」と伝えます。加算の順序を入れ替え、NaN や無限大はないものとし、ゼロの符号を無視します。同じファイルを2通りでコンパイルしました。

出力 -O2 -O2 -ffast-math
double 素朴な合計(10^7) 誤差 -3.69e-07、9.71 ms 誤差 3.45e-08、1.75 ms
double Kahan 合計 誤差 0、37.37 ms 誤差 3.45e-08、1.58 ms
float 素朴な合計 誤差 -173 誤差 18
1.0f を 2×10^7 回加算 16777216.0 20000000.0
z = atof("0") で z/z nan 1.000000
v = strtod("nan") で v != v 1 0

何が起きたか。順序の入れ替えが許されたので、clang は素朴なループを複数の部分和にベクトル化しました。5.5倍速く、しかも偶然に精度も上がりました(浅いペアワイズ加算と同じ形になるため)。一方で、Kahan の補正 (t - s) - y は代数的には 0 だと証明して消しました。Kahan 関数は素朴な関数と完全に同じ値を返しています。float のカウンターのループは 20,000,000 と計算済みの値に置き換わりました。厳密な IEEE 演算では出せない「正しい」答えです。そして NaN は存在しないと仮定するので、実行時の 0/0 が 1.0 になり、自分自身との比較による NaN 判定は偽になりました。noinline の補助関数の中のライブラリ呼び出し isnan() だけはまだ動き、NAN マクロを使った行では clang が warning: use of NaN is undefined behavior due to the currently enabled floating-point options [-Wnan-infinity-disabled] を出しました。

補正付き加算、区間演算、NaN チェックを含むコードは -ffast-math でコンパイルしないこと。速さがほしいなら、複数の累積変数やペアワイズ加算を自分で書けば、コンパイラに嘘をつかずにベクトル化できます。最適化が前提を利用する話は C の未定義動作と最適化を参照してください。

NaN:比較・ソート・max・JSON

NaN(非数)は 0/0、inf - inf、0 * inf、パース失敗や欠損データから生まれます。決定的な性質は NaN との比較はすべて偽、NaN == NaN も偽ということです。ソートや max は一貫した順序を前提にしているので、NaN の位置によって壊れ方が変わります。

Python  sorted([3, nan, 1, 2])          -> [3, nan, 1, 2]        (並んでいない)
Python  sorted([nan, 3, 1, 2])          -> [nan, 1, 2, 3]
Python  max([nan, 1, 2]) / max([1, 2, nan]) -> nan / 2
Python  statistics.median([1, nan, 3, 2, 5]) -> 2
Swift   [3, .nan, 1, 2].sorted()        -> [3.0, nan, 1.0, 2.0]
jsc     [3, NaN, 1, 10, 2].sort((a, b) => a - b) -> 3,NaN,1,2,10
jsc     [3, NaN, 1, 10, 2].sort()       -> 1,10,2,3,NaN          (文字列順)
PHP     sort([3, NAN, 1, 2])            -> [NAN, 1, 2, 3]
PHP     max(NAN, 1) / max(1, NAN)       -> 1 / NAN
Java    Arrays.sort(double[])           -> [-0.0, 0.0, 1.0, 2.0, 3.0, NaN]
C#      Array.Sort(double[])            -> NaN, 0, -0, 1, 2, 3
C#      Math.Max(NaN, 1) / LINQ Max([1, NaN, 2]) -> NaN / 2

Java と C# はソート用に全順序を定義しているので(Java は NaN を最後、C# は最初)正しく並びます。それ以外はエラーなしでおかしな結果を返します。median まで 2 というもっともらしい値を返しました。怖いのは見える NaN ではなく、その隣の間違った答えです。

所属判定も奇妙です。Python では nan in [nan] は True(同じオブジェクトなので同一性で見つかる)ですが、float('nan') in [float('nan')] は False で、{float('nan'), float('nan')} は要素が2つになります。jsc では [NaN].includes(NaN) が true なのに [NaN].indexOf(NaN) は -1、isNaN("abc") は true で Number.isNaN("abc") は false でした。

JSON には NaN がありません。言語ごとの反応です。

呼び出し 結果
Python json.dumps([nan, inf, -0.0]) [NaN, Infinity, -0.0](正しい JSON ではない)
Python json.dumps(nan, allow_nan=False) ValueError: Out of range float values are not JSON compliant
jsc JSON.stringify([NaN, Infinity, -0]) [null,null,0]
jsc JSON.parse('[NaN]') SyntaxError: JSON Parse error: Unexpected identifier "NaN"
PHP json_encode(NAN) false、Inf and NaN cannot be JSON encoded
.NET JsonSerializer.Serialize(double.NaN) ArgumentException: .NET number values such as positive and negative infinity cannot be written as valid JSON.
SQLite INSERT … VALUES (9e999 - 9e999) NULL として保存

Python のサービスが NaN を出すと JavaScript 側の JSON.parse が落ち、JavaScript 側は NaN を黙って null にし、SQLite は NULL にして sum() や avg() が読み飛ばします。境界で決めてください。入力で NaN を拒否し、値がないときは意図して null を送ります。大きな整数 ID と JSON の問題は第2回で、PHP の例は プリペアドステートメントで JSON の数値型が変わる話にあります。

負のゼロ

IEEE 754 にはゼロが2つあります。-0.0 == 0.0 は試したどの言語でも真ですが、符号は漏れ出します。

  • 1 / -0.0 は C で -inf、jsc で -Infinity。
  • Python の repr(-0.0) は -0.0。max(0.0, -0.0) は 0.0、max(-0.0, 0.0) は -0.0(同点なら先の引数が勝つ)。
  • 小さな負の値を整形するとマイナスが出ます。Python f"{-0.004:.2f}"、jsc (-0.004).toFixed(2)、Java String.format("%.2f", -0.004)、.NET ToString("F2") はどれも -0.00。jsc の Intl.NumberFormat("en-US", {maximumFractionDigits: 2}) は -0、PHP の number_format(-0.004, 2) は 0.00 でした。
  • Java の Double.valueOf(0.0).equals(-0.0) は false なので、HashMap<Double, …> は両方をキーとして持ちます。
  • JSON.stringify(-0) は 0、PHP の json_encode(-0.0) は -0、SQLite は -0.0 を 0.0 として保存しました。

為替換算の差額 0.004 ドルが -0.00 と表示される、というのが現場で一番多い苦情です。先に通貨の最小単位に丸め(第4回)、表示の前にゼロかどうかを調べて正規化します。

よくある間違い → 実際に起きること → 直し方

間違い 実際の結果 直し方
何百万個の float をループで合計 10^7 個で 396 ulp ずれる math.fsum、Neumaier、Python 3.12 以降の sum()
「並べてから足す」 符号が混ざると 54,006 ulp 補正付きの加算を使う
float32 の累積変数 500万のうち 173 ずれる float64 で累積
float のカウンター 16,777,216 で止まる 整数のカウンター
Kahan と -ffast-math 補正が消える そのファイルは fast-math なし
NaN 入りで sorted()/max() 並ばない、順序で変わる max 先に isnan で除く
NaN を json.dumps 他の言語で読めない JSON allow_nan=False、null を送る
小さな負の値を丸めて表示 -0.00 丸めてからゼロを正規化
合計を == で比較 Python 3.9 と 3.12 で合計が違う 整数の円、または math.isclose

int・Decimal・float の使い分け

判断の図。まず数値が何を表すかを見る。お金や税、領収書と一致すべきものは最小単位の整数、率や1円未満の端数が必要なら Decimal。個数や ID は 64 ビット整数で、2 の 53 乗を超えうるなら JSON では文字列。測定値・統計・グラフィックスは float64。float32 は保存や GPU 用に限り、合計は float64 で取る。多数の浮動小数点数を合計するときは fsum、Neumaier、ペアワイズを使い、NaN は入力の境界で拒否する。
どの数値型を使うかの判断図。各分岐は本シリーズの実行結果に基づく。0.1 を 1000 万回足すと double では 999999.9998389754、C# の decimal ではちょうど 1000000.0。float32 は 16777216 で数えるのをやめ、NaN は Python・Swift・jsc のソートを壊した。
  • お金、税、領収書と一致すべきもの: 最小単位の整数(円ならそのまま整数)、率や1円未満の端数が要るなら Decimal(第4回)。C# の decimal は 0.1 を 1000 万回足してちょうど 1000000.0 でした。
  • 個数と ID: 64ビット整数。2^53 を超えうるなら JSON では文字列(第2回)。
  • 測定値・統計・機械学習・グラフィックス: float64。float32 は保存や GPU 用に限り、累積は float64。N が大きいときや結果を実行間で比べるときは fsum か補正付きの方法で合計します。

シリーズのまとめチェックリスト

  1. 型を知る:0.1 のようなリテラルは最初から2進で丸められている(第1回)。float は許容誤差で比べ、== を使わない。
  2. 上限を知る:2^31、2^63、そして JavaScript の数値と JSON の 2^53(第2回)。
  3. 丸め方を意図して選び(偶数丸めか四捨五入か)、最後に1回だけ丸める。消費税の端数処理のような決まりは所轄の案内や税理士に確認する(第3回)。
  4. お金は最小単位の整数か Decimal で持ち、float にしない(第4回)。
  5. 整形した数値を保存しない。入力はロケールを明示し、厳格なパターンで読む。全角数字に注意(第5回)。
  6. 補正付きで合計し、NaN は境界で止め、-0.0 は表示前に正規化し、数値の正しさが要るコードに -ffast-math を使わない(今回)。
  7. 境界値のテストを書く:0.1、2.5、-0.0、NaN、2^53 + 1、空の入力。はじめての単体テストも参照。

正直な限界とバージョンの注意

  • Python の sum() が float に補正付き(Neumaier)加算を使うのは 3.12 からです。3.9.6(補正なし)と 3.12.14(補正あり)で確認しました。
  • SQLite の sum(0.1) が正確だったのは 3.51.0 での測定です。古い SQLite は素朴な合計だったので、手元のバージョンを確認してください。
  • -ffast-math の結果は arm64 上の Apple clang 21 のものです。GCC や他のターゲットでは並べ替え方が違います。Kahan の補正が消える、NaN が畳み込まれるという傾向はよくありますが、数値そのものは移植できません。Linux では実行していません。
  • ulp 単位の誤差はデータ次第です。2つのデータは random.Random(42) から作りました。別の分布なら数値は変わりますが、方法の順位は同じでした。
  • 時間は1台のマシン(M1 Pro)で5回の最良値または中央値を取ったもので、それ以上のウォームアップ制御はしていません。

練習問題

1. ダッシュボードが Python 3.9 で 200 万件の注文金額(float)を合計し、Python 3.12 のジョブが出した前日の数値と比べています。10桁目が違います。原因と直し方を2つ挙げてください。

2. 実行せずに答えてください。Python で max([float("nan"), 5.0]) と max([5.0, float("nan")]) は何を出しますか。代わりにどう書きますか。

解答

1. Python 3.12 の sum() は補正付きで 3.9 は違うため、下の桁がずれます(0.1 の実験では 999999.9998389754 と 1000000.0)。直し方は、両方のジョブで math.fsum を使うこと。売上ならもっと良いのは、円を整数で持って整数を足すことで、どのバージョンでも正確です。

2. 順に nan と 5.0 です。max は最初の要素を持ち、x > 現在値 が真のときだけ入れ替えますが、NaN がどちら側にあってもそれは真になりません。max(x for x in xs if not math.isnan(x)) と書き、入力の NaN が何を意味するか(たいていは、もっと手前で拒否すべき)を明示的に決めます。

続き

よくある質問

小さい順に並べてから足せば誤差は減りますか?

確実ではありません。[0,1) の正の値 1000 万個では昇順ソートで誤差が 396 ulp から 64 ulp に減りましたが、符号と桁がばらばらなデータでは逆に 532 ulp から 54,006 ulp に悪化しました。Kahan、Neumaier、math.fsum、Python 3.12 の sum() は、試したすべてのケースで誤差 0〜1 ulp でした。

NaN が入っているとき Python の sorted() はどうなりますか?

NaN との比較はすべて False なので、並べ替えが矛盾した答えを受け取ります。sorted([3, nan, 1, 2]) は [3, nan, 1, 2] のまま返り、max([nan, 1, 2]) は nan、max([1, 2, nan]) は 2、statistics.median([1, nan, 3, 2, 5]) は 2 でした。Swift と jsc も同じように壊れます。並べる前に math.isnan で取り除きます。

-ffast-math を付けても大丈夫ですか?

正確な丸めや NaN に依存しないコードに限ります。clang -O2 -ffast-math では Kahan 加算が素朴なループと同じ結果になり、実行時に計算した 0.0/0.0 が nan ではなく 1.000000 と表示され、入力から読んだ NaN で v != v が 0 になりました。素朴な合計は 5.5 倍速くなり、たまたま精度も上がりました。

  • #数値計算
  • #上級
  • #浮動小数点
  • #NaN
  • #Kahan加算
  • #Python
  • #C言語
  • #JavaScript
  • #SQLite

t.laboratory

実際に作って運用しているアプリ・サーバー・サービスで起きた問題と、その解決に使ったコードを記録する技術ブログです。

運営者情報 · アプリ

↑