浮動小数点数の10進数演算:楽しみと利益のために
Adding Floating-Point Decimals for Fun and Profit (blog.vero.site)
要約
プログラミング言語における浮動小数点数は、通貨計算などで丸め誤差を生じさせ、正確な10進数演算を困難にします。この記事では、IEEE 754規格と「ulp(unit in the last place)」の概念を解説し、なぜ0.1 + 0.2 が正確に0.3にならないのかを説明します。また、浮動小数点数の結果を10進数に変換する際の複雑さや、一般的な10進数加算における誤差の分析についても掘り下げています。
全文翻訳
浮動小数点数による10進数の加算:楽しみと利益のために
2026-08-30 (2527 words) filed under Math, CS
多くの人が、米ドルとセントのような10進数の計算を、ほとんどのプログラミング言語の浮動小数点数で行うべきではないと知っています。これは、10進数をその浮動小数点数として正確に表現できないため、丸め誤差に遭遇するからです。
有名な例として、IEEE倍精度浮動小数点数では、0.1 + 0.2 は 0.3 ではなく、0.30000000000000004 になります。
一方で、私はPythonのREPLを使って、レシートの10進数を常に合計しています。もちろん、私のリスクは低いです。私は1ドルから100ドルの範囲のものを合計しており、コピーする前に微小な誤差を手動で丸めることを知っています。しかし、実際には、それらの誤差が全く現れないこともかなりよくあります。
0.01の倍数を1.00まで全てのペアで合計し、結果が大きすぎる(青)、小さすぎる(赤)、または正しいかどうかを見ると、クールなパターンが得られます。
Figure 1: 0.01の倍数を2つ足し合わせたときの浮動小数点数の影響、1.00まで
このパターンはどこから来るのでしょうか?
浮動小数点数について(簡単に)
倍精度浮動小数点数 (x) は、1つの符号ビット、11個のエキスポーネントビット、52個のフラクショントビット(この順序)で構成され、合計64ビットです。
符号ビットは (+) または (-) の符号を提供します。エキスポーネントビットは、−1022から1023までの整数 (E) を表します。フラクショントビットは、(2^{52}) 未満の非負整数 (F) を表し、これはシグニサンド (1 + F/{2^{52}} \in \lbrack1, 2)) に対応します。この常に存在する (1) は「隠れビット」と呼ばれます。浮動小数点数の値は (x = \pm 2^E(1 + F/{2^{52}})) です。
したがって、最後のフラクショントビットの実効値は (2^{E-52}) となり、これは (x) の「最下位ビットの値」を意味する ulp(unit in the last place)と呼ばれます。(x) に最も近い2つの浮動小数点数は、1つのulpだけ異なります。ただし、(F = 0) で (x) がちょうど2のべき乗であるエッジケースを除く。
"hidden bit"52 bits float(0.1) = 0.00011001100110011001100110011001100110011001100110011010₂
ulp(float(0.1)) = 0.00000000000000000000000000000000000000000000000000000001₂
この説明は私たちの目的に十分ですが、0、非正規数、無限大、NaNなど、他の多くのケースを無視しています。これらは、私が説明しなかったエキスポーネントビットの2つの値を使用します。また、簡単のため、他の精度の浮動小数点数も考慮しません。
加算の解剖
例として(qntmなどに倣って)、Python REPLで 0.1 + 0.2 と入力したときに何が起こるかをステップごとに見てみましょう。1
まず、Pythonの式 0.1 はある浮動小数点数に評価されます。具体的には、IEEE標準で要求されるように、0.1に最も近い浮動小数点数です。その正確な数値を (\text{float}(0.1)) と書くことにします。2
同様に、Pythonの式 0.2 は別の浮動小数点数 (\text{float}(0.2)) に評価されます。
次に、+ が2つのステップで評価されると想像できます。まず、Pythonは正確な合計 (\text{float}(0.1) + \text{float}(0.2)) を計算します。次に、それを最も近い浮動小数点数に丸めます。結果の値は (\text{float}(\text{float}(0.1) + \text{float}(0.2))) です。(これは文字通りには動作しません。最初のステップの正確な合計はどこにも具体化されませんが、数学的には正確です。)
実際には、私がこの詳細を徹底的に調べ出すまで気づかなかった微妙な点があります:(\text{float}(0.1) + \text{float}(0.2)) は、その2つの最も近い浮動小数点数に等しく近いのです!このような場合、Pythonはシグニサンドが偶数の浮動小数点数に丸めます。この場合は切り上げになります。3
最後に、この値を表示するために、Pythonはそれを10進数に変換する必要があります。この変換は驚くほど微妙で、IEEE標準で正確に指定されているわけではありません!(\text{float}(\text{float}(0.1) + \text{float}(0.2))) は正確に0.3ではありませんが、かなり近いので、「0.3」と表示しても不合理ではありません。別の選択肢としては、正確に「0.3000000000000000444089209850062616169452667236328125」と表示することです。また、様々な丸め量で表示することも考えられます:0.300000000000000044、または0.30000000000000004441、などです。(\text{float}(\text{float}(0.1) + \text{float}(0.2)) = \text{float}(0.30000000000000005)) であることは依然として真実であるため、例えば0.30000000000000005 を表示することも想像できます。つまり、Pythonの式 0.1 + 0.2 == 0.30000000000000005 は真です。この変換の微妙さは、Python 3.1の特定のパッチまで、REPLで 1.1 と入力すると、Pythonは入力されたものを 1.1000000000000001 と表示していたという事実によって証明されます。
この10進数変換がどのように機能すべきかについての標準的な説明は、Steele and White, 19904 によって形式化され、3つの基準5が定められています。
- 10進数表現はラウンドトリップ可能であるべきです。つまり、再度入力すると、同じ浮動小数点数が得られるべきです。これは「0.3」という出力を除外します。
- 基準1を満たす場合、10進数表現は可能な限り短くあるべきです。これは「0.30000000000000004441」のような出力を除外します。
- 基準1と2を満たす場合、10進数表現は浮動小数点数に可能な限り近いはずです。これは「0.30000000000000005」のような出力を除外します。
このアルゴリズムに従うと、0.1 + 0.2 == 0.30000000000000004 となる理由を理解できます。
一般化
一般的なケースを考えてみましょう。正確な正の10進数量 (a) と (b) を足そうとしているとします。その正確な合計は (c) です。まあ、完全には一般的ではありません。これらの値は「妥当なドル金額」であり、正で70兆ドル未満であると仮定します。これは私が提出しなければならないレシートをカバーするには十分だと思います。それより少し上(246 = 70,368,744,177,664)になると、浮動小数点数はセントの倍数よりも疎になり、これは良くありません。
問題は、(\text{float}(\text{float}(a) + \text{float}(b))) は (\text{float}(c)) とどのように比較されるかです。
その差を (\Delta := \text{float}(\text{float}(a) + \text{float}(b)) - \text{float}(c)) とします。誤差関数 (\text{error}(x) := \text{float}(x) - x) を導入することで、これを推論できます。すると、(\Delta) を次のように書き換えることができます。
(\begin{aligned}\Delta ={} &\text{error}(a) + \text{error}(b) \&+ \text{error}(\text{float}(a) + \text{float}(b)) - \text{error}(c).\qquad(*)\end{aligned})
各誤差項を限界づけることができます。浮動小数点数の ulp(unit in the last place)は、最下位ビットの値であることを思い出してください。表記を多少乱用して、(x) が浮動小数点数として正確に表現できない場合でも (\text{ulp}(x)) と書くことを許可し、これが (\text{ulp}(\text{float}(x))) を意味すると理解することにします。したがって、(\text{float}(x) \pm \text{ulp}(x)) も浮動小数点数であり6、(x) からの距離は (\text{float}(x)) 自体よりも近くないはずです(そうでなければ、(\text{float}(x)) はより近い値に評価されたはずです)。これは、すべての(妥当な)(x) に対して、(\ [
|\text{error}(x)| \leq \frac{\text{ulp}(\text{float}(x))}{2}.\ ]
が成り立つことを意味します。さらに、(x) が最も近い2つの浮動小数点数のちょうど中間に位置する場合にのみ等号が成立しますが、(x) が妥当な金額である場合にはこれは成り立ちません7。この限界を項ごとに ((*)) に適用すると、(|\Delta| < 2\text{ulp}(c)) と結論付けることができます。さらに、(\Delta) は (c) に近い2つの浮動小数点数の差であるため、(\text{ulp}(c)) の倍数です8。ここから、(\Delta \in {-\text{ulp}(c), 0, +\text{ulp}(c)}) 、つまり結果は答えから最大1 ulpずれると結論付けられます。
しかし、(|\Delta|) の中間限界をよりタイトに生成する導出があります。ここでは、(a \leq b) と仮定します。すると、(\text{float}(c) + \text{ulp}(c) - \text{float}(b)) は表現可能な浮動小数点数です。なぜなら、結果のulpは (b) と (c) の両方のulp以下だからです。したがって、少なくともこれは (a) の利用可能な近似です。そしてそれは過大評価です。
(\ [
\begin{aligned}a &= c - b \ &\leq \text{float}(c) + \frac{\text{ulp}(c)}{2} - \text{float}(b) + \frac{\text{ulp}(c)}{2} \ &= \text{float}(c) - \text{float}(b) + \text{ulp}(c).\end{aligned}\ ]
したがって、
(\ [
\begin{aligned}\text{float}(a) &\leq \text{float}(c) - \text{float}(b) + \text{ulp}(c)\ \text{float}(a) + \text{float}(b) &\leq \text{float}(c) + \text{ulp}(c).\end{aligned}\ ]
これを (a + b = c) から引くと、
(\ [
\text{error}(a) + \text{error}(b) \leq \text{error}(c) + \text{ulp}(c).\ ]
同じ限界が反対側からも適用されます。結果として、
(\ [
\delta := \text{error}(a) + \text{error}(b) - \text{error}(c),\ ]
とすると、
(\ [
-1 \leq \frac{\delta}{\text{ulp}(c)} \leq 1.\ ]
前と同様に、(|\delta - \Delta| \leq \text{ulp}(c)/2) であることを知っており、再び (\Delta) は (\text{ulp}(c)) の倍数であるため、(\Delta \in {-\text{ulp}(c), 0, +\text{ulp}(c)}) であることがわかります。
(\delta/\text{ulp}(c)) のヒートマップを作成すると、Figure 1 のより連続的なバージョンと見なせるものが表示されます。
Figure 2: 0.01の倍数を2つ足し合わせたときの浮動小数点誤差の合計、1.00まで
これで、Figure 1 を、偶数シグニサンドを持つ浮動小数点数への丸めによって、(\delta) が正確に (\pm\text{ulp}(c)/2) となる領域で発生する市松模様パターンを持つ「丸められた」バージョンとして解釈できます。
Figure 3: 奇数浮動小数点シグニサンドを持つ0.01の倍数
そして、Figure 2 を、3つの (\text{error}) 関数の「干渉」の結果として解釈できます。1つは水平、1つは垂直、1つは対角線(ただし、分母は変化する)です。
Figure 4: Figure 2 を項に分解する
残る疑問は、なぜ (\text{error}(x)) がそのように見えるのかということです。
一次元誤差
Figure 5: 0.01の倍数における誤差関数、2.00まで
まず、(x) がちょうど2のべき乗である場合、(\text{error}(x) = 0) であることに注目します。2つのそのようなべき乗の間で、(\text{error}(x)) と (\text{error}(x+0.01)) を比較してみましょう。(\text{ulp}(x) = \text{ulp}(x+0.01)) なので、(\text{float}(x + 0.01) \equiv 0 \equiv \text{float}(x) \bmod \text{ulp}(x)) となり、
(\ [
\text{error}(x + 0.01) \equiv \text{error}(x) - 0.01 \bmod \text{ulp}(x);\ ]
つまり、(\text{error}(x)) は (\text{ulp}(x)) を法とする「公差 −0.01 の等差数列」です。したがって、この関数のラップアラウンド動作が、以前の図の周期的なパターンにつながります。
Figure 2 の右下象限、(\ \lbrack0.5, 1] \times \ \lbrack0.5, 1]) に焦点を当てましょう。この領域では、(\text{ulp}(0.5) = 2^{-53}) および (\text{ulp}(1) = 2^{-52}) を計算でき、その後、
(\ [
\begin{aligned}\frac{0.01 \bmod \text{ulp}(0.5)}{\text{ulp}(0.5)} &\equiv 0.92\equiv -0.08 \bmod 1 \ \frac{0.01 \bmod \text{ulp}(1)}{\text{ulp}(1)} &\equiv 0.96\equiv -0.04 \bmod 1,\end{aligned}\ ]
どちらも「0に近い」です。(0.08 \approx 1/12) であるため、(x \in \ \lbrack0.5, 1]) の場合、(\text{error}(x)) はラップアラウンドする前に12の「ステップ」を持ちます。また、(0.04 = 1/25) であるため、(x \in \ \lbrack1, 2]) の場合、(\text{error}(x)) はラップアラウンドする前に25の「ステップ」を持ちます。
パターンをさらに理解するために、
(\ [
\frac{0.01 \bmod 2^{-n}}{2^{-n}} = 0.01 \times 2^n \bmod 1 = \frac{2^n \bmod 100}{100}.\ ]
と計算できます。実際、倍精度浮動小数点数のフラクショントビット数である52が、(2^{52}) が100を法として「0に近い」という良い偶然の一致です。これが誤差関数があまりラップアラウンドせず、滑らかな領域がある理由です。図を (a, b \in \ \lbrack0, 2]) に拡張して、(c) が (\ \lbrack2, 4]) に達するようにすると、(\ [
\frac{0.01 \bmod \text{ulp}(2)}{\text{ulp}(2)} \equiv 0.48\bmod 1\ ]
であり、(\text{error}(x)) は (\ \lbrack2, 4]) の (x) のステップごとにほぼラップアラウンドするため、より複雑な市松模様と対角線が表示されます。これは (c) のシグニサンドのパリティとより複雑な方法で干渉します。
Figure 6: 0.01の倍数を2つ足し合わせたときの浮動小数点数の影響、2.00まで
Figure 7: 0.01の倍数を2つ足し合わせたときの浮動小数点誤差の合計、2.00まで
Figure 8: 奇数浮動小数点シグニサンドを持つ0.01の倍数、4.00まで
Figure 9: 0.01の倍数における誤差関数、4.00まで
付録:浮動小数点数におけるエラーフリー変換
(これはおそらく本文よりも実用的です)
例えば、この投稿の図を生成するために、コンピュータ上で (\text{error}(x) = \text{float}(x) - x) のような関数を実際にどのように計算しますか?明らかに、研究しているのと同じ浮動小数点形式で直接計算することはできません。その形式では、(\text{float}) は恒等関数です。(x) を表現しようとする時点で、誤差はすでに発生しています。
概念的に最も簡単な方法は、Pythonの [fractions](https://docs.python.org/3/library/fractions.html) のような、何らかの正確な有理数演算を使用することです。私の最初の探索では、Noulith(その rational 型に多数の機能とバグ修正を場当たり的に追加した後…)を使用しました。
しかし、浮動小数点形式から離れることなく、このような誤差を扱う間接的な方法が数多くあることが判明しました。これらのテクニックは「エラーフリー変換」と呼ばれると信じています。
2Sum(Møller, 1965):(a) と (b) から、(a +\ \text{float}\ b = s) かつ (a + b = s + t) となるように (s) と (t) を計算します。
def two_sum(a: float, b: float) -> tuple[float, float]:
s = a + b
bb = s - a
return s, (a - (s - bb)) + (b - bb)
Veltkamp分割9:(a) から、(a = h + \ell) となり、(h) と (\ell) の両方が(隠れビットの後で)最大26ビットの有効桁数を持つように (h) と (\ell) を計算します。これは、そのような2つの浮動小数点数を浮動小数点数で乗算すると正確になるため役立ちます。(マジック定数を変更することで、(h) と (\ell) の間で有効桁数を再割り当てできます。)
def veltkamp_split(a: float) -> tuple[float, float]:
c = ((1 << 27) | 1) * a
hi = c - (c - a)
return hi, a - hi
Dekker積10:(a) と (b) から、(a \times\ \text{float}\ b = p) かつ (a \times b = p + r) となるように (p) と (r) を計算します。
def dekker_product(a: float, b: float) -> tuple[float, float]:
p = a * b
ah, al = veltkamp_split(a)
bh, bl = veltkamp_split(b)
return p, ((ah * bh - p) + ah * bl + al * bh) + al * bl
これらのテクニックを使用して、(\text{error}(n / 100)) の十分な近似を次のように計算できます。
def err_over_100(n: float) -> float:
d = n / 100
p, e = dekker_product(100, d)
return ((p - n) + e) / 100