2進数と浮動小数点 — 0.1+0.2が0.3にならない

2進数と浮動小数点。0と1のブロック、電卓と小数点のカード、虫眼鏡。

0.1 + 0.2 が 0.3 になりません。2進数で小数をどう表しているのかを見て、金額を扱うときの選び方を決めます。

前回: CPUの仕組みを自作する — 足し算しかしていない

これは【深掘り】の記事です。本線の順路ではありません。 「1」と 1 は等しい — JavaScriptの基本と最初の落とし穴 で「数値は数値」として片づけた部分を、正面から扱います。 飛ばしても本線は進めます。 ただし、金額を扱うコードを書く日までには読んでおいたほうがいい内容です。

この記事のコマンドは、VMの中(Ubuntu Server)で打ちます。 Windows の PowerShell ではありません。VM の立て方は VMを29台溜めた話 — Ubuntu Serverの立て方 にあります。


最初に、実際に出した不具合の話をします。

小さな注文フォームを作っていました。商品の単価に割引を掛け、個数を掛けて、合計金額を出すだけの処理です。

割引後の単価は 4.35円 でした。個数は 100個。手で計算すれば 435円 です。

書いたコードは、こうでした。

const tanka = 4.35;
const kosuu = 100;
const goukei = Math.floor(tanka * kosuu);
console.log(goukei);

画面に出た数字は、434 でした。

1円足りません。

最初に疑ったのは Math.floor です。「切り捨てだから1円減ったのだろう」と思いました。違いました。 掛け算の結果がちょうど 435 なら、切り捨てても 435 のままです。

そこで、Math.floor を外して、掛けた結果だけを出しました。

console.log(4.35 * 100);

出てきたのは、これです。

434.99999999999994

435 ではありませんでした。

このとき私は、こう思いました。

JavaScript の掛け算が壊れている。

そう思ってしまうのが自然です。そして、その思い込みのまま、私は間違った直し方をしました。

const goukei = Math.floor(Number((tanka * kosuu).toFixed(2)));

これで 435 が出ました。動いたので、正しいと思いました。

けれど、この直し方は別の場所で同じ症状を出します。 実際、そのあと消費税の内訳で、また1円ずれました。toFixed を足す場所を1つずつ増やしていって、どこに足せば直るのか分からなくなりました。


それが無いと何が困るのか。

ここで足りていなかったのは、テクニックではありません。

コンピュータが数をどう持っているかを知らなかった。

これだけです。4.35 という数を、コンピュータは 4.35 として持っていません。 持てないのです。持てない理由が分かっていれば、toFixed を貼る場所を探す作業は最初から発生しません。

そして、この「数の持ち方」を知らないままだと、次のような場面で毎回止まります。

場面数の持ち方を知らないと起きること
金額の計算1円ずれる。しかも特定の数字でしか再現しないので、テストをすり抜ける
chmod 755 を読む755 が何なのか分からず、毎回検索する。権限の回 で 7 = rwx と覚えても、なぜそうなるかは分からない
/24 を読むサブネットマスクがビットの本数だと気づかない
バイナリファイルを読むバイトの順番が逆に見えて、値が化ける
件数が増えたら遅いどのくらい遅くなるのかを見積もれない。ここは次の回の計算量の話
DBの型を選ぶ金額に FLOAT を選んでしまう。FLOATで金額を持つと1円ずれる — SQL深掘り はこの記事の続きの症状

この記事は、「0.1 + 0.2 が 0.30000000000000004 になる」を最後まで説明しきることを目標にします。「浮動小数点だから誤差が出る」で止めません。64ビットのビット列を実際に取り出して、どのビットがどう食い違っているかまで見ます。


対象レベル: 中級〜上級 / 区分: 発展

目次

この記事でわかること

  • 16進数を使う理由は「4ビットちょうどで1桁」だからであること。10進が2進と噛み合わないのに対し、16進は2進を4桁ずつ区切って読み替えただけであること
  • JavaScript のビット演算は、値を32ビットに切り落としてから計算すること。だから 2 ** 31 | 0 が負の数になること。| 0 を「小数を切り捨てるおまじない」として使うと、大きい数で黙って壊れること
  • 0.1 が2進数で表せないのは、10進で 1/3 が 0.333… になるのと同じ理由であること。「JavaScript が悪い」のではなく、2進の有限桁で書けない分数だからであること
  • IEEE 754 の倍精度は 符号1 / 指数11 / 仮数52 に分かれていること。そして 0.1 + 0.2 と 0.3 は、64ビットの末尾が少しだけ違う(隣どうしの表せる値で、最下位の1単位だけずれている)こと
  • 2 ** 53 を超えると、小数どころか整数も壊れること。だから金額は最小単位の整数か BigInt で持ち、toFixed は表示専用であること
  • 同じ4バイトが、書き方によってバイト順が逆になること。x86 はリトルエンディアン、ネットワーク上の並びはビッグエンディアンで、問題になるのは自分でバイナリを読み書きするときだけであること

この記事でやること

  1. 作業場所 ~/cslab/binary を作り、この記事の実験を全部そこに閉じ込める(最後に消します)
  2. 10進 ↔ 2進 ↔ 16進を toString と parseInt で往復させ、変換表を自分で出力する
  3. ビット演算7種類(& | ^ ~ << >> >>>)を全部打ち、それぞれの実用例と32ビットに丸められる罠を確かめる
  4. 0.1 + 0.2 !== 0.3 の中身を、DataView と Float64Array でビット列まで開いて見る
  5. 直し方を3つ試し、あわせて toFixed が計算を直していないことを実演する
  6. エンディアンを DataView と od で確かめ、最後に対数・指数・階乗の伸び方を表にして次の回への橋を架ける

先に知る言葉

基本的な言葉は用語集にもまとめてあります。

言葉意味
ビット0 か 1 のどちらかを入れられる、いちばん小さい入れ物。1ビットで2通り
バイトビット8個ぶん。1バイトで256通り(0〜255)を表せる
基数(きすう)何種類の数字で書くかという決めごと。10進なら10種類、2進なら2種類、16進なら16種類
16進数0〜9 と a〜f の16種類で書く書き方。1桁がちょうど4ビット
符号あり/符号なし同じビット列を「マイナスもある数」として読むか、「0以上の数」として読むかの違い。ビット列は同じで、読み方が違うだけ
浮動小数点数小数を「符号・指数・仮数」の3つに分けて持つ方式。小数点の位置が動くからこの名前
IEEE 754その持ち方を決めた国際規格。JavaScript の数値はこの規格の倍精度(64ビット)1種類だけ
仮数(かすう)/指数1.6 × 2⁻⁴ と書いたときの 1.6 が仮数、-4 が指数
丸め誤差表せない値を、いちばん近い表せる値に寄せたときに出るズレ
エンディアン2バイト以上の値を、どちらの端から並べるかという順番の決めごと

① 準備 — 作業場所と Node.js

まず、作業場所を1つ作ります。 この記事で作るファイルは全部ここに入れて、最後にフォルダごと消します。

bash
$ mkdir -p ~/cslab/binary
$ cd ~/cslab/binary
$ pwd
/home/ユーザー名/cslab/binary

この記事のコードは JavaScript で書き、Node.js で動かします。 ブラウザを開かなくても、VM の中で数の中身を全部見られるからです。

入っているか確かめます。

bash
$ command -v node
$ node --version

何も出なかったら、入っていません。 which と違って command -v は組み込みなので、素の Ubuntu でも必ず使えます。

入っていない場合は入れます。

bash
$ sudo apt update
$ sudo apt install -y nodejs
$ node --version
v18.19.1

バージョンは v18 でも v20 でも構いません。 この記事で使う BigInt と DataView は、どちらにも入っています。Node.js を初めて入れる場合の背景は APIの正体はJSONを返すHTTP — Node.jsで作る にあります。

この記事では、対話モード(REPL)と、ファイルに書いて実行する方法の両方を使います。 短い確認は対話モードのほうが速いので、まず開いてみます。

bash
$ node
Welcome to Node.js v18.19.1.
Type ".help" for more information.
>

> が出たら、そこに JavaScript を打てます。抜けるときは .exit か Ctrl+D です。ここは覚えておいてください。抜けられなくなると詰まります。

試しに1行打ちます。

1 + 1
2

これで環境の確認は終わりです。 一度抜けます。

.exit

② 2進数を読めるようにする

先に結論を書きます。 2進数を「読める」というのは、暗算できることではありません。

どの桁が何を表しているかを言えること。 これだけです。

10進数のしくみを、先に言葉にする

