小数の表し方 -- 浮動小数点数と IEEE 754

この講義では、小数が0と1しかない世界でどのように表されるのか、そしてなぜ浮動小数点数に精度誤差が生じるのかを理解できます。


身近な例え:科学的記数法

物理の授業で科学的記数法を見たことがあるはずです:

光速 = 3.0 x 108m/s、電子の質量 = 9.1 x 10-31 kg。

この方法では、少ない桁数で非常に大きな数や非常に小さな数を表せます。

コンピュータが小数を表すときも、まったく同じ考え方を使っています。2進数の科学的記数法。

あらゆる2進数の小数は次のように書けます:

1.xxxxxxxxxx x 2yyyyy

この形式では、3つのものだけを保存すれば十分です。

  • 符号:プラスかマイナスか?
  • 仮数(xxxxxxxxxx):有効数字の部分
  • 指数(yyyyy):小数点の位置

IEEE 754 規格は、この3つを固定の形式で32ビットに詰め込んだものです。


IEEE 754 単精度の3つの部分構造

32ビット(単精度 float)は正確に3つの部分に分けられています:

符号ビット Sign 0 1 ビット
指数部 Exponent 00000000 8 ビット
仮数部 Mantissa (Fraction) 00000000000000000000000 23 ビット
符号ビット (1 bit)
指数部 (8 bits)
仮数部 (23 bits)

第1部:符号ビット(1 bit)

最も単純な部分です。

0正の数を表し、1負の数を表します。

第2部:指数部(8ビット)

指数は小数点の位置を決めます(これが「浮動小数点」という名前の由来です——小数点が「浮動」します)。

ただし指数は直接保存されるのではなく、「実際の指数 + 127」を保存します。

この127をオフセット(Bias)。

なぜオフセットを加えるのでしょうか?

8ビットでは0〜255(符号なし)しか表せませんが、実際の指数は負の数(1より小さい数を表す)である必要があるからです。

オフセット127を加えると:

  • 保存値127は実際の指数0に対応します(127 - 127 = 0)
  • 保存値0は実際の指数-127に対応します
  • 保存値255は実際の指数+128に対応します

第3部:仮数部(23ビット)

仮数が保存するのは「1.xxxxx」の「xxxxx」の部分で、先頭の1は省略されています。

2進数の科学的記数法では、正規化された形式は常に1.xxxになるため、先頭の1を保存する必要はありません。

これにより、巧妙に1ビット分の精度を多く節約しています。

3つの部分構造を理解する鍵:浮動小数点数 = (-1)^符号× 1.仮数 × 2(指数-127)。これがIEEE 754のすべての要点です。


インタラクティブデモ:32ビット浮動小数点数の分解ツール

浮動小数点数を入力して、IEEE 754 単精度形式での3つの部分構造を観察しましょう。

セグメントのバーが、3つの部分がそれぞれどのビットに対応するかをハイライト表示します。

IEEE 754 単精度分解ツール

浮動小数点数を入力:

0.1を入力して、仮数部分を観察してみましょう。

0.1の2進数の仮数は無限循環小数です——23ビットではまったく足りません。

これは有名なコンピュータの現象につながります。


なぜ 0.1 + 0.2 は 0.3 にならないのか

Python や JavaScript で次のコードを実行すると0.1 + 0.2 == 0.3、結果はFalse。

これはバグではなく、浮動小数点数の表現法による必然的な結果です。

理由はとても簡単です:0.1は2進数で正確に表すことができません。

10進数で1/3 = 0.33333... が無限循環小数であるのと同じです。

2進数では、0.1(10進数) = 0.000110011001100110011...(2進数)となり、これも無限循環小数です。

IEEE 754 はこの無限循環小数を保存するための仮数が23ビットしかありません。

23ビットを超える部分は切り捨て(丸め)られるしかなく、これによって丸め誤差が生じます。

float32 で0.1が実際に保存される値はおよそ0.100000001490116119384765625です。

float32 で0.2が実際に保存される値はおよそ0.20000000298023223876953125です。

両者を足して再び丸めると、結果は正確な0.3にはなりません。

金額計算では浮動小数点数を避けるべきです

