お金の計算:最小単位の整数か10進型か、割り勘の1円

数値講座4。int(19.99*100) は1998、BigDecimal の 2.0 と 2.00 は不一致、bcmul は小数を落とし、個別に丸めた割り勘は32%で合計ずれ。Decimal の速度コストは2.7〜21倍。実行結果で確認。

シリーズ:数値・お金の計算講座 4/6(中級)。 丸めでつまずいた(第3回)あと、価格の保存、カートの合計、割り勘、クーポン値引きの按分、外貨換算を「1円合わない」問い合わせなしで実装したい人向けです。読み終えると、整数(最小単位)と10進型の使い分け、Python・Java・C#・PHP・Swift の10進型それぞれの落とし穴、そして1円も失わない按分関数が手に入ります。

お金のバグは派手ではありません。返金が1円足りない、決済代行のCSVと売上集計が合わない、どこかの層で金額がいつの間にか float になっていた。そういう地味な不具合を直す人のための回です。日本円は実務上「銭」を使わないので最小単位は1円、つまり円の金額はそのまま整数で表せます。一方で税抜単価や外貨、従量課金の単価には小数が出てきます。以下はすべて Apple Silicon Mac(M1 Pro)で Python 3.9.6(比較用に 3.12)、Java 26、.NET 10.0.14、PHP 8.5.6(bcmath、ICU 78.3 の intl)、Swift 6.4.2、SQLite 3.51.0、macOS の jsc で実行した結果です。

float がお金の入れ物に向かない理由

第1回で見たように 0.1 は2進数で正確に表せません。お金では、変換や切り捨ての瞬間にそれが「違う金額」になります。

# float_money.py
print("sum of ten 0.10 =", sum([0.10] * 10))
print("int(19.99 * 100) =", int(19.99 * 100))
print("round(19.99 * 100) =", round(19.99 * 100))
print("0.07 * 100 =", 0.07 * 100)
sum of ten 0.10 = 0.9999999999999999
int(19.99 * 100) = 1998
round(19.99 * 100) = 1999
0.07 * 100 = 7.000000000000001

int() は切り捨てで、19.99 * 100 は 1999 よりわずかに小さいので、19.99 ドルが 1998 セントになりました。JavaScript でも 19.99*100 = 1998.9999999999998、SQLite でも CAST(19.99*100 AS INTEGER) は 1998 でした。round() を使えばこの例は通りますが、それでは全員が全部の層でそれを覚えている前提になります。

SQLite には意外な点もありました。REAL で保存した 0.10 を10行 sum すると、3.51.0 ではぴったり 1.0 を返しました(Python の単純な sum は 0.9999999999999999)。最近の SQLite は浮動小数点の合計を丁寧に計算するようです。だからといって REAL がお金に安全になるわけではなく、誤差が別の場所に出るだけです。

選択肢1:最小単位の整数

いちばん単純で強い規則は、すべての金額を通貨の 最小単位 の個数として整数で持つことです。19.99 ドルは 1999、1,500円は 1500、4,500ウォンは 4500。足し算・引き算・比較が正確で速く、どの言語でもどのデータベースでも同じ結果になります。

通貨ごとの小数桁数を4つのライブラリに聞きました。

通貨 Java Currency .NET CultureInfo PHP NumberFormatter(ICU 78.3) jsc Intl
JPY 0 0(ja-JP) 0 0
KRW 0 0(ko-KR) 0 0
CLP 0 0(es-CL) 0 0
COP 2 0(es-CO) 0 2
USD / EUR / MXN 2 2 2 2
BHD 3 (未確認) (未確認) (未確認)

Java の Currency.getDefaultFractionDigits() は ISO 4217 に従います(COP 2、BHD 3)。.NET と PHP は 1234.5 コロンビアペソを小数なしの $ 1.235 と表示し、jsc は $ 1.234,50 でした。円の表示も揺れていて、1234.5 円を PHP は ¥1,234(全角の円記号、偶数丸め)、.NET と jsc は ¥1,235 と出しました。最小単位の桁数はロケールの書式化関数から推測せず、通貨コードをキーにした自前の表を持って、入力と表示の両方で使います。