1234 という数を、私たちは自然に読んでいます。何をしているかというと、これです。

1234 = 1×1000 + 2×100 + 3×10 + 4×1
     = 1×10³  + 2×10²  + 3×10¹ + 4×10⁰

右から順に、10⁰・10¹・10²・10³ の重みが付いている。 これが10進数です。

2進数は、この 10 が 2 になっただけです。

1101 = 1×2³ + 1×2² + 0×2¹ + 1×2⁰
     = 8    + 4    + 0    + 1
     = 13

使える数字が 0 と 1 の2種類しかないので、桁がすぐ増えます。 そのかわり、各桁は「その重みを足すか、足さないか」の二択になります。ここが後で効いてきます。

実際に変換してみる

node を開きます。

bash
$ cd ~/cslab/binary
$ node

10進 → 2進は toString(2) です。

(13).toString(2)
'1101'

戻ってくるのは文字列です。 数値ではありません。ここは最初に必ず引っかかるところなので、確かめておきます。

typeof (13).toString(2)
'string'

逆向きは parseInt に基数を渡します。

parseInt('1101', 2)
13

parseInt の第2引数は、必ず書いてください。 省略すると、文字列の見た目から基数を推測されます。

parseInt('1101')
1101

基数を書かないと10進として読まれ、1101 になります。 これは黙って起きるので、気づきにくい事故です。

16進も同じやり方です。

(255).toString(16)
'ff'
parseInt('ff', 16)
255

ソースコードに直接16進を書くときは 0x を付けます。 これは parseInt を通さず、その場で数値になります。

0xff
255
0b1101
13

0b は2進、0x は16進、0o は8進のリテラルです。 chmod 755 の 755 は8進なので、0o755 と書けます。あとで使います。

16進数を使う理由は「4ビットちょうどで1桁」だから

ここが、この節でいちばん大事なところです。

16進数は、2進数を4桁ずつ区切って、名前を付け直しただけです。理由は単純で、2⁴ = 16 だからです。

node を抜けて、変換表を作ります。

bash
$ .exit

ファイルを作ります。

bash
$ cat > nibble.js <<'EOF'
  console.log('10進  2進    16進');
  for (let n = 0; n <= 15; n++) {
    const dec = String(n).padStart(2, ' ');
    const bin = n.toString(2).padStart(4, '0');
    const hex = n.toString(16);
    console.log(`  ${dec}  ${bin}  ${hex}`);
  }
  EOF
$ node nibble.js
10進  2進    16進
   0  0000  0
   1  0001  1
   2  0010  2
   3  0011  3
   4  0100  4
   5  0101  5
   6  0110  6
   7  0111  7
   8  1000  8
   9  1001  9
  10  1010  a
  11  1011  b
  12  1100  c
  13  1101  d
  14  1110  e
  15  1111  f

この16行が、16進数のすべてです。 そして、この表があると、どんなに長い2進数でも機械的に16進に直せます。

2進 : 1111 1111 1010 0101
       ↓    ↓    ↓    ↓
16進:  f    f    a    5     → ffa5

4桁ずつ切って、表を引くだけ。 繰り上がりも計算もありません。

これを10進でやろうとすると、こうなりません。10 は 2 のべき乗ではないので、桁がどこでも噛み合いません。

node -e "console.log((0xffa5).toString(10), (0xffa5).toString(2))"
65445 1111111110100101

65445 を見て、元の2進数を言えますか。 言えません。計算しないと分かりません。 ffa5 なら、表を4回引くだけで言えます。

だから、コンピュータの世界の数字は16進で書かれます。 色コードの #ff0000、メモリのアドレス、ハッシュ値、文字コード。全部これです。「16進はプロっぽいから使う」のではなく、2進を人間が読むための、いちばん手間の少ない書き方だからです。

もう1つ、覚えておくと得な対応があります。

単位ビット数16進の桁数表せる範囲(符号なし)
ニブル410〜15
バイト820〜255
ハーフワード1640〜65535
ワード3280〜4294967295
ダブルワード64160〜18446744073709551615

1バイト = 16進2桁。 これを覚えているだけで、バイナリを見たときに「いま何バイト見ているか」が数えられます。前回のブートセクタで 512 バイトを扱いましたが、あれを16進で書くと1024桁です。

スクリーンショットを撮ってください: 01_nibble_table.png node nibble.js の16行の表が全部写るように撮ります。この表が、この記事の残り全部の土台になります。


③ ビット演算を全部試す

ビット演算は7種類しかありません。 そして、それぞれに「これのために存在する」という使い道があります。名前だけ覚えても使えないので、用途と一緒に打っていきます。

ファイルを作ります。

bash
$ cat > bitops.js <<'EOF'
  const a = 12;   // 1100
  const b = 10;   // 1010
  
  const show = (label, value) =>
    console.log(
      label.padEnd(12, ' '),
      String(value).padStart(12, ' '),
      '  2進:',
      (value >>> 0).toString(2).padStart(8, '0')
    );
  
  console.log('a = 12 (1100),  b = 10 (1010)');
  console.log('');
  show('a & b',  a & b);
  show('a | b',  a | b);
  show('a ^ b',  a ^ b);
  show('~a',     ~a);
  show('a << 1', a << 1);
  show('a >> 1', a >> 1);
  show('a >>> 1', a >>> 1);
  EOF
$ node bitops.js
a = 12 (1100),  b = 10 (1010)

a & b                   8   2進: 00001000
a | b                  14   2進: 00001110
a ^ b                   6   2進: 00000110
~a                    -13   2進: 11111111111111111111111111110011
a << 1                 24   2進: 00011000
a >> 1                  6   2進: 00000110
a >>> 1                 6   2進: 00000110

7つ全部出ました。 ここから1つずつ、何をしているかと、何に使うかを見ます。

&(AND)— 立っているか調べる

両方のビットが 1 のときだけ 1。

  1100  (12)
& 1010  (10)
------
  1000  (8)

用途は「フラグが立っているか調べる」です。

権限や状態を、1つの数値の中にビットごとに詰めておく書き方があります。作ってみます。

bash
$ cat > flags.js <<'EOF'
  const READ    = 1 << 0;   // 0001
  const WRITE   = 1 << 1;   // 0010
  const EXECUTE = 1 << 2;   // 0100
  const DELETE  = 1 << 3;   // 1000
  
  // 「読み」と「書き」だけ持っている人
  let perm = READ | WRITE;
  
  console.log('perm =', perm, '=', perm.toString(2).padStart(4, '0'));
  console.log('読める?  ', (perm & READ)    !== 0);
  console.log('書ける?  ', (perm & WRITE)   !== 0);
  console.log('実行できる?', (perm & EXECUTE) !== 0);
  console.log('消せる?  ', (perm & DELETE)  !== 0);
  EOF
$ node flags.js
perm = 3 = 0011
読める?   true
書ける?   true
実行できる? false
消せる?   false

& READ の結果は 1 か 0 です。true / false ではありません。 だから !== 0 を付けます。ここを忘れると、0 が偽として扱われるのでたまたま動いてしまい、あとで & DELETE(8)のときに混乱します。

|(OR)— 立てる

どちらかが 1 なら 1。 さっき READ | WRITE で使いました。権限を足すのが | です。

bash
$ node -e "
  const READ=1, WRITE=2, EXEC=4;
  let perm = READ;
  console.log('最初      :', perm.toString(2).padStart(3,'0'));
  perm = perm | WRITE;
  console.log('書きを足す:', perm.toString(2).padStart(3,'0'));
  perm |= EXEC;
  console.log('実行も足す:', perm.toString(2).padStart(3,'0'));
  "
最初      : 001
書きを足す: 011
実行も足す: 111

|= は「もう立っていても壊れない」のが良いところです。 同じ権限を2回足しても 011 のままです。

^(XOR)— 反転させる、消えたものを見つける

片方だけが 1 のときに 1。

  1100  (12)
^ 1010  (10)
------
  0110  (6)

用途1は「トグル(反転)」です。

bash
$ node -e "
  const DARK = 1 << 0;
  let ui = 0;
  console.log('1回目:', (ui ^= DARK));
  console.log('2回目:', (ui ^= DARK));
  console.log('3回目:', (ui ^= DARK));
  "
1回目: 1
2回目: 0
3回目: 1

同じ値で2回 XOR すると元に戻る。 これが XOR の性質です。

用途2は「変数の入れ替え(スワップ)」です。 一時変数を使わずに交換できます。