金額に関わる場面では、整数(「分」単位)または専用の Decimal 型を使うべきです。

Python のDecimal、Java のBigDecimal、C# のdecimalはすべてこのために設計されています。

浮動小数点数で金額を保存すると、0.01の累積誤差が0.010000000000000002になっていることに気づいたときには、問題はすでに長い間潜んでいたことになります。


浮動小数点数の値の範囲と特殊な値

IEEE 754 は指数と仮数のためにいくつかの特別な組み合わせを予約しています:

種類符号ビット指数(格納値)仮数意味
零0 または 10(すべて0)すべて0+0 または -0
非正規化数0 または 10(すべて0)すべて0ではない0に非常に近い値
正規化数0 または 11 ~ 254任意通常の浮動小数点数
無限大0 または 1255(すべて1)すべて0+Infinity または -Infinity
NaN任意255(すべて1)すべて0ではない非数(例:0/0)

単精度 float(32ビット)のおおよその範囲:

  • 最大の正の値:約 3.4 x 1038
  • 最小の正の値(正規化):約 1.2 x 10-38
  • 最小の正の値(非正規化):約 1.4 x 10-45
  • 有効精度:約7桁の10進有効数字

倍精度 double(64ビット)は範囲がより広く、精度もより高い:

  • 11ビットの指数(オフセット1023)
  • 52ビットの仮数
  • 有効精度:約15〜16桁の10進有効数字

浮動小数点数の精度が失われる3つのケース

ケース1:10進数から2進数への変換誤差

先ほどの0.1の例のように。

10進数では「きれい」な小数でも、2進数では無限循環になる可能性があります。

分母が2のべき乗である分数(0.5、0.25、0.125など)だけが、2進数で正確に表せます。

ケース2:大きな数に小さな数を足す

浮動小数点数の精度は一様に分布していません——値が大きいほど、区別できる最小の差も大きくなります。

例えば 16777216.0 + 1.0 = 16777216.0(float32 では結果は変わりません)。

32ビット浮動小数点数は約7桁の有効数字しか正確に表現できないため、16777216自体がすでに8桁を占めています。

1を加えたことによる変化は、仮数部で表現できない精度範囲に落ち込み、そのまま「飲み込まれて」しまいます。

ケース3:近い数どうしの引き算

非常に近い2つの浮動小数点数を減算すると、次のような結果になります。有効数字の壊滅的な喪失。

例えば 1.2345678 - 1.2345677 = 0.0000001 ですが、実際の計算では 0.000000099999... のような誤差が大きい結果になることがあります。

浮動小数点数の精度制限を理解することは、それを使うことを「怖がる」ためではなく、適切な場面で適切なツールを選ぶためです。科学計算、グラフィックレンダリング、機械学習——浮動小数点数はこれらの分野で十分に役立ちます。しかし、金融、会計、正確なカウント——浮動小数点数は避けてください。


コードデモ:浮動小数点数の秘密

実例

# 浮動小数点数精度問題の完全デモ(サンプル デモ)
import struct

def float_to_ieee754_binary(num):
    """浮動小数点数を IEEE 754 単精度の3つの部分に変換する"""
    # struct を使用して浮動小数点数を4バイトにパック(ビッグエンディアン)
    packed = struct.pack('>f', num)
    # 32ビットの2進文字列に変換
    bits = ''.join(f'{b:08b}' for b in packed)

    sign = bits[0]
    exponent = bits[1:9]
    mantissa = bits[9:32]

    exp_stored = int(exponent, 2)
    exp_actual = exp_stored - 127

    # 仮数部の小数値を計算
    frac = 0
    for i, bit in enumerate(mantissa):
        if bit == '1':
            frac += 2 ** -(i + 1)

    value = (-1 if sign == '1' else 1) * (1 + frac) * (2 ** exp_actual)

    return {
        'bits': bits,
        'sign': sign,
        'exponent': exponent,
        'mantissa': mantissa,
        'exp_stored': exp_stored,
        'exp_actual': exp_actual,
        'fraction': frac,
        'reconstructed': value
    }

# =============================================
# デモ1: 0.5 と 0.1 の表現を比較
# =============================================
print("=" * 60)
print("デモ1: なぜ 0.5 は正確で 0.1 は不正確なのか")
print("=" * 60)