文字列の入力を一度も float に通さない小さな変換関数です。

# cents.py
from decimal import Decimal

MINOR = {"JPY": 0, "KRW": 0, "CLP": 0, "USD": 2, "EUR": 2, "MXN": 2}

def to_minor(text, currency):
    """'19.99' USD -> 1999; '1500' JPY -> 1500. Refuses more digits than the currency has."""
    d = Decimal(text)
    scaled = d.scaleb(MINOR[currency])
    if scaled != scaled.to_integral_value():
        raise ValueError(f"{text} has more decimals than {currency} allows")
    return int(scaled)

def show(minor, currency):
    return f"{Decimal(minor).scaleb(-MINOR[currency]):.{MINOR[currency]}f} {currency}"

print(to_minor("19.99", "USD"), to_minor("1500", "JPY"), to_minor("12.5", "EUR"))
print(show(1999 * 3, "USD"), show(4500 * 3, "KRW"))
try:
    to_minor("100.5", "JPY")
except ValueError as e:
    print("ValueError:", e)
1999 1500 1250
59.97 USD 13500 KRW
ValueError: 100.5 has more decimals than JPY allows

日本のフォームで気になる全角数字も試しました。Python の Decimal("123") は Decimal('123')、Decimal("19.99") は 19.99、Java の new BigDecimal("123") も 123 を返しました。一方 PHP の bcadd("123", "0") は ValueError: bcadd(): Argument #1 ($num1) is not well-formed でした。言語によって受け入れたり拒否したりするので、入力は最初に半角へ正規化します(第5回で詳しく扱います)。

整数にも上限があります(第2回)。符号付き64ビット整数は約 9.2 × 10^18 単位まで持てるので価格には十分ですが、JavaScript の Number が正確なのは 2^53 までです。金額を JSON でブラウザに送るなら、文字列にするか十分小さく保ちます。

選択肢2:10進型、それぞれの落とし穴

整数の円やセントでは、消費税率や 0.0123 円のような従量単価を持てません。その計算には10進の型が要ります。どの言語にもありますが、それぞれに罠があります。

Python の Decimal:float からではなく文字列から作る。

# decimal_traps.py
import decimal
from decimal import Decimal, ROUND_HALF_UP

print("Decimal(0.1)   =", Decimal(0.1))
print("Decimal('0.1') =", Decimal("0.1"))
print("Decimal(0.1) * 3 == Decimal('0.3'):", Decimal(0.1) * 3 == Decimal("0.3"))
ctx = decimal.getcontext()
print("prec =", ctx.prec, "| rounding =", ctx.rounding)
print("Decimal(1) / 3 * 3 =", Decimal(1) / 3 * 3)
print("quantize 2.665 ->", Decimal("2.665").quantize(Decimal("0.01")),
      "| HALF_UP ->", Decimal("2.665").quantize(Decimal("0.01"), ROUND_HALF_UP))
ctx.traps[decimal.FloatOperation] = True      # make float leaks loud
try:
    Decimal(19.99)
except decimal.FloatOperation as e:
    print("FloatOperation trapped:", type(e).__name__)
Decimal(0.1)   = 0.1000000000000000055511151231257827021181583404541015625
Decimal('0.1') = 0.1
Decimal(0.1) * 3 == Decimal('0.3'): False
prec = 28 | rounding = ROUND_HALF_EVEN
Decimal(1) / 3 * 3 = 0.9999999999999999999999999999
quantize 2.665 -> 2.66 | HALF_UP -> 2.67
FloatOperation trapped: FloatOperation

学べることは3つです。Decimal(0.1) は float の誤差を忠実にコピーする。既定のコンテキストは有効桁28桁の偶数丸めなので、丸め方を指定しない quantize は 2.67 ではなく 2.66 を返す。割り算は相変わらず割り切れない。FloatOperation のトラップを有効にすると、float が Decimal に紛れ込んだ瞬間に例外になります。

Java の BigDecimal:equals は数値の等しさではない。