bash
$ cat > swap.js <<'EOF'
  let x = 12, y = 10;
  console.log('前:', x, y);
  x ^= y;
  y ^= x;
  x ^= y;
  console.log('後:', x, y);
  EOF
$ node swap.js
前: 12 10
後: 10 12

ただし、実務でこれを書く理由はほとんどありません。 現代の JavaScript なら分割代入で済みます。

[x, y] = [y, x];

XOR スワップは「XOR の性質を確かめるための実験」として意味があるだけです。読みにくいコードを増やす価値はありません。ここでは性質の確認のために打っています。

~(NOT)— 全ビット反転、そして「落とす」

0 と 1 を全部ひっくり返します。 さっき ~12 が -13 になりました。符号ビットまで反転するので、正の数を反転すると負になります。

用途は「フラグを落とす」です。 & と組み合わせます。

bash
$ node -e "
  const READ=1, WRITE=2, EXEC=4;
  let perm = READ | WRITE | EXEC;
  console.log('全部     :', perm.toString(2).padStart(3,'0'));
  perm = perm & ~WRITE;
  console.log('書きを落す:', perm.toString(2).padStart(3,'0'));
  "
全部     : 111
書きを落す: 101

~WRITE は「WRITE 以外のビットが全部 1 のマスク」です。 それと & を取ると、WRITE のビットだけが 0 になります。「落とす」は & ~x。 これは定型句として覚えてしまって構いません。

<< と >> — 2倍と半分

<< は左にずらす。1回で2倍です。

1100 (12) << 1  →  11000 (24)

>> は右にずらす。1回で半分(切り捨て)です。

1100 (12) >> 1  →  110 (6)
bash
$ node -e "
  let n = 12;
  for (let i = 0; i <= 4; i++) console.log('12 <<', i, '=', 12 << i);
  console.log('');
  for (let i = 0; i <= 4; i++) console.log('12 >>', i, '=', 12 >> i);
  "
12 << 0 = 12
12 << 1 = 24
12 << 2 = 48
12 << 3 = 96
12 << 4 = 192

12 >> 0 = 12
12 >> 1 = 6
12 >> 2 = 3
12 >> 3 = 1
12 >> 4 = 0

12 >> 3 が 1 になっているところを見てください。 1.5 ではありません。小数は出ません。切り捨てです。

もう1つの用途が「偶奇判定」です。 これは & ですが、桁の重みの話なので一緒に置きます。

bash
$ node -e "
  for (const n of [0,1,2,3,7,10,255,256]) {
    console.log(String(n).padStart(4), (n & 1) === 0 ? '偶数' : '奇数');
  }
  "
   0 偶数
   1 奇数
   2 偶数
   3 奇数
   7 奇数
  10 偶数
 255 奇数
 256 偶数

なぜ最下位ビットを見るだけで偶奇が分かるのか。 2進数の桁の重みは 1, 2, 4, 8, 16... です。最下位の 1 以外は全部偶数なので、合計が奇数になるかどうかは最下位ビットだけで決まります。 10進で「下1桁が 0/2/4/6/8 なら偶数」と言うのと同じ理屈です。

>>> — 符号を無視して詰める

>> は符号ビットを保ったまま右にずらします。 >>> は符号を考えず、空いた左側に 0 を入れます。

bash
$ node -e "
  console.log('-8 >> 1  =', -8 >> 1);
  console.log('-8 >>> 1 =', -8 >>> 1);
  console.log('');
  console.log('-1 >>> 0 =', -1 >>> 0);
  console.log('(-1).toString(2)      =', (-1).toString(2));
  console.log('(-1 >>> 0).toString(2)=', (-1 >>> 0).toString(2));
  "
-8 >> 1  = -4
-8 >>> 1 = 2147483644

-1 >>> 0 = 4294967295
(-1).toString(2)      = -1
(-1 >>> 0).toString(2)= 11111111111111111111111111111111

-1 を toString(2) すると -1 と出ます。 これは驚くところです。JavaScript は「マイナス記号付きの2進数」として文字にするので、ビット列が見えません。

>>> 0 を挟むと、同じビット列を符号なしの32ビットとして読み直せます。 だから 11111111...1 が見えました。

(x >>> 0).toString(2) は、ビット列を見るための定型句です。 さっきの bitops.js でこれを使っていたのは、このためです。

JavaScript のビット演算は32ビットに丸められる

ここが、この節でいちばん危ないところです。

JavaScript の数値は64ビットの浮動小数点です。なのに、ビット演算だけは「いったん32ビットの整数に変換してから」計算されます。 変換のときに、あふれた上位ビットは黙って捨てられます。

実際に踏みます。

bash
$ cat > trap32.js <<'EOF'
  const cases = [
    ['2 ** 30',              2 ** 30],
    ['2 ** 31',              2 ** 31],
    ['2 ** 32',              2 ** 32],
    ['2 ** 40',              2 ** 40],
    ['MAX_SAFE_INTEGER',     Number.MAX_SAFE_INTEGER],
  ];
  
  console.log('元の値'.padEnd(20), '値'.padStart(20), '| 0 したあと'.padStart(20));
  for (const [label, v] of cases) {
    console.log(label.padEnd(20), String(v).padStart(20), String(v | 0).padStart(20));
  }
  
  console.log('');
  console.log('1 << 31 =', 1 << 31);
  console.log('1 << 32 =', 1 << 32);
  console.log('1 << 33 =', 1 << 33);
  EOF
$ node trap32.js
元の値                                  値          | 0 したあと
2 ** 30                       1073741824           1073741824
2 ** 31                       2147483648          -2147483648
2 ** 32                       4294967296                    0
2 ** 40                    1099511627776                    0
MAX_SAFE_INTEGER            9007199254740991                   -1
1 << 31 = -2147483648
1 << 32 = 1
1 << 33 = 2

読み方を1つずつ。

  • 2 ** 31 | 0 が -2147483648。 32ビット符号あり整数の最上位ビットは符号なので、そこに 1 が立った瞬間に負になります
  • 2 ** 32 | 0 が 0。 33ビット目は32ビットに入らないので、まるごと消えます
  • MAX_SAFE_INTEGER | 0 が -1。 下位32ビットが全部 1 だったので、符号ありで読むと -1 です
  • 1 << 32 が 1。 ずらす数は 32で割った余りになります。「32回ずらせば 0 になる」ではありません

| 0 を「小数を切り捨てるおまじない」として使っているコードを見たら、桁を確認してください。

小数の切り捨て自体は、たしかに動きます。

bash
$ node -e "
  console.log(' 5.9 | 0 =',  5.9 | 0);
  console.log('-5.9 | 0 =', -5.9 | 0);
  console.log('Math.floor(-5.9) =', Math.floor(-5.9));
  console.log('');
  console.log('3000000000.7 | 0        =', 3000000000.7 | 0);
  console.log('Math.trunc(3000000000.7)=', Math.trunc(3000000000.7));
  "
 5.9 | 0 = 5
-5.9 | 0 = -5
Math.floor(-5.9) = -6
3000000000.7 | 0 = -1294967296
Math.trunc(3000000000.7) = 3000000000

2つ問題が出ています。

  1. -5.9 | 0 は -5、Math.floor(-5.9) は -6。 | 0 は0方向への切り捨てで、floor は下方向です。マイナスで結果が違います
  2. 30億を超えると、値が別の数になる。 -1294967296 です

切り捨てたいなら Math.trunc、床なら Math.floor を使ってください。 | 0 は速さのための書き方で、32ビットに収まると分かっている場所以外では使うべきではありません。


④ 浮動小数点

ここが本題です。 0.1 + 0.2 を出します。

bash
$ node -e "
  console.log(0.1 + 0.2);
  console.log(0.1 + 0.2 === 0.3);
  console.log(0.3);
  "
0.30000000000000004
false
0.3

0.3 を出すと 0.3 と出るのに、0.1 + 0.2 は 0.30000000000000004。

冒頭の掛け算も、同じ症状です。

bash
$ node -e "
  console.log(4.35 * 100);
  console.log(0.07 * 100);
  console.log(1.1 + 2.2);
  let s = 0;
  for (let i = 0; i < 10; i++) s += 0.1;
  console.log('0.1 を10回足す:', s, s === 1);
  "
434.99999999999994
7.000000000000001
3.3000000000000003
0.1 を10回足す: 0.9999999999999999 false

0.1 を10回足しても 1 になりません。 0.999...9 です。ここで Math.floor を掛ければ、0 になります。

0.07 * 100 は多いほうにずれ、4.35 * 100 は少ないほうにずれています。 ずれる方向も決まっていません。「だいたい合っているが、たまに合わない」 のが、この症状のいちばん厄介なところです。