for num in [0.5, 0.1]:
    r = float_to_ieee754_binary(num)
    print(f"\n"浮動小数点数: {num}")
    print(f" 符号ビット: {r['sign']} ({'正' if r['sign'] == '0' else '負'})")
    print(f" 指数部: {r['exponent']} (格納={r['exp_stored']}, 実際={r['exp_actual']})")
    print(f" 仮数部: {r['mantissa']}")
    print(f" 実際の格納値: {r['reconstructed']}")

# =============================================
# デモ2: おなじみの 0.1 + 0.2 != 0.3
# =============================================
print("\n" + "=" * 60)
print("デモ2: 0.1 + 0.2 != 0.3")
print("=" * 60)

# より高い精度で表示
import decimal
ctx = decimal.getcontext()
ctx.prec = 50

a = decimal.Decimal(0.1)
b = decimal.Decimal(0.2)
c = decimal.Decimal(0.3)

print(f"0.1 の実際の値: {a}")
print(f"0.2 の実際の値: {b}")
print(f"0.3 の実際の値: {c}")
print(f"0.1 + 0.2  = {a + b}")
print(f"0.1 + 0.2 == 0.3 ? {0.1 + 0.2 == 0.3}")

# =============================================
# デモ3: 大きな数が小さな数を「飲み込む」
# =============================================
print("\n" + "=" * 60)
print("デモ3: 大きな数に小さな数を加えると飲み込まれる")
print("=" * 60)

big = 16777216.0
small = 1.0
result = big + small
print(f"{big} + {small} = {result}")
print(f"結果は元の数と等しい? {result == big}")

# この数が float32 の精度限界に達していることを示す
print(f"\n"原因: {big} は float32 で仮数部に {len(format(struct.unpack('>f', struct.pack('>f', big)))
print(f"隣接する2つの float32 値の最小間隔は約 2^24 / 2^23 = 2.0 です")

# =============================================
# デモ4: 正しい金額処理
# =============================================
print("\n" + "=" * 60)
print("デモ4: サンプル 案例 - 金額の正しい処理")
print("=" * 60)

from decimal import Decimal

# 誤った方法:浮動小数点数を使う
float_total = 0.1 + 0.2
print(f"誤り(浮動小数点数): 0.1 + 0.2 = {float_total}")

# 正しい方法:Decimal を使う
decimal_total = Decimal('0.1') + Decimal('0.2')
print(f"正しい(Decimal): Decimal('0.1') + Decimal('0.2') = {decimal_total}")

# または整数を使う(単位は分)
cents_total = 10 + 20  # 0.1元 = 10分, 0.2元 = 20分
print(f"正しい(整数分): 10分 + 20分 = {cents_total}分 = {cents_total/100}元")

# =============================================
# デモ5: 浮動小数点数の特殊値
# =============================================
print("\n" + "=" * 60)
print("デモ5: 浮動小数点数の特殊値")
print("=" * 60)

import math

# 無限大
print(f"float('inf')    = {float('inf')}")
print(f"1.0 / 0.0       = {1.0 / 0.0}")
print(f"float('inf') > 1e1000000 = {float('inf') > 1e1000000}")

# NaN
print(f"float('nan')     = {float('nan')}")
print(f"0.0 / 0.0        = {0.0 / 0.0}")
print(f"float('nan') == float('nan') ? {float('nan') == float('nan')}")
print(f" (NaN はどんな値とも等しくありません。それ自身とも!)")

# NaN をチェック
print(f"math.isnan(float('nan')) = {math.isnan(float('nan'))}")

実践でのアドバイス:いつ何を使うべきか

シナリオ推奨型理由
科学計算、グラフィックレンダリングfloat または double精度が十分で、ハードウェアアクセラレーションのサポートが良い
金融金額計算Decimal / BigDecimal正確な演算、丸め誤差がない
カウンター、インデックスint / long正確な整数、精度問題なし
浮動小数点数を比較する許容差で比較する直接 == を使うべきではなく、abs(a-b) < epsilon を使うべき
通貨の保存/転送整数(単位は分)シリアライズ時の浮動小数点誤差を避ける
その他の拡張