equals: false  compareTo: 0
HashSet size: 2  TreeSet size: 1
stripTrailingZeros equals: true
new BigDecimal(0.1) = 0.1000000000000000055511151231257827021181583404541015625
BigDecimal.valueOf(0.1) = 0.1
10 / 3 (scale 2, HALF_EVEN) = 3.33

new BigDecimal("2.0").equals(new BigDecimal("2.00")) はスケールも比べるので false です。両方を入れた HashSet は要素2つ、compareTo を使う TreeSet は1つでした。new BigDecimal(0.1) は float の誤差をコピーし、BigDecimal.valueOf(0.1) は最短の文字列を経由するので 0.1 です。スケールなしの割り算は例外で、new BigDecimal("10").divide(new BigDecimal("3")) は java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.、1.005 に丸めモードなしで setScale(2) すると Rounding necessary が出ました。

C# の decimal:いちばん素直だが上限はある。

0.1 + 0.2 == 0.3 (double): False
0.1m + 0.2m == 0.3m: True
1m / 3m * 3m = 0.9999999999999999999999999999
2.0m == 2.00m: True, ToString: 2.0 vs 2.00, Equals: True
decimal.MaxValue = 79228162514264337593543950335
OverflowException: Value was either too large or too small for a Decimal.

decimal は値で比較しつつ表示用にスケールを保ちます。あふれると checked の外でも必ず例外です(long は checked がなければ -9223372036854775808 に回り込みました)。

PHP の bcmath:文字列で受けて文字列で返し、既定のスケールは0。

bcmul('19.99','3') = 59   <- default scale 0
bcmul('19.99','3',2) = 59.97
bcdiv('2','3',2) = 0.66  <- truncates
bcadd('1e3','1') = ValueError: bcadd(): Argument #1 ($num1) is not well-formed
BcMath\Number('19.99') * 3 = 59.97

スケール引数を忘れると小数がそのまま消えます。bcmul('19.99', '3') は 59 でした。bcdiv は丸めではなく切り捨てで、指数表記は拒否されます。PHP 8.4 で追加された BcMath\Number クラスはスケールを保ち演算子も使えて、8.5.6 では 59.97 を返しました。

Swift の Decimal:小数リテラルは一度 Double を通る。

Decimal(0.1) = 0.1
Decimal(19.99) = 19.98999999999999488
Decimal(string:"19.99")! * 3 = 59.97

Decimal(0.1) は 0.1 と表示されるので罠に気づきにくいのですが、Decimal(19.99) は 19.98999999999999488、第3回の Decimal(1.005) は 1.0049999999999997952 でした。Decimal(string:) を使います。

割り勘とクーポン按分で1円も失わない

10,000円を3人で割ると、同じ額にはなりません。それぞれを個別に丸めると1円が消えたり湧いたりします。最大剰余法 で直します。

# alloc.py
import random