なぜ 0.1 は表せないのか — 10進で 1/3 が書けないのと同じ

ここを、比喩でなく対応で説明します。

10進数で 1/3 を書いてください、と言われたらどうしますか。

1/3 = 0.3333333333...

終わりません。 桁をいくら増やしても、1/3 にはなりません。では 10進数が壊れているのでしょうか。 違います。

10進数で有限桁で書けるのは、分母が 10 の約数(2 と 5)のべき乗だけでできている分数です。 1/2 = 0.5、1/4 = 0.25、1/5 = 0.2、1/8 = 0.125 は書ける。 1/3 や 1/7 は、分母に 3 や 7 がいるので書けない。

2進数はまったく同じです。

2進数で有限桁で書けるのは、分母が 2 のべき乗だけでできている分数です。 1/2、1/4、1/8、1/16 は書ける。 1/10 は、分母 10 = 2 × 5 に「5」がいるので書けない。

0.1 は 1/10 です。だから、2進数では無限に続きます。

確かめます。手で筆算します。 0.1 を2進にするには、2倍して整数部を取る、を繰り返します。

0.1 × 2 = 0.2  → 0
0.2 × 2 = 0.4  → 0
0.4 × 2 = 0.8  → 0
0.8 × 2 = 1.6  → 1  (残り 0.6)
0.6 × 2 = 1.2  → 1  (残り 0.2)
0.2 × 2 = 0.4  → 0
0.4 × 2 = 0.8  → 0
0.8 × 2 = 1.6  → 1  (残り 0.6)
0.6 × 2 = 1.2  → 1  (残り 0.2)
   ...
0.1 = 0.0001100110011001100110011... (1001 が永遠に繰り返す)

0.2 が2回目に戻ってきた時点で、ループが確定しています。 終わりません。

そして、コンピュータの箱は有限です。 52ビットしか入りません。だからどこかで切って、いちばん近い値に寄せます。 その結果、箱の中に入っているのは 0.1 ではなく、「0.1 にいちばん近い、2進52桁で書ける数」です。

見てみます。

bash
$ node -e "
  console.log((0.1).toFixed(20));
  console.log((0.2).toFixed(20));
  console.log((0.3).toFixed(20));
  console.log((0.5).toFixed(20));
  console.log((0.25).toFixed(20));
  "
0.10000000000000000555
0.20000000000000001110
0.29999999999999998890
0.50000000000000000000
0.25000000000000000000

0.1 は、実際には 0.10000000000000000555... です。 0.2 は少し大きく、0.3 は少し小さい。

0.5 と 0.25 は、ぴったりです。 分母が2のべき乗だからです。だから、こうなります。

bash
$ node -e "
  console.log(0.5 + 0.25 === 0.75);
  console.log(0.125 + 0.375 === 0.5);
  console.log(0.1 + 0.2 === 0.3);
  "
true
true
false

浮動小数点は「不正確」ではありません。 表せる数については完全に正確です。 表せない数を渡されたときに、いちばん近い数に寄せるだけです。

64ビットの中身を、実際に取り出す

ここまでは「寄せている」という説明でした。次は現物を見ます。

IEEE 754 の倍精度(double)は、64ビットを3つに分けます。

部分ビット数位置意味
符号1先頭0 なら正、1 なら負
指数11次の11小数点をどこに置くか。1023 を引いた値が本当の指数
仮数52残り1.xxxxx の xxxxx の部分。先頭の 1. は保存されない

「先頭の 1. は保存されない」 ところが効いています。2進数で正規化すると、先頭は必ず 1 になります(0 なら桁をずらせばいい)。必ず 1 なら、記録する必要がありません。 これで1ビット得しています。

取り出すコードを書きます。DataView を使います。

bash
$ cat > ieee754.js <<'EOF'
  function inspect(x) {
    const view = new DataView(new ArrayBuffer(8));
    view.setFloat64(0, x);                 // 第3引数を省略 = ビッグエンディアン
    const hi = view.getUint32(0);
    const lo = view.getUint32(4);
  
    const bits =
      hi.toString(2).padStart(32, '0') + lo.toString(2).padStart(32, '0');
    const hex =
      hi.toString(16).padStart(8, '0') + lo.toString(16).padStart(8, '0');
  
    const sign = bits[0];
    const expBits = bits.slice(1, 12);
    const fracBits = bits.slice(12);
    const exp = parseInt(expBits, 2) - 1023;
  
    return { hex, sign, expBits, exp, fracBits };
  }
  
  for (const x of [0.1, 0.2, 0.3, 0.1 + 0.2]) {
    const r = inspect(x);
    console.log('値      :', x);
    console.log('16進    : 0x' + r.hex);
    console.log('符号    :', r.sign);
    console.log('指数    :', r.expBits, '=', parseInt(r.expBits, 2), '→ 2 の', r.exp, '乗');
    console.log('仮数    :', r.fracBits);
    console.log('');
  }
  EOF
$ node ieee754.js
値      : 0.1
16進    : 0x3fb999999999999a
符号    : 0
指数    : 01111111011 = 1019 → 2 の -4 乗
仮数    : 1001100110011001100110011001100110011001100110011010

値      : 0.2
16進    : 0x3fc999999999999a
符号    : 0
指数    : 01111111100 = 1020 → 2 の -3 乗
仮数    : 1001100110011001100110011001100110011001100110011010

値      : 0.3
16進    : 0x3fd3333333333333
符号    : 0
指数    : 01111111101 = 1021 → 2 の -2 乗
仮数    : 0011001100110011001100110011001100110011001100110011

値      : 0.30000000000000004
16進    : 0x3fd3333333333334
符号    : 0
指数    : 01111111101 = 1021 → 2 の -2 乗
仮数    : 0011001100110011001100110011001100110011001100110100

ここが、この記事の答えです。

最後の2つを並べます。

0.3                 : 0x3fd333333333 3333
0.1 + 0.2           : 0x3fd333333333 3334
                                        ^
                                  最後の1桁だけ違う

仮数の末尾を見ます。

0.3       の仮数の末尾: ... 0011 0011 0011
0.1 + 0.2 の仮数の末尾: ... 0011 0011 0100

64ビットのうち、違っているのは末尾の3ビットです。 値としては隣どうしの表せる数で、最下位の1単位(1 ulp)だけ違います。

なぜそうなったか。順を追います。

  1. 0.1 は仮数が 1001...1001 の繰り返しを切って、最後で切り上げた値。つまり本物の 0.1 より少し大きい
  2. 0.2 も同じ仮数で、指数が1つ大きいだけ。つまり本物の 0.2 より少し大きい
  3. その2つを足すと、ずれも足される。 結果は「本物の 0.3」より少し大きい
  4. 0.3 を直接書いたときは、切り上げではなく切り捨て(次の桁が 0 だったため)になり、本物の 0.3 より少し小さい
  5. 両者は、表せる値として隣どうしになった。 だから === が false

「誤差が積もった」というより、「丸める方向が違った」のが正確です。

同じことを Float64Array でもやってみます。 こちらのほうが短く書けますが、マシンのバイト順に依存します。 それが次の節の伏線です。

bash
$ cat > f64array.js <<'EOF'
  const f = new Float64Array(1);
  const u = new Uint32Array(f.buffer);   // 同じ8バイトを32ビット×2で見る
  
  f[0] = 0.1;
  console.log('u[0] =', u[0].toString(16).padStart(8, '0'));
  console.log('u[1] =', u[1].toString(16).padStart(8, '0'));
  EOF
$ node f64array.js
u[0] = 9999999a
u[1] = 3fb99999

u[1] に上位(3fb99999)が入っています。 u[0] ではありません。同じメモリを別の型で覗くと、バイトの並び順がそのまま見えるからです。ここを扱うのが ⑥ です。

2 ** 53 を超えると、整数も壊れる

「小数だけの話だろう」と思っていると、もう1つ踏みます。

仮数は52ビットです。先頭の暗黙の 1. を足して53ビットぶんの精度しかありません。それを超える整数は、1刻みで表せません。

bash
$ cat > safeint.js <<'EOF'
  console.log('MAX_SAFE_INTEGER =', Number.MAX_SAFE_INTEGER);
  console.log('2 ** 53          =', 2 ** 53);
  console.log('');
  console.log('2**53 === 2**53 + 1        :', 2 ** 53 === 2 ** 53 + 1);
  console.log('9007199254740992 + 1       :', 9007199254740992 + 1);
  console.log('9007199254740993           :', 9007199254740993);
  console.log('');
  console.log('isSafeInteger(2**53 - 1):', Number.isSafeInteger(2 ** 53 - 1));
  console.log('isSafeInteger(2**53)    :', Number.isSafeInteger(2 ** 53));
  console.log('');
  console.log('EPSILON =', Number.EPSILON, '= 2 の -52 乗:', 2 ** -52);
  EOF
$ node safeint.js
MAX_SAFE_INTEGER = 9007199254740991
2 ** 53          = 9007199254740992

2**53 === 2**53 + 1        : true
9007199254740992 + 1       : 9007199254740992
9007199254740993           : 9007199254740992

isSafeInteger(2**53 - 1): true
isSafeInteger(2**53)    : false

EPSILON = 2.220446049250313e-16 = 2 の -52 乗: 2.220446049250313e-16

9007199254740993 と書いたのに、9007199254740992 と出ています。

ソースコードに書いた整数が、読み込んだ瞬間に別の数になっている。

これは実際に事故になります。外部サービスのIDや、Twitter の投稿IDのような 64ビット整数を JSON で受け取って、JSON.parse した瞬間に末尾が変わるのがそれです。

bash
$ node -e "
  const json = '{\"id\": 9007199254740993}';
  console.log(JSON.parse(json).id);
  "
9007199254740992

IDが1つずれました。 これは「IDが違う人のデータを引く」不具合になります。大きなIDは、文字列で受け取るしかありません。

Number.EPSILON は 2 ** -52、つまり「1 の次に表せる数との差」です。1 のあたりでの刻み幅であって、どこでも同じ刻み幅ではありません。 ここは次の節で使います。

スクリーンショットを撮ってください: 02_ieee754_bits.png node ieee754.js の出力で、0x3fd3333333333333 と 0x3fd3333333333334 の2行が両方写るように撮ります。最後の1桁だけ違うことが見えるように。


⑤ 直し方

原因が分かったので、直し方は3つに絞れます。

直し方1(本命)— 金額は円単位の整数で持つ

いちばん確実なのはこれです。

小数を使わない。

金額を 4.35 円として持つのをやめて、銭単位の整数 435 として持ちます。 表示するときだけ100で割ります。

bash
$ cat > money.js <<'EOF'
  // ❌ 小数で持つ
  const ngTanka = 4.35;
  console.log('小数で持つ:', Math.floor(ngTanka * 100));
  
  // ✅ 銭単位の整数で持つ(4.35円 = 435銭)
  const okSen = 435;
  const kosuu = 100;
  const goukeiSen = okSen * kosuu;       // 43500 銭
  const goukeiYen = Math.floor(goukeiSen / 100);
  console.log('整数で持つ:', goukeiYen);
  
  // 表示だけ小数にする
  const hyouji = (sen) => (sen / 100).toFixed(2);
  console.log('単価の表示:', hyouji(okSen), '円');
  EOF
$ node money.js
小数で持つ: 434
整数で持つ: 435
単価の表示: 4.35 円

435 が出ました。 435 * 100 = 43500 は整数どうしの掛け算なので、丸める場所がありません。

この方針は、DBの型の選び方にも直結します。 金額の列に FLOAT を使うと同じ症状が出ます。詳しくは FLOATで金額を持つと1円ずれる — SQL深掘り にあります。同じ原因の、置き場所が違うだけの話です。

直し方2 — 桁があふれるなら BigInt

整数で持っても、桁が 2 ** 53 を超えたら壊れます。 消費税の計算で分母を大きくしたり、通貨をまとめて集計したりすると届きます。そのときは BigInt です。

bash
$ cat > bigint.js <<'EOF'
  // 末尾に n を付けると BigInt
  const a = 9007199254740993n;
  console.log('BigInt   :', a.toString());
  console.log('+1       :', (a + 1n).toString());
  
  // 桁が増えても壊れない
  let f = 1n;
  for (let i = 1n; i <= 25n; i++) f *= i;
  console.log('25! =', f.toString());
  
  // 金額の計算(銭単位)
  const tankaSen = 435n;
  const kosuu = 100000000n;
  console.log('合計(銭) :', (tankaSen * kosuu).toString());
  console.log('合計(円) :', (tankaSen * kosuu / 100n).toString());
  EOF
$ node bigint.js
BigInt   : 9007199254740993
+1       : 9007199254740994
25! = 15511210043330985984000000
合計(銭) : 43500000000
合計(円) : 435000000

9007199254740993 が、そのまま保持されています。

BigInt には2つの制約があります。実際に踏んでおきます。

bash
$ node -e "
  try {
    console.log(1n + 1);
  } catch (e) {
    console.log('エラー:', e.message);
  }
  console.log('7n / 2n =', (7n / 2n).toString());
  console.log('7 / 2   =', 7 / 2);
  console.log('1n == 1 :', 1n == 1);
  console.log('1n === 1:', 1n === 1);
  "
エラー: Cannot mix BigInt and other types, use explicit conversions
7n / 2n = 3
7 / 2   = 3.5
1n == 1 : true
1n === 1: false
  1. BigInt と普通の数値は、そのまま混ぜられません。 Number(x) か BigInt(x) で明示的に変換します
  2. 割り算は小数になりません。切り捨てです。 7n / 2n は 3n。金額の按分をやるなら、これを承知の上で使う必要があります

混ぜられないのは不便に見えますが、これは親切です。 黙って精度を落として動くほうが、はるかに危ないからです。

直し方3 — 小数の比較は === でやらない

どうしても小数のまま計算する場合(座標、割合、物理量など)は、比較の方法を変えます。

bash
$ cat > compare.js <<'EOF'
  const a = 0.1 + 0.2;
  const b = 0.3;
  
  console.log('=== で比較     :', a === b);
  
  // 差の絶対値が十分小さければ「等しい」とみなす
  const nearlyEqual = (x, y, tol = 1e-9) => Math.abs(x - y) < tol;
  console.log('差で比較(1e-9) :', nearlyEqual(a, b));
  console.log('実際の差       :', Math.abs(a - b));
  
  // 大きい値では 1e-9 では足りない
  const big1 = 1e16 + 1;
  const big2 = 1e16 + 2;
  console.log('');
  console.log('大きい値の差   :', Math.abs(big1 - big2));
  console.log('差で比較(1e-9) :', nearlyEqual(big1, big2));
  EOF
$ node compare.js
=== で比較     : false
差で比較(1e-9) : true
実際の差       : 5.551115123125783e-17

大きい値の差   : 2
差で比較(1e-9) : false

Math.abs(a - b) < 1e-9 で true になりました。 実際の差は 5.55e-17 なので、1e-9 は十分ゆるいしきい値です。

ただし、これは万能ではありません。 最後の2行を見てください。1e16 あたりでは、隣の表せる値との差が 2 もあります。 つまり 1e-9 というしきい値は、1 のあたりでしか意味を持ちません。

値のあたり隣の表せる値との差(おおよそ)
12.2e-16(= Number.EPSILON)
10001.1e-13
1e150.125
1e162

扱う値の大きさが決まっているなら固定のしきい値でいい。 決まっていないなら、値の大きさに比例させる必要があります。そして、金額なら直し方1に戻ってください。 比較のしきい値を悩むより、整数で持つほうが確実です。

toFixed は表示を整えるだけ。計算は直っていない

冒頭で私がやった間違った直し方の話です。

bash
$ cat > tofixed.js <<'EOF'
  console.log('(0.1 + 0.2).toFixed(2)   =', (0.1 + 0.2).toFixed(2));
  console.log('型                       =', typeof (0.1 + 0.2).toFixed(2));
  console.log('');
  // 見た目は 0.30 になったが、比較は直っていない
  console.log('toFixed してから比較      :', Number((0.1 + 0.2).toFixed(2)) === 0.3);
  console.log('');
  // そして toFixed 自身が、同じ問題で間違える
  console.log('(1.005).toFixed(2)       =', (1.005).toFixed(2));
  console.log('(1.005).toFixed(20)      =', (1.005).toFixed(20));
  console.log('(2.675).toFixed(2)       =', (2.675).toFixed(2));
  console.log('(2.675).toFixed(20)      =', (2.675).toFixed(20));
  EOF
$ node tofixed.js
(0.1 + 0.2).toFixed(2)   = 0.30
型                       = string

toFixed してから比較      : true

(1.005).toFixed(2)       = 1.00
(1.005).toFixed(20)      = 1.00499999999999989342
(2.675).toFixed(2)       = 2.67
(2.675).toFixed(20)      = 2.67499999999999982236