def allocate(total, weights):
    """Split integer `total` (minor units) in proportion to `weights`.
    Largest remainder method: the parts always add up to `total`."""
    wsum = sum(weights)
    parts = [total * w // wsum for w in weights]          # floor of each share
    left = total - sum(parts)                             # units still to hand out
    by_rem = sorted(range(len(weights)), key=lambda i: (-(total * weights[i] % wsum), i))
    for i in by_rem[:left]:
        parts[i] += 1
    return parts

def naive(total, weights):
    """Round each share half-up on its own (the usual first attempt)."""
    wsum = sum(weights)
    return [(2 * total * w + wsum) // (2 * wsum) for w in weights]

for total, w, label in [(10000, [1, 1, 1], "$100.00 in 3"),
                        (100000, [1, 1, 1], "100,000 won in 3"),
                        (1000, [480, 980, 1980], "1,000 yen discount over 480/980/1980"),
                        (500, [1, 1, 1, 1, 1, 1], "5.00 EUR over 6 lines"),
                        (7, [1, 1, 1], "7 cents in 3")]:
    n = naive(total, w)
    print(f"{label}: naive {n} sum {sum(n)} | allocate {allocate(total, w)} sum {sum(allocate(total, w))}")

rng = random.Random(42)
T, bad, worst = 100_000, 0, 0
for _ in range(T):
    w = [rng.randrange(1, 10_000) for _ in range(rng.randrange(2, 8))]
    total = rng.randrange(100, 1_000_000)
    d = sum(naive(total, w)) - total
    if d:
        bad += 1; worst = max(worst, abs(d))
    assert sum(allocate(total, w)) == total
print(f"random splits: {T}, naive total wrong in {bad} ({bad / T:.1%}), worst {worst} units; allocate exact in all")
$100.00 in 3: naive [3333, 3333, 3333] sum 9999 | allocate [3334, 3333, 3333] sum 10000
100,000 won in 3: naive [33333, 33333, 33333] sum 99999 | allocate [33334, 33333, 33333] sum 100000
1,000 yen discount over 480/980/1980: naive [140, 285, 576] sum 1001 | allocate [139, 285, 576] sum 1000
5.00 EUR over 6 lines: naive [83, 83, 83, 83, 83, 83] sum 498 | allocate [84, 84, 83, 83, 83, 83] sum 500
7 cents in 3: naive [2, 2, 2] sum 6 | allocate [3, 2, 2] sum 7
random splits: 100000, naive total wrong in 31958 (32.0%), worst 3 units; allocate exact in all
流れ図。合計 10000 セント、重み 1・1・1。各取り分を切り捨てると 3333・3333・3333 で合計 9999。残り1セント。余りの大きい順(同じなら先頭から)に渡す:3334・3333・3333、合計 10000。各自を個別に丸めると 3333 が3つで1セント消える。
100.00 を3人に分ける最大剰余法(セント単位)。全員の取り分を切り捨て、残りを数え、余りの大きい順に1ずつ配る。合計は必ず元の金額に戻る。

3行目が日本のECでよくある「1,000円引きクーポンを商品ごとに按分する」場面です。480円・980円・1,980円の3商品に比例配分して個別に四捨五入すると、合計1,001円の値引きになりました。約束より1円多い値引きです。返品で1商品だけ戻すとき、按分額が合計と合っていないと返金額が決まりません。ランダムな10万件(シード42)では32.0%で合計がずれました。按分関数は毎回正確で、同点は先頭の行に配るので、同じ入力からは必ず同じ結果が出ます。

割り勘アプリなら、10,000円を3人で allocate(10000, [1, 1, 1]) とすれば 3,334・3,333・3,333 円です。誰が1円多く払うかは「先頭の人(幹事)」のように規則として画面に出しておくと揉めません。

外貨換算:レートは1つ、丸めは1回

為替レートは10進の文字列で持ち、10進型で換算して、換算先の通貨の最小単位に1回だけ丸めます。以下のレートは架空です。

# fx2.py
from decimal import Decimal as D, ROUND_HALF_UP

def q(x, unit="1"):
    return x.quantize(D(unit), ROUND_HALF_UP)

RATE = D("151.37")                      # invented USD -> JPY rate, kept as a decimal string
yen = q(D("19.99") * RATE)
print("19.99 USD ->", D("19.99") * RATE, "->", yen, "JPY; back ->", q(yen / RATE, "0.01"), "USD")
print("float 19.99 * 151.37 =", 19.99 * 151.37)

once  = q(D("19.99") * RATE * D("1.10"))             # convert + 10% tax, round once
twice = q(q(D("19.99") * RATE) * D("1.10"))          # round after converting, then again
print("with 10% tax: round once", once, "| round twice", twice)

items = [D("0.99")] * 100
print("100 x 0.99 USD: convert each line", sum(q(p * RATE) for p in items),
      "| convert the total", q(sum(items) * RATE))
19.99 USD -> 3025.8863 -> 3026 JPY; back -> 19.99 USD
float 19.99 * 151.37 = 3025.8862999999997
with 10% tax: round once 3328 | round twice 3329
100 x 0.99 USD: convert each line 15000 | convert the total 14986

2回丸めると1円動きました。0.99 ドルの明細100行を1行ずつ換算すると 14,986円ではなく 15,000円で、1行ごとに 149.8563 が 150 に切り上がったからです。海外のアプリ内課金やサブスクの売上を円で集計するときは、行ごとに換算するか合計で換算するかを決め、使ったレートと丸め規則を取引と一緒に記録して、後から同じ数字を再現できるようにします。

実測:10進型はどれだけ遅いか

10進型を避ける理由としてよく挙がるのは速度です。同じ処理を3言語で測りました。ランダムな金額100万件(シード42)に10%の税を足してセント単位で四捨五入し、合計します。Python は5回、Java と .NET は7回の中央値、Apple Silicon Mac(M1 Pro)。

# bench.py(Python 部分)
import random, statistics, time
from decimal import Decimal as D, ROUND_HALF_UP
N, REPS = 1_000_000, 5
rng = random.Random(42)
cents = [rng.randrange(1, 100_000) for _ in range(N)]     # 0.01 .. 999.99
floats = [c / 100 for c in cents]
decs = [D(c).scaleb(-2) for c in cents]
CENT, RATE = D("0.01"), D("1.10")

def with_int():   return sum((c * 110 + 50) // 100 for c in cents)
def with_float(): return sum(round(x * 1.10, 2) for x in floats)
def with_dec():   return sum((d * RATE).quantize(CENT, ROUND_HALF_UP) for d in decs)
言語 最小単位の整数 2進 float 10進型
Python 3.9 64.3 ms 231.7 ms 173.7 ms(Decimal)
Python 3.12 54.7 ms 240.7 ms 160.3 ms(Decimal)
Java 26 1.4 ms(long) 1.6 ms(double) 22.5 ms(BigDecimal)
.NET 10 0.9 ms(long) 1.0 ms(double) 19.3 ms(decimal)
棒グラフ。同じ言語の整数と比べて何倍遅いか:Python float 3.6、Python Decimal 2.7、Java double 1.1、Java BigDecimal 16.1、.NET double 1.1、.NET decimal 21.4。
最小単位の整数を 1.0× としたときのコスト。100 万件の金額に 10% の税を足してセント単位で四捨五入し合計(Python 3.9 は5回、Java 26 と .NET 10 は7回の中央値、Apple Silicon Mac M1 Pro)。同じ言語の整数版が 1.0×。

Python では C で実装された Decimal の方が float と round() の組み合わせより速く、整数が最速でした。Java と .NET では10進型が整数の16倍と21倍かかりましたが、それでも100万行の税計算が約20ミリ秒です。Web リクエスト1回なら誤差の範囲で、効いてくるのは数億行のバッチです。保存は整数、10進型は必要な計算だけ、という方針の理由がもう1つ増えました。

float 版は遅いだけでなく間違っていました。正確な合計より Python で 124.95(12,495行が0.01低い、第3回参照)、Java で 6.83、.NET で 7.31 少なかったのです。

表し方の選び方

判断図。起点:誰かが払う・受け取る金額。見積もりや統計だけなら float でよい。そうでなく、すべての値が通貨の最小単位に収まるなら整数で持つ(USD・EUR・MXN はセント、JPY・KRW・CLP は円・ウォン・ペソそのもの)。税率、細かい単価、通貨換算が要るなら10進型(Python Decimal、Java BigDecimal、C# decimal、PHP bcmath、文字列から作った Swift Decimal)で計算し、最後に1回だけ丸めて最小単位の整数に戻す。
お金の表し方の選び方。基本は最小単位の整数、税率や単価が通貨の桁より細かいときは10進の型、2進の浮動小数点は請求に関わらない所だけ。
必要なこと 使うもの 注意点
金額の保存・合計・比較 最小単位の整数(BIGINT 列) 桁数は通貨表で。JS の Number は 2^53 まで
税率、小数のある単価 文字列から作った10進型 Decimal(float)、スケール、既定の丸め
割り勘・按分・返金 整数で最大剰余法 同点の配り先を決めておく
外貨換算 10進文字列のレート、丸めは1回 レートと規則を取引と一緒に記録
グラフ・見積もり・統計 float でよい 結果を請求に戻さない

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

間違い 実行で起きたこと 直し方
int(price * 100) int(19.99 * 100) → 1998 文字列から変換:to_minor("19.99", "USD")
Decimal(0.1)、new BigDecimal(0.1)、Swift Decimal(19.99) 0.1000000000000000055511151231257827021181583404541015625、19.98999999999999488 文字列から作る。Python は FloatOperation を有効に
BigDecimal をマップのキーに 2.0 と 2.00 の HashSet が要素2つ compareTo、または保存前に setScale(2)
スケールなしの bcmul bcmul('19.99','3') → 59 必ずスケールを渡すか BcMath\Number
割り勘を個別に丸める 10,000円÷3 → 合計9,999円。ランダムでは32.0%がずれる 最大剰余法で按分
うっかり行ごとに換算 0.99ドル×100行 → 15,000円と14,986円 行ごとか合計かを決めて記録
全角数字をそのまま渡す Python・Java は受理、PHP bcmath は ValueError 入力の最初に半角へ正規化

正直な限界・バージョンのメモ

  • BcMath\Number は PHP 8.4 で追加され、確認したのは 8.5.6 だけです。通貨の桁数の表は PHP の ICU 78.3、.NET 10 に付属する ICU、Java 26 の通貨データを反映したもので、他のバージョンでは変わる可能性があります。
  • 計測は1台・1種類の処理・小さな N です。Java はソースから直接実行(java Bench.java)、.NET は dotnet run -c Release。JIT のウォームアップは繰り返しの中央値で吸収しました。Java と .NET の金額はそれぞれの Random(42) で作ったので、合計値は Python と異なります。
  • SQLite が 0.10 10行の合計でぴったり 1.0 を返したのは 3.51.0 で観察しただけです。
  • 為替レートと税率は架空または例示です。会計・税務・法律の助言ではありません。端数処理の規則は税理士と決めてください。

練習問題

1. 0.07 ドルの商品を int(0.07 * 100) でセントにしています。Python は 0.07 * 100 = 7.000000000000001 と出しました。この場合 int() は安全ですか。同じコードが失敗する入力を本文から1つ挙げてください。

2. 飲み会の会費 10,000円を7人で allocate(10000, [1] * 7) で割り勘します。1人いくらで、1円多く払うのは誰ですか。

解答

1. この例はたまたま通ります。7.000000000000001 を切り捨てると 7 です。19.99 では失敗します。int(19.99 * 100) は積が 1999 よりわずかに小さいため 1998 でした。ある価格で動いて別の価格で壊れることこそ、文字列から変換すべき理由です。

2. 10000 // 7 = 1,428円ずつで合計 9,996円、残り4円。余りは全員同じなので、同点の規則で先頭の4人に1円ずつ配ります。4人が 1,429円、3人が 1,428円、合計 10,000円です(実行結果 [1429, 1429, 1429, 1429, 1428, 1428, 1428])。

次へ

よくある質問

金額は整数で持つべきですか、Decimal で持つべきですか?

保存と足し算は通貨の最小単位の整数(円なら1円単位、ドルならセント)で行い、税率、細かい単価、為替換算のように桁が必要な計算だけ Python の Decimal、Java の BigDecimal、C# の decimal などの10進型を使い、最後に1回だけ丸めて整数に戻します。2進の float は使いません。Python で int(19.99 * 100) は 1998 でした。

BigDecimal で 2.0 と 2.00 が等しくならないのはなぜですか?

BigDecimal.equals は値とスケール(小数点以下の桁数)の両方を比べるからです。new BigDecimal("2.0").equals(new BigDecimal("2.00")) は false、compareTo は 0 でした。HashSet には2つ残り、TreeSet には1つでした。金額の比較は compareTo を使い、マップのキーにするなら setScale でスケールをそろえます。

割り勘で1円も合わなくならない分け方は?

最大剰余法を最小単位の整数で使います。全員の取り分を切り捨て、残った単位数を数え、余りの大きい人から1ずつ配ります。10,000円を3人なら 3,334・3,333・3,333 円です。それぞれを個別に丸める方法は、ランダムな10万件で32.0%が合計と合いませんでした。

  • #数値計算
  • #中級
  • #お金の計算
  • #Decimal
  • #BigDecimal
  • #割り勘
  • #Python
  • #Java
  • #C#
  • #PHP

t.laboratory

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

運営者情報 · アプリ

↑