(1.005).toFixed(2) が 1.00 です。1.01 ではありません。

バグではありません。 toFixed(20) の行を見てください。箱の中にあるのは 1.00499999999999989... です。 これを小数第2位で丸めれば、正しく 1.00 です。

toFixed は、正しい値を間違って丸めているのではなく、 すでに少し小さい値を、正しく丸めている。

だから、toFixed を貼っても直りません。 直っているのは見た目だけで、元の値がずれているという事実は残っています。 私が「1か所に貼ったら別の場所で出た」のは、これが理由です。

さらに、toFixed は文字列を返します。 気づかず足すと、こうなります。

bash
$ node -e "
  const a = (0.1).toFixed(2);
  const b = (0.2).toFixed(2);
  console.log(a + b);
  console.log(Number(a) + Number(b));
  "
0.100.20
0.30000000000000004

'0.10' + '0.20' が '0.100.20' になりました。 文字列の連結です。この落とし穴は 「1」と 1 は等しい — JavaScriptの基本と最初の落とし穴 で扱ったものと同じ形です。

toFixed を使ってよい場所は1つだけです。

計算がすべて終わって、あとは人に見せるだけの直前。


⑥ エンディアン — 同じ4バイトが逆に見える

④ で Float64Array を覗いたとき、上位が u[1] に入っていました。 その理由がこれです。

1バイトに収まる値なら、順番の問題は起きません。 2バイト以上の値をメモリに置くとき、どちらの端から並べるかを決める必要があります。

呼び名並べ方使っている場所
ビッグエンディアン大きい桁から置く。人間が数字を書く順と同じネットワーク上のパケット、多くのファイル形式
リトルエンディアン小さい桁から置くx86 / x64 の CPU(つまり普通のPC)、ARM の既定

0x12345678 という4バイトの値を、両方で書いてみます。

bash
$ cat > endian.js <<'EOF'
  const view = new DataView(new ArrayBuffer(4));
  
  const dump = (label) => {
    const bytes = [];
    for (let i = 0; i < 4; i++) {
      bytes.push(view.getUint8(i).toString(16).padStart(2, '0'));
    }
    console.log(label, bytes.join(' '));
  };
  
  view.setUint32(0, 0x12345678, false);   // false = ビッグエンディアン
  dump('ビッグ  :');
  
  view.setUint32(0, 0x12345678, true);    // true  = リトルエンディアン
  dump('リトル  :');
  
  console.log('');
  // 書いた向きと読む向きが違うと、値が化ける
  view.setUint32(0, 0x12345678, true);
  console.log('リトルで書いてビッグで読む: 0x' + view.getUint32(0, false).toString(16));
  console.log('リトルで書いてリトルで読む: 0x' + view.getUint32(0, true).toString(16));
  EOF
$ node endian.js
ビッグ  : 12 34 56 78
リトル  : 78 56 34 12

リトルで書いてビッグで読む: 0x78563412
リトルで書いてリトルで読む: 0x12345678

同じ値なのに、バイト列が逆になりました。 そして、書いた向きと違う向きで読むと、まったく別の値になります。 0x12345678 が 0x78563412 です。

これを、シェルからも確かめます。 ファイルに書き出して、od で中身を1バイトずつ見ます。od は coreutils に入っているので、素の Ubuntu でも必ずあります。

bash
$ cat > writebin.js <<'EOF'
  const fs = require('fs');
  
  const big = Buffer.alloc(4);
  big.writeUInt32BE(0x12345678, 0);
  fs.writeFileSync('big.bin', big);
  
  const little = Buffer.alloc(4);
  little.writeUInt32LE(0x12345678, 0);
  fs.writeFileSync('little.bin', little);
  
  console.log('big.bin と little.bin を書きました');
  EOF
$ node writebin.js
$ ls -l big.bin little.bin
big.bin と little.bin を書きました
-rw-rw-r-- 1 user user 4 ... big.bin
-rw-rw-r-- 1 user user 4 ... little.bin

どちらも4バイトです。 中身を見ます。

bash
$ echo '--- big.bin ---'
$ od -An -tx1 big.bin
$ echo '--- little.bin ---'
$ od -An -tx1 little.bin
--- big.bin ---
 12 34 56 78
--- little.bin ---
 78 56 34 12

ディスクの上でも、本当に逆に並んでいます。 これは JavaScript の都合ではなく、バイトの並びそのものです。

自分のマシンはどちら向きか

判定するコードは短いです。 同じメモリを、2バイトの型と1バイトの型の両方で覗くだけです。

bash
$ cat > detect.js <<'EOF'
  const buf = new ArrayBuffer(2);
  new Uint16Array(buf)[0] = 0x0102;      // 「1」が上位、「2」が下位
  const first = new Uint8Array(buf)[0];  // 先頭の1バイトは何か
  
  console.log('先頭バイト: 0x' + first.toString(16).padStart(2, '0'));
  console.log(first === 0x02 ? 'リトルエンディアン' : 'ビッグエンディアン');
  EOF
$ node detect.js
先頭バイト: 0x02
リトルエンディアン

先頭に下位バイトの 02 が来ています。 リトルエンディアンです。

CPU 側からも確認できます。

bash
$ lscpu | grep -i byte
Byte Order:                         Little Endian

何も出なかったら、表示が日本語になっている可能性があります。 そのときは全体を見ます。

bash
$ lscpu | head -20

Byte Order または バイト順序 の行が答えです。

これが問題になるのは、自分でバイナリを読み書きするときだけ

ここを外すと、無駄に怖がることになります。

普通のプログラムを書いているあいだ、エンディアンは一度も出てきません。 1 + 1 を計算するとき、CPU が内部でどちら向きに並べていても、結果は 2 です。言語が面倒を見ています。

出てくるのは、この3つのときだけです。

場面なぜ出るか
バイナリのファイル形式を自分で読む仕様に「この4バイトはビッグエンディアン」と書いてある。従わないと化ける
生のソケットで数値を送るネットワーク上の並びはビッグエンディアン(「ネットワークバイトオーダー」)。x86 の並びとは逆
同じメモリを別の型で覗く④ の Float64Array と Uint32Array のように、型付き配列でメモリを共有したとき

逆に、次の場面ではまったく出てきません。

  • JSON をやりとりする(文字なので順番の問題が無い)
  • HTTP のヘッダやボディを読む(テキスト)
  • DBに数値を入れて取り出す(ドライバが処理する)

「ネットワークはビッグエンディアン」は正しいのですが、 HTTP や JSON を書いているあいだ、それを意識する場面は来ません。

逆に言うと、DataView を書いた瞬間からは必ず意識してください。 DataView の setUint32 / getUint32 は、第3引数を省略するとビッグエンディアンです。Float64Array などの型付き配列は、マシンのバイト順に従います。 既定が逆です。

APIエンディアンの既定
DataView の setXxx / getXxxビッグエンディアン(第3引数 true でリトルに)
Uint32Array / Float64Array などマシンに従う(普通のPCならリトル)
Node.js の Bufferメソッド名で明示(writeUInt32BE / writeUInt32LE)

外部と決めた形式を読み書きするなら、DataView か Buffer を使って、向きを毎回書いてください。 型付き配列は「自分のマシンの中だけ」で使うものです。

スクリーンショットを撮ってください: 03_endian_od.png od -An -tx1 big.bin と od -An -tx1 little.bin の2つの出力が並んで写るように撮ります。12 34 56 78 と 78 56 34 12 が同じ画面にあることが分かるように。


⑦ 実務でビットが出てくる場所

「ビット演算なんて業務で書かない」と思っていました。 書きません。けれど、読む場面は毎週あります。

chmod 755 は8進数で書いたビット列

Permission denied の正体 — rwxと755を読めるようにする で 7 = rwx と覚えました。なぜそうなるのかは、2進数の話です。

bash
$ node -e "
  const fmt = (n) => n.toString(2).padStart(3, '0');
  for (let n = 0; n <= 7; n++) {
    const b = fmt(n);
    const rwx = (b[0] === '1' ? 'r' : '-') + (b[1] === '1' ? 'w' : '-') + (b[2] === '1' ? 'x' : '-');
    console.log(n, b, rwx);
  }
  "
0 000 ---
1 001 --x
2 010 -w-
3 011 -wx
4 100 r--
5 101 r-x
6 110 rw-
7 111 rwx

r が 4、w が 2、x が 1。 つまり 1 << 2、1 << 1、1 << 0。さっき flags.js で自分の手で作ったものと、同じ形です。

そして 755 は8進数です。 8 = 2³ なので、1桁がちょうど3ビットです。所有者・グループ・その他がそれぞれ3ビット、合わせて9ビット。

bash
$ node -e "
  console.log('0o755 =', 0o755, '=', (0o755).toString(2).padStart(9, '0'));
  console.log('0o644 =', 0o644, '=', (0o644).toString(2).padStart(9, '0'));
  console.log('0o777 =', 0o777, '=', (0o777).toString(2).padStart(9, '0'));
  "
0o755 = 493 = 111101101
0o644 = 420 = 110100100
0o777 = 511 = 111111111

111 101 101 を3つに区切れば rwx r-x r-x。 これで 755 は暗記項目ではなくなります。16進が4ビットで1桁だったのと同じ理由で、権限は8進で書かれています。

/24 はビットの本数

/24 が読めないと直せない — Linux深掘り で扱った /24 も、ビットの本数です。

bash
$ cat > cidr.js <<'EOF'
  const mask = (bits) => {
    // 上位 bits 個だけ 1 のマスクを作る
    const m = bits === 0 ? 0 : (-1 << (32 - bits)) >>> 0;
    const octets = [24, 16, 8, 0].map((s) => (m >>> s) & 0xff);
    return {
      bin: m.toString(2).padStart(32, '0').match(/.{8}/g).join('.'),
      dotted: octets.join('.'),
      hosts: bits >= 31 ? 0 : 2 ** (32 - bits) - 2,
    };
  };
  
  console.log('CIDR  マスク            2進                                   ホスト数');
  for (const b of [8, 16, 24, 25, 26, 30]) {
    const r = mask(b);
    console.log(
      ('/' + b).padEnd(6),
      r.dotted.padEnd(18),
      r.bin,
      String(r.hosts).padStart(10)
    );
  }
  EOF
$ node cidr.js
CIDR  マスク            2進                                   ホスト数
/8    255.0.0.0          11111111.00000000.00000000.00000000   16777214
/16   255.255.0.0        11111111.11111111.00000000.00000000      65534
/24   255.255.255.0      11111111.11111111.11111111.00000000        254
/25   255.255.255.128    11111111.11111111.11111111.10000000        126
/26   255.255.255.192    11111111.11111111.11111111.11000000         62
/30   255.255.255.252    11111111.11111111.11111111.11111100          2

/24 は「上位24ビットが1」という意味です。 残り8ビットがホストに使えるので、2 ** 8 = 256。そこからネットワークアドレスとブロードキャストアドレスの2つを引いて 254 です。

-1 << (32 - bits) でマスクを作っているところを見てください。 -1 は全ビットが1です。それを左にずらせば、右側に0が入ります。これがマスクの作り方です。 そして >>> 0 で符号なしとして読み直しています。③ で覚えた定型句が、そのまま出てきました。

なぜ /25 が 128 なのかも、これで分かります。 10000000 です。半分に割ったのです。

フラグの集合

③ で作った flags.js のパターンは、現実のライブラリの中に大量にあります。

例中身
ファイルを開くときのオプション「読み」「書き」「追記」「新規作成」をビットで足して1つの数値にする
イベントの購読「押した」「離した」「動いた」をビットで持つ
権限管理権限が30種類あっても、1つの整数に収まる

なぜわざわざこうするのか。 理由は2つです。

  1. 速い。 30個の真偽値を配列で持って全部見るより、& 1回で終わる
  2. 小さい。 32個の状態が 4バイトに収まる。DBの1列、URLの1パラメータで済む

自分で新しくこの設計を採用する必要は、まずありません。 読めればいい。そして読めるためには、この記事の ③ だけで足ります。


⑧ 数の基礎 — 対数・指数・階乗の伸び方

最後に、次の回への橋を架けます。

対数は「何回半分にできるか」

log₂ n の意味を、公式ではなく動作で確かめます。

bash
$ cat > log2.js <<'EOF'
  const countHalving = (n) => {
    let count = 0;
    while (n > 1) {
      n = Math.floor(n / 2);
      count++;
    }
    return count;
  };
  
  console.log('件数        半分にできる回数   Math.log2');
  for (const n of [1, 2, 8, 64, 1000, 1000000, 1000000000]) {
    console.log(
      String(n).padStart(12),
      String(countHalving(n)).padStart(12),
      Math.log2(n).toFixed(2).padStart(14)
    );
  }
  EOF
$ node log2.js
件数        半分にできる回数   Math.log2
           1            0           0.00
           2            1           1.00
           8            3           3.00
          64            6           6.00
        1000            9           9.97
     1000000           19          19.93
  1000000000           29          29.90

100万件のデータを、半分に割り続けると20回で1件になる。 10億件でも30回。

これが、辞書を引くときに真ん中から開く理由です。 そして索引が「速い」の正体です。

大事なのは、件数が1000倍になっても、回数が10増えただけというところです。

指数と階乗

逆向きに伸びるものを並べます。

bash
$ cat > growth.js <<'EOF'
  const fact = (n) => {
    let f = 1n;
    for (let i = 1n; i <= BigInt(n); i++) f *= i;
    return f;
  };
  
  // 値そのものより「何桁になるか」を見る
  const digits = (v) => v.toString().length;
  
  console.log('n    log2(n)  n*log2(n)  n^2      2^n の桁数  n! の桁数');
  for (const n of [1, 2, 4, 8, 16, 20, 32, 64]) {
    console.log(
      String(n).padEnd(5),
      Math.log2(n).toFixed(1).padEnd(8),
      Math.round(n * Math.log2(n)).toString().padEnd(10),
      String(n * n).padEnd(8),
      String(digits(2n ** BigInt(n))).padEnd(11),
      String(digits(fact(n)))
    );
  }
  EOF
$ node growth.js
n    log2(n)  n*log2(n)  n^2      2^n の桁数  n! の桁数
1    0.0      0          1        1           1
2    1.0      2          4        1           1
4    2.0      8          16       2           2
8    3.0      24         64       3           5
16   4.0      64         256      5           14
20   4.3      86         400      7           19
32   5.0      160        1024     10          36
64   6.0      384        4096     20          90

値そのものではなく、桁数を出しました。 そうしないと画面に収まりません。「収まらない」ということ自体が、この節の内容です。

n = 64 の行を見てください。

伸び方n = 64 のとき
log₂ n6
n64
n log₂ n384
n²4096
2ⁿ約 1844京
n!90桁

log₂ n は 6 で、n! は 90桁。 同じ n = 64 です。

そして、階乗を BigInt で計算したことに注目してください。 普通の数値でやると、こうなります。

bash
$ node -e "
  const factNum = (n) => { let f = 1; for (let i = 1; i <= n; i++) f *= i; return f; };
  console.log('20! (Number):', factNum(20));
  console.log('21! (Number):', factNum(21));
  console.log('25! (Number):', factNum(25));
  console.log('');
  let f = 1n; for (let i = 1n; i <= 25n; i++) f *= i;
  console.log('25! (BigInt):', f.toString());
  "
20! (Number): 2432902008176640000
21! (Number): 51090942171709440000
25! (Number): 1.5511210043330986e+25
25! (BigInt): 15511210043330985984000000

21! はもう 2 ** 53 を超えていますが、この値はまだ正しいです。 2 の因数を多く含むので、倍精度でちょうど表せる数だからです。BigInt と食い違い始めるのは 23! からです。2 ** 53 を超えたら即座に壊れるのではなく、表せない値になった時点で壊れます。25! は指数表記になって、下の桁が完全に消えました。

④ で見た MAX_SAFE_INTEGER の話が、⑧ の階乗で実際に効いてきました。 「大きい数を数える」ことは、「数の持ち方を知っている」ことと切り離せません。

この伸び方の違いが、次の回の全部

この表が言っているのは、1つのことです。

同じ「1万件」でも、log n なら14回、n² なら1億回。

処理の書き方が違うだけで、この差が出ます。 それを測る話が 1万件で100倍になる — 計算量とO記法を測る です。

この記事でやったことが、あそこで使えます。

  • log₂ n が「半分にできる回数」だと分かっているので、二分探索の速さが暗記項目でなくなる
  • 2 ** n の伸び方を実際に見たので、「全組み合わせを試す」がなぜ現実的でないかが数で分かる
  • n! が BigInt でないと表せないことを踏んだので、桁があふれることを疑う癖がつく

つまずいたところ

1. toString(2) は文字列を返し、parseInt は基数を省略すると勝手に推測する

(13).toString(2) + 1 を打って 11011 が出ました。'1101' + 1 の文字列連結です。 2進数の足し算をしたつもりでした。JavaScript の数値に「10進」「2進」という状態はありません。 常に2進で持っていて、文字にするときに基数を選ぶだけです。逆向きも同じで、parseInt('1101') は 1101(10進として読む)、parseInt('0x1f') は 31(0x を見て16進として読む)。ルールが1つでないので、基数は必ず書くと決めました。

2. | 0 を「小数を切り捨てる書き方」として覚えていた

短くて速いと聞いて使っていました。30億を超える値で -1294967296 が出て、初めて32ビットに落ちていることを知りました。 さらに -5.9 | 0 が -5 で、Math.floor(-5.9) が -6 なのも知りませんでした。「同じ結果になる短い書き方」だと思っていたら、2つの点で別物でした。 いまは Math.trunc か Math.floor を書いています。1文字のために挙動を暗記する価値はありません。

3. 0.1 + 0.2 の説明を「浮動小数点だから」で止めていた

人に聞かれたときに「浮動小数点は誤差が出るので」と答えていました。そう答えていた自分が、0.5 + 0.25 === 0.75 が true になることを知りませんでした。 誤差はいつでも出るのではなく、表せない数を渡したときだけ出ます。 これを知らないと「小数はすべて信用できない」という間違った結論になり、必要のない場所にも toFixed を貼ることになります。実際、私はそうしていました。

4. toFixed で直ったと思った

(0.1 + 0.2).toFixed(2) が '0.30' になったので、直ったと思いました。直っていたのは表示だけです。 そのあと (1.005).toFixed(2) が 1.00 になるのを見て、toFixed 自体が同じ問題の上に乗っていることを知りました。症状を隠す道具を、直す道具だと思っていたのがいちばんの遠回りでした。

5. Number.EPSILON を「どこでも使える誤差の許容値」だと思った

「小数の比較は Number.EPSILON と比べればいい」と読んで、そのまま使っていました。EPSILON は 2 ** -52、つまり「1 のあたりでの刻み幅」です。 値が 1e15 のあたりでは、隣の表せる値との差が 0.125 もあります。EPSILON と比べても、絶対に等しくなりません。 しきい値は扱う値の大きさに合わせるもので、定数を1つ覚えて済む話ではありませんでした。

6. BigInt と数値を混ぜてエラーになり、BigInt を諦めた

1n + 1 で Cannot mix BigInt and other types が出て、「使いにくい機能だ」と思って戻しました。あれは親切な設計です。 混ぜられたら、どちらの精度に合わせるかを言語が勝手に決めることになります。黙って Number に落とされて桁が消えるより、止まるほうが良い。あと 7n / 2n が 3n になる(切り捨て)ことも知らずに、按分の計算に使いかけました。

7. DataView と型付き配列で、エンディアンの既定が逆だと知らなかった

Float64Array で覗いたビット列と、DataView で取ったビット列が一致しなくて、片方が壊れていると思いました。 どちらも正しくて、DataView の既定がビッグエンディアン、型付き配列はマシンに従うという違いでした。「既定はどちらか」を確かめずに使っていたのが原因です。以来、DataView では第3引数を必ず書いています。

8. JSON.parse で整数が変わることを、DBのバグだと思った

外部から受け取ったIDが、保存したものと1つ違っていました。DBを疑い、ログを疑い、最後にコンソールで JSON.parse の結果を見て気づきました。 2 ** 53 を超える整数は、読み込んだ瞬間に別の数になります。 JSON の仕様には整数の桁の上限が無いのに、JavaScript 側に上限がある、というのが原因です。大きなIDは文字列で扱うしかありません。


後片づけ

この記事で作ったものを消します。

まず、node の対話モードを開いたままにしていないか確かめます。

bash
$ jobs

何か出たら、fg で戻して .exit で抜けてください。

作ったファイルを確認します。

bash
$ ls -l ~/cslab/binary
bigint.js  big.bin   bitops.js  cidr.js   compare.js  detect.js
endian.js  f64array.js  flags.js  growth.js  ieee754.js  little.bin
log2.js    money.js  nibble.js  safeint.js  swap.js  tofixed.js
trap32.js  writebin.js

全部この記事で作ったものです。 フォルダごと消します。

bash
$ cd ~
$ rm -rf ~/cslab
$ ls ~ | grep cslab

何も出なければ片づいています。

Node.js は残しておいてください。 このあとの回でも使います。消したい場合だけ、こうします。

bash
$ sudo apt remove -y nodejs

ただし、他のものが nodejs に依存していると一緒に消えます。 apt remove の実行前に、消えるパッケージの一覧が出るので必ず読んでください。 迷ったら残してください。ディスクを数十MB使うだけです。


まとめ — 理解できたこと

  • 2進数を「読める」とは、桁の重み(1, 2, 4, 8, …)を言えることであって、暗算できることではない
  • 16進数を使う理由は、2⁴ = 16 で「1桁がちょうど4ビット」だから。 4桁ずつ切って表を引くだけで機械的に読み替えられる。10進では桁がどこでも噛み合わないので、これができない。そして 1バイト = 16進2桁
  • ビット演算は7種類しかなく、それぞれに用途がある。 立っているか調べるのが &、立てるのが |、反転が ^、落とすのが & ~x、2倍と半分が << >>、符号を無視して詰めるのが >>>
  • JavaScript のビット演算は、値を32ビットに切り落としてから計算する。 だから 2 ** 31 | 0 は負になり、2 ** 32 | 0 は 0 になり、1 << 32 は 1 になる。| 0 は切り捨ての代用にしてはいけない
  • 0.1 が2進数で表せないのは、10進で 1/3 が書けないのと同じ理由。 有限桁で書けるのは、分母がその基数の素因数のべき乗だけでできている分数に限られる。2 の世界には 5 が無いので、1/10 は書けない
  • 浮動小数点は不正確ではない。 0.5 + 0.25 === 0.75 は true。表せない数を渡したときだけ、いちばん近い値に寄せる
  • 0.1 + 0.2 と 0.3 は、隣どうしの表せる値で、最下位の1単位だけ違う。 前者は丸めが切り上がり、後者は切り捨てられたから。「誤差が積もった」より「丸める方向が違った」が正確
  • IEEE 754 の倍精度は 符号1 + 指数11 + 仮数52。 先頭の 1. は必ず 1 なので保存されない。指数は 1023 を引いて読む。DataView で本当に取り出せる
  • 2 ** 53 を超えると整数も1刻みで表せない。 9007199254740993 と書いた瞬間に別の数になる。JSON.parse でも起きるので、大きなIDは文字列で扱う
  • 金額の正しい持ち方は「最小単位の整数」。 4.35円は 435銭として持ち、表示のときだけ割る。桁があふれるなら BigInt。DBで FLOAT を選ばないのと同じ判断
  • toFixed は表示を整えるだけで、計算は直っていない。 (1.005).toFixed(2) が 1.00 になるのは、箱の中身が 1.00499… だから正しく丸めた結果。しかも返り値は文字列
  • 小数の比較は === ではなく差の絶対値で。 ただし Number.EPSILON は「1 のあたりの刻み幅」なので、大きい値では使えない。しきい値は値の大きさに合わせる
  • 同じ4バイトが、書く向きでバイト列が逆になる。 x86 はリトル、ネットワーク上の並びはビッグ。問題になるのは自分でバイナリを読み書きするときだけで、JSON や HTTP には出てこない。DataView の既定はビッグ、型付き配列はマシンに従う(既定が逆)
  • chmod 755 は8進(1桁 = 3ビット)で書いたフラグの集合、/24 は「上位24ビットが1」というビットの本数。 そして log₂ n は「何回半分にできるか」(100万件で20回、10億件で30回)。同じ n = 64 で log₂ n は 6、n! は 90桁 — この伸び方の差が、次の回で扱う計算量の内容そのもの

参考リンク


次に読む

この記事は 【深掘り】コンピュータ科学 の 2 / 25 本目です。

記事
← 前の記事CPUの仕組みを自作する — 足し算しかしていない
→ 次の記事文字コードとUTF-8 — 化けたのは読み方だけ

上から順に読めば積み上がるように並べています。 飛ばしても構いませんが、詰まったら前の回に戻ってください。

全体の順路は はじめに にあります。

roadmap.sh のどこをやっているか

›CS — Binary & Bitwise
  • ビット演算と2の補数
  • IEEE 754 とエンディアン

この記事は、上の項目を実際に手を動かして確かめる回です。

よかったらシェアしてね!
  • URLをコピーしました!
  • URLをコピーしました!

コメント

コメントする

目次