List of Floating-Point [text.Baldanders.info]

0.1 たす 0.2 が 0.3 にならない場合

2020-08-19T02:43:53+00:00

面白い tweet を見かけたので。

以下のコード

package main

import "fmt"

func main() {
    a := 0.1
    b := 0.2
    c := a + b
    fmt.Println(c == 0.3)
}

を実行したら true になるか false になるか，というもの。分からなければ実際に書いて実行してみれば分かる。

ちなみに Go 言語では小数点数のリテラル表現を使って a := 0.1 の様に記述すると暗黙的に float64 (倍精度浮動小数点数) 型として宣言・初期化される¹。

まぁ，浮動小数点数の仕様はプログラマなら知ってて当然だよね（笑）

念のために説明すると，これは（言語に関係なく）浮動小数点数の標準である IEEE 754 の仕様によるもの。 IEEE 754 は浮動小数点数を2進数で保持している。

たとえば 0.1 を Go の書式 %b で表すと

package main

import "fmt"

func main() {
	fmt.Printf("%b\n", 0.1)
    //Output:
    //7205759403792794p-56
}

となる。仮数部が10進数になっているので分かりにくいが，無理やり2進数で表すと

package main

import "fmt"

func main() {
	fmt.Printf("%b\n", 0.1)
    fmt.Printf("%bp-56\n", 7205759403792794)
    //Output:
    //7205759403792794p-56
    //11001100110011001100110011001100110011001100110011010p-56

}

と循環し，丸め誤差が発生していることが分かる。これが「0.1 たす 0.2 が 0.3 にならない」カラクリである。

といっても数値計算であれば（計算誤差を含めた誤差評価ができているなら）特に問題はないのだが，たとえばお金の計算をする場合は小数点以下で計算誤差が発生しては困ってしまう。

そこで，大抵の言語では「通貨型」と呼ばれる型またはクラスが用意されている。中身は10の冪でスケーリングした固定小数点数であることが多い。こういった型やクラスを上手く使い分けることがプログラム設計の最初の1フィートとなるだろう。

なお Go 言語では，通貨型あるいは固定小数点数型に相当するものが基本型にも標準ライブラリにも存在しない²。その代わりと言ってはナニだが，標準の math/big パッケージに有理数型 big.Rat がある。これを使えば（ちょっと面倒くさい記述になるが）先ほどのコードは

package main

import (
    "fmt"
    "math/big"
)

func main() {
    a := big.NewRat(1, 10)
    b := big.NewRat(2, 10)
    c := (&big.Rat{}).Add(a, b)
    fmt.Println(big.NewRat(3, 10).Cmp(c) == 0)
}

のように書き換えることができる。実行結果は各自でどうぞ（笑）

ブックマーク

参考図書

プログラマの数学第2版: 結城浩 (著); SBクリエイティブ 2018-01-16 (Release 2018-02-08); Kindle版; B079JLW5YN (ASIN); 評価

[Comment] タイトル通りプログラマ必読書。第2版では機械学習に関する章が付録に追加された。

reviewed by Spiegel on 2018-03-19 (powered by PA-APIv5)

プログラミング言語Go (ADDISON-WESLEY PROFESSIONAL COMPUTING SERIES): Alan A.A. Donovan (著), Brian W. Kernighan (著), 柴田芳樹 (翻訳); 丸善出版 2016-06-20; 単行本（ソフトカバー）; 4621300253 (ASIN), 9784621300251 (EAN), 4621300253 (ISBN); 評価

[Comment] 著者のひとりは（あの「バイブル」とも呼ばれる）通称 “K&R” の K のほうである。この本は Go 言語の教科書と言ってもいいだろう。と思ったら絶版状態らしい（2025-01 現在）。復刊を望む！

reviewed by Spiegel on 2016-07-13 (powered by PA-APIv5)

厳密には定数 “0.1” は，いったん「型付けなし」の浮動小数点数として評価された後，変数宣言時に float64 に暗黙的に変換される。 ↩︎
ただし shopspring/decimal のようなパッケージを公開されている方はいる。感謝！ ↩︎

Go 言語で浮動小数点数をいろいろな書式で表示してみる

2019-09-27T16:27:23+00:00

今日も面白い記事を見つけた。

go で float32 を JSON にするとちょっと意外なことになる - Qiita

今回は Go 1.13 になった記念として浮動小数点数をいろいろな書式で表示してみることにする。

その前に…

上の記事について補足をしておくが¹， 0xa0000000 をいわゆる倍精度浮動小数点数（Go 言語で言うところの float64）にキャストした場合と，いったん単精度浮動小数点数（Go 言語で言うところの float32）にキャストした後に倍精度で再度キャストした場合で結果は同じ値になるが，これは倍精度へのキャストで精度が復元しているわけではない点に注意が必要である。

このことは 0xa0000000 を2進数に展開するとよく分かる。 Go 1.13 から %b で整数値を2進数で表現できるようになったので試してみよう。

fmt.Printf("%b\n", int64(0xa0000000))
//Output
//10100000000000000000000000000000

このとおり 0xa0000000 の実質的な有効桁数は3ビットしかない。なので，単精度と倍精度の間でキャストを繰り返しても実質的な精度に影響はないのである。

もし有効桁数の違いを見たいのであればサンプルの値を 0xa0000001 に変えてみるといいだろう。たとえば件の記事に出てくる JavaScript コード

o = {
  foo: new Float32Array([0xa0000000]),
  bar: new Float64Array([0xa0000000])
}
process.stdout.write(JSON.stringify(o));

を

o = {
  foo: new Float32Array([0xa0000001]),
  bar: new Float64Array([0xa0000001])
}
process.stdout.write(JSON.stringify(o));

に書き換えて実行してみると

$ node json.js 
{"foo":{"0":2684354560},"bar":{"0":2684354561}}

という感じに異なる値で表示される。これで JavaScript コードでも明示的に単精度浮動小数点数にすれば，ちゃんと精度が削られること（情報落ち）が分かるだろう。

JSON (RFC 7159) における数値（numbers）の内部表現は倍精度浮動小数点数のみだが JavaScript の仕様に合わせて整数で表現可能な場合はできるだけ整数で表そうとする。故に無理やり単精度浮動小数点数に押し込めばこんな妙ちきりんなことも起きる。幸い JSON は 1.23E+4 みたいな表現も許容するので，有効桁数を明示したいならこの表記がいいだろう。

ちなみに Go 言語で float32 を JSON 形式に展開する際に 1.23E+4 のような表記にしたければ float32 を wrap する型を作って

type Float32 float32

func (f Float32) MarshalJSON() ([]byte, error) {
    return []byte(fmt.Sprintf("%v", f)), nil
}

などとすればよい。

0xa0000001 を様々な書式で表記してみる

ようやく本題（笑）

あらかじめ 0xa0000001 を

const value = 0xa0000001

var (
    i64 = int64(value)
    f64 = float64(value)
    f32 = float32(value)
)

と定義して fmt.Printf() 関数の各書式（verb）を使って表記してみよう。こんな感じ。

Format	Expression
`fmt.Printf("%d", i64)`	`2684354561`
`fmt.Printf("%b", i64)`	`10100000000000000000000000000001`
`fmt.Printf("%f", f64)`	`2684354561.000000`
`fmt.Printf("%f", f32)`	`2684354560.000000`
`fmt.Printf("%e", f64)`	`2.684355e+09`
`fmt.Printf("%e", f32)`	`2.684355e+09`
`fmt.Printf("%g", f64)`	`2.684354561e+09`
`fmt.Printf("%g", f32)`	`2.6843546e+09`
`fmt.Printf("%g", float64(f32))`	`2.68435456e+09`

更に Go 1.13 から浮動小数点数に対して %b が使えるようになった。 %b を使うと仮数部と指数部を分離した表記になる。こんな感じ。

Format	Expression
`fmt.Printf("%b", f64)`	`5629499536310272p-21`
`fmt.Printf("%b", f32)`	`10485760p+8`
`fmt.Printf("%b", float64(f32))`	`5629499534213120p-21`

仮数部が10進数表記で分かりにくいので，強引に2進数に置き換えるとこんな感じ。

Value	Expression
`f64`	`10100000000000000000000000000001000000000000000000000p-21`
`f32`	`101000000000000000000000p+8`
`float64(f32)`	`10100000000000000000000000000000000000000000000000000p-21`

float32 で8ビット分の情報落ちが発生していることがよく分かる。覆水盆に返らず（笑）

Go 1.13 で浮動小数点数の内部構造が簡単に見れるようになって，浮動小数点数対する理解がより進むというものである。

【おまけの追記】 encoding/json パッケージにおける浮動小数点数の扱いと json.Number 型

Go 言語の標準パッケージである encoding/json で構造体の要素に float32/float64 を割り当てた際の JSON へのエンコードでは，最終的に strconv.AppendFloat() 関数で文字列に変換される。

strconv.AppendFloat() 関数とほぼ同じ機能を持つ strconv.FormatFloat() 関数で出力を確認してみよう。

Conversion	Output
`strconv.FormatFloat(f64, 'f', -1, 64)`	`2684354561`
`strconv.FormatFloat(f64, 'f', -1, 32)`	`2684354600`
`strconv.FormatFloat(float64(f32), 'f', -1, 64)`	`2684354560`
`strconv.FormatFloat(float64(f32), 'f', -1, 32)`	`2684354600`

encoding/json では1番目および4番目のフォーマットを使っている。理由は不明だが間違いではない。単精度浮動小数点数の有効桁数は10進数換算で7桁程度しかないため 2684354560 と 2684354600 の違いに意味はないのだ。

それでも JavaScript に近い表記が欲しいのであれば，たとえば先程の float32 の wrapper として定義した Float32 型を以下のように書き直すことで実現できる。

type Float32 float32

func (f Float32) MarshalJSON() ([]byte, error) {
    return []byte(strconv.FormatFloat(float64(f), 'f', -1, 64)), nil
}

ところで，ちょっと反則的（？）かもしれないが encoding/json パッケージには json.Number という型が用意されている。 json.Number 型は名前に反して string 型の wrapper になっている。

// A Number represents a JSON number literal.
type Number string

// String returns the literal text of the number.
func (n Number) String() string { return string(n) }

// Float64 returns the number as a float64.
func (n Number) Float64() (float64, error) {
	return strconv.ParseFloat(string(n), 64)
}

// Int64 returns the number as an int64.
func (n Number) Int64() (int64, error) {
	return strconv.ParseInt(string(n), 10, 64)
}

つまり JSON との Marshal/Unmarshal は文字列と同じ扱いだが，必要に応じて数値（int64 または float64 型）に変換できるというわけだ。

これまで述べたように JSON の numbers を浮動小数点数に変換すると計算誤差が発生するため破壊的な変換になりがちだが json.Number 型であればそれを最小限に抑えられるだろう。

ブックマーク

参考図書

プログラミング言語Go (ADDISON-WESLEY PROFESSIONAL COMPUTING SERIES): Alan A.A. Donovan (著), Brian W. Kernighan (著), 柴田芳樹 (翻訳); 丸善出版 2016-06-20; 単行本（ソフトカバー）; 4621300253 (ASIN), 9784621300251 (EAN), 4621300253 (ISBN); 評価

reviewed by Spiegel on 2016-07-13 (powered by PA-APIv5)

件の記事の著者は浮動小数点数の性質については分かった上で Go 言語以外の言語との表現の違いについて問題にしておられるようだ。 ↩︎

スプレッド・シートでフィボナッチ数列を列挙する

2019-06-23T06:57:34+00:00

あっ，ブログネタ見っけ（笑）

LibreOffice CalcとExcelの計算結果誤差をみなさんで検証していただいた結果まとめ - Togetter

はっきり言って前半の議論以下の脊髄反射的やり取りは鼻糞ほどの参考にもならないので，最後に紹介されているリンクを読むことを強くオススメする。

Excelの演算誤差

いや，これ読んでて大昔に特定用途のバンドパスフィルタのシミュレーションを Excel で書かされたことを思い出したよ。トラウマになるほどではなかったが，あれはなかなか酷い仕事だった（笑）

【事前準備】フィボナッチ数列の一般項

閑話休題 (それはさておき) ，問題を整理しよう。

まずはフィボナッチ数列の定義から。 $n$ 番目のフィボナッチ数を $F_n$ で表すと

\begin{align*} F_0 &= 0 \\ F_1 &= 1 \\ F_{n+2} &= F_n + F_{n+1} & (n = 0,1,2,3 \cdots) \end{align*}

で定義できる。ちなみに，この定義を素朴に Go 言語コードにしたのが以下。

package main

import "fmt"

var fibonacciNumbers = make(map[int64]int64)

func fibonacciNumber(n int64) int64 {
    switch n {
    case 0:
        return 0
    case 1:
        return 1
    default:
        if fn, ok := fibonacciNumbers[n]; ok {
            return fn
        }
        fn := fibonacciNumber(n-2) + fibonacciNumber(n-1)
        fibonacciNumbers[n] = fn
        return fn
    }
}

func main() {
    fmt.Println("| $n$ | $F_n$ |")
    fmt.Println("| ---:| ---:|")
    for n := int64(1); n <= 75; n++ {
        fmt.Printf("| %d | %d |\n", n, fibonacciNumber(n))
    }
}

このコードを実行して1番目から75番目までのフィボナッチ数列をつくりリファレンス値としよう。一部を挙げておく。

$n$	$F_n$
1	1
2	1
3	2
4	3
5	5
…	…
69	117669030460994
70	190392490709135
71	308061521170129
72	498454011879264
73	806515533049393
74	1304969544928657
75	2111485077978050

ところで定義で挙げた数式は「漸化式」と呼ばれるものだが，一般項で表すこともできる。面倒なので結果だけ Wikipedia から引用してしまおう。すなわち

\begin{align*} \varphi &= \frac{1+\sqrt{5}}{2} \\ \psi &= \frac{1-\sqrt{5}}{2} = 1 - \varphi \end{align*}

とするなら $F_n$ は

\begin{align*} F_n &= \frac{\varphi^n - \psi^n}{\varphi - \psi} = \frac{\varphi^n - \psi^n}{\sqrt{5}} & (n = 0,1,2,3 \cdots) \end{align*}

と書ける¹。これをGo 言語で書くとこんな感じ。

package main

import (
    "fmt"
    "math"
)

func main() {
    fmt.Println("| $n$ | $\\varphi^n$ | $\\psi^n$ | $F_n$ |")
    fmt.Println("| ---:| ---:| ---:| ---:|")
    r5 := math.Sqrt(5)
    phi := (1 + math.Sqrt(5)) / 2
    psi := 1 - phi
    for n := int64(1); n <= 75; n++ {
        phin := math.Pow(phi, float64(n))
        psin := math.Pow(psi, float64(n))
        f := (phin - psin) / r5
        fmt.Printf("| %d | %.15f | %.15f | %.15f |\n", n, phin, psin, f)
    }
}

結果も載せておこう。

$n$	$\varphi^n$	$\psi^n$	$F_n$
1	1.618033988749895	-0.618033988749895	1.000000000000000
2	2.618033988749895	0.381966011250105	1.000000000000000
3	4.236067977499790	-0.236067977499790	2.000000000000000
4	6.854101966249685	0.145898033750315	3.000000000000000
5	11.090169943749475	-0.090169943749474	5.000000000000000
…	…	…	…
69	263115950957275.968750000000000	-0.000000000000004	117669030460993.984375000000000
70	425730551631122.937500000000000	0.000000000000002	190392490709134.968750000000000
71	688846502588399.000000000000000	-0.000000000000001	308061521170129.000000000000000
72	1114577054219521.750000000000000	0.000000000000001	498454011879263.875000000000000
73	1803423556807920.750000000000000	-0.000000000000001	806515533049392.875000000000000
74	2918000611027442.500000000000000	0.000000000000000	1304969544928656.750000000000000
75	4721424167835363.000000000000000	-0.000000000000000	2111485077978049.500000000000000

$\psi^n$ の値が小さすぎてガッツリ情報落ちしているが $F_n$ として必要なのは整数部分のみなので小数点以下を丸めた値が正しければ無問題。実際のところ

\begin{align*} \left| \frac{\psi^n}{\sqrt{5}} \right| &\lt \frac{1}{2} & (n = 0,1,2,3 \cdots) \end{align*}

と言えるので

\begin{align*} F_n &= \left[ \frac{\varphi^n}{\sqrt{5}} \right] = \left\lfloor \frac{\varphi^n}{\sqrt{5}} + \frac{1}{2} \right\rfloor & (n = 0,1,2,3 \cdots) \end{align*}

でも十分いけるのだ。

ていうかね。 $\sqrt{5}$ を無理やり浮動小数点数に展開して計算してるんだから誤差が出て当然なのであり，それが不可視化されている各スプレッドシートのほうが相当怪しげな内部処理をしていると言わざるを得ない。

スプレッドシートでフィボナッチ数列の一般項を計算する

さて，ようやく本題。

つまるところ，この一般項を使ってスプレッドシートでフィボナッチ数列を計算させたらどうなるか，というのが今回のお題だ。

まずA列に 1, 2, 3, 4,… と整数値を入れておく
B列には式 =((1+SQRT(5))/2)^A1 (1行目の場合) をセットする（$\varphi^n$ 相当）
C列には式 =((1-SQRT(5))/2)^A1 (1行目の場合) をセットする（$\psi^n$ 相当）
D列には式 =((((1+SQRT(5))/2)^A1)-(((1-SQRT(5))/2)^A1))/SQRT(5) (1行目の場合) をセットする

これで B列 → C列 → D列と計算過程を追うことができる。

まずは LibreOffice Calc で実行してみた。ちなみにバージョン6.2系である。

fibonacci-numbers.ods

結果の一部，70番目以降のみ挙げておく。

$n$	$\varphi^n$	$\psi^n$	$F_n$
70	425730551631124.000000000000000	0.000000000000002	190392490709135.000000000000000
71	688846502588401.000000000000000	-0.000000000000001	308061521170130.000000000000000
72	1114577054219520.000000000000000	0.000000000000001	498454011879265.000000000000000
73	1803423556807930.000000000000000	-0.000000000000001	806515533049395.000000000000000
74	2918000611027450.000000000000000	0.000000000000000	1304969544928660.000000000000000
75	4721424167835376.000000000000000	0.000000000000000	2111485077978060.000000000000000

まず小数点以下の値が潰れているのが懸念点なのだが（これについては後述する），表からは71番目からはリファレンス値に対して明らかにズレが生じていることが分かる。

同じことを Google スプレッドシートでもやってみた。

fibonacci-numbers

これも70番目以降のみ挙げておこう。

$n$	$\varphi^n$	$\psi^n$	$F_n$
70	425730551631124.000000000000000	0.000000000000002	190392490709135.000000000000000
71	688846502588401.000000000000000	-0.000000000000001	308061521170130.000000000000000
72	1114577054219520.000000000000000	0.000000000000001	498454011879265.000000000000000
73	1803423556807930.000000000000000	-0.000000000000001	806515533049395.000000000000000
74	2918000611027450.000000000000000	0.000000000000000	1304969544928660.000000000000000
75	4721424167835380.000000000000000	0.000000000000000	2111485077978060.000000000000000

途中計算に若干の違いはあれど最終的な結果は同じになった。

Excel のことは知らない²。

Machine Epsilon

ある処理系における浮動小数点数の精度を調べるには $1+\epsilon-1$ がゼロにならない最小の $\epsilon$ すなわち machine epsilon を調べるのがよい。今回使っている処理系では，浮動小数点数の基数はどれも2進数なので $\epsilon$ の値を

\begin{align*} \epsilon &= \frac{1}{2^{n}} & (n = 1,2,3 \cdots) \end{align*}

として調べていけばいいだろう。たとえば Go 言語であれば

package main

import (
    "fmt"
    "math"
)

func main() {
    fmt.Println("| $n$ | $\\epsilon$ | $1+\\epsilon-1$ |")
    fmt.Println("| ---:| ---:| ---:|")
    for n := int64(1); n <= 55; n++ {
        e := math.Pow(2.0, float64(-n))
        me := 1.0 + e - 1.0
        fmt.Printf("| %d | %v | %v |\n", n, e, me)
    }
}

といったコード。このコードの実行結果（の一部）は以下の通り。

$n$	$\epsilon$	$1+\epsilon-1$
45	2.842170943040401e-14	2.842170943040401e-14
46	1.4210854715202004e-14	1.4210854715202004e-14
47	7.105427357601002e-15	7.105427357601002e-15
48	3.552713678800501e-15	3.552713678800501e-15
49	1.7763568394002505e-15	1.7763568394002505e-15
50	8.881784197001252e-16	8.881784197001252e-16
51	4.440892098500626e-16	4.440892098500626e-16
52	2.220446049250313e-16	2.220446049250313e-16
53	1.1102230246251565e-16	0

64ビット浮動小数点数の仮数部のサイズは52ビットなので，これは妥当な結果と言える。

同じことを LibreOffice Calc で実行した結果は以下の通り。

$n$	$\epsilon$	$1+\epsilon-1$
45	2.8421709430404E-14	2.8421709430404E-14
46	1.4210854715202E-14	1.4210854715202E-14
47	7.105427357601E-15	7.105427357601E-15
48	3.5527136788005E-15	3.5527136788005E-15
49	1.77635683940025E-15	0
50	8.88178419700125E-16	0
51	4.44089209850063E-16	0
52	2.22044604925031E-16	0
53	1.11022302462516E-16	0

Excel で聞かれる括弧の付け方で結果が変わる云々はなかったが $\epsilon=2^{-48}$ までの精度しかないようだ。これなら先のフィボナッチ数列一般項の計算結果も納得である。何がネックになってるのかは分からないが。

Google スプレッドシートはちょっと複雑で，まず冪乗計算（POW(x,y) または x^y）が $2^{-33}$ までしか値が取れない。しょうがないので，計算値ではなく，生の $\epsilon$ 値をセルにコピペして検証してみたところ $\epsilon=2^{-52}$ までの精度があることが確認できた³。しかし関数ごとに精度が異なるのであれば，これはこれでヒッジョーに面倒くさい話になる。

というわけで

結論として（大きな有効桁数が要件となる）数値計算をスプレッドシートで行うのはオススメできない。やるのであれば身元の確かなツールを使って数値計算を行い，その結果をスプレッドシートにインポートしてデータの整理を行うことであろうか。

ブックマーク

1を1億回足して1億にならない場合

参考図書

数学ガール: 結城浩 (著); SBクリエイティブ 2007-06-26 (Release 2014-03-12); Kindle版; B00EYXMA9I (ASIN); 評価

[Comment] ミルカさんとの衝撃の encounter。数学ガールがワルツを踊る。

reviewed by Spiegel on 2014-02-14 (powered by PA-APIv5)

プログラマの数学第2版: 結城浩 (著); SBクリエイティブ 2018-01-16 (Release 2018-02-08); Kindle版; B079JLW5YN (ASIN); 評価

[Comment] タイトル通りプログラマ必読書。第2版では機械学習に関する章が付録に追加された。

reviewed by Spiegel on 2018-03-19 (powered by PA-APIv5)

ちなみに今回出てきた $\varphi$ の値は「黄金比（golden ratio）」などと呼ばれているらしい。黄金比については与太話も含めて色々と面白い話もあるが今回は割愛する。 ↩︎
もはや Microsoft Office は個人ユーザが使うものではないだろう。あれはお役所や企業等のレガシー環境で仕方なく使う道具である。 ↩︎
$\epsilon$ 値は Go 言語コードで吐き出されたものを使った ↩︎

モンティ・ホール問題で遊ぶ

2018-04-20T01:31:29+00:00

有名な数学問題なので知ってる人も多いと思うけど一応解説すると，「モンティ・ホール問題」というのは Monty Hall という人が司会をつとめるアメリカの番組 “Let’s make a deal” 内で行われたゲームに関する問題である。

簡単にルールを紹介する。

プレイヤーの前に閉まった3つのドアがある。1つのドアの後ろには景品の新車が，2つのドアの後ろには（はずれを意味する）ヤギがいる
プレイヤーが1つのドアを選択
司会者が残りのドアのうちヤギがいるドアを開けてヤギ（＝はずれ）を見せる
プレイヤーは最初に選んだドアを変更してもよい

このときプレイヤーは最初に選択したドアを変更したほうが得（つまり当たる確率が高い）かどうか，というのが「モンティ・ホール問題」のあらましである。

この問題について「ドアを変更したほうが当たる確率が高い」と示した女性がいて，これに対して猛烈な反発が起こり大論争になったらしい（女性蔑視な発言もあったそうで，今なら確実にハラスメント案件だよなw）。

ポイントは3番目の「はずれのドアを開ける」部分で（司会者はどのドアが当たりかあらかじめ知っている），残りの2つのドアのどちらかが当たりなのだからというので多くの人が直感的に「当たる確率は半々」だと思った，博士号保持者も含めて。

この問題は事後確率（posterior probability）と呼ばれるものの一種である¹。最初の選択で当たる確率は $1 / 3$ なので後半に変更しなければ $1 / 3$ のままだが，「はずれのドアを開ける」ことにより選択肢が既に選択したドアともうひとつのドアの2つになるため，ドアを変更した場合の当たる確率が $2 / 3$ （つまり半々より確率値が大きい）になるのである。

via Monty open door chances.svg - Wikimedia Commons

「モンティ・ホール問題」は直感と論理との乖離を示す好例として挙げられることが多く，また簡単な確率シミュレーションとしてプログラミングの演習問題に使われることもあるようだ。

というわけで「モンティ・ホール問題」をシミュレートするコードを Go 言語で組んでみよう（Go 言語で書くことに特に意味はない。皆さんはお好きな言語でどうぞ）。

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func selectDoor(limit, max int) <-chan int {
    ch := make(chan int)
    go func() {
        defer close(ch)
        rand.Seed(time.Now().UnixNano())
        for i := 0; i < max; i++ {
            ch <- rand.Intn(limit)
        }
    }()
    return ch
}

func challenges(shuldChange bool, max int) int {
    doors := []bool{true, false, false}
    ch := selectDoor(len(doors), max)
    count := 0
    for n := range ch {
        result := doors[n]
        if shuldChange {
            result = !result
        }
        if result {
            count++
        }
    }
    return count
}

func main() {
    max := 10000
    fmt.Println("nochange:", float64(challenges(false, max))/float64(max))
    fmt.Println("  change:", float64(challenges(true, max))/float64(max))
}

Go 言語的に面白いトピックはないので詳細は省くが，ざっくり説明すると selectDoor() 関数は（疑似乱数を使って）ドアを選択する関数で選択したドアを指定回数だけ channel で返す。 challenges() 関数は「モンティ・ホール問題」を指定回数だけ試行するもので，当たりの回数を返している。ドアを変更するか否かは引数 shuldChange で指定する。変数 doors がプレイヤーが選択するドアで，当たりが true に相当する。 for-range 構文の中身が実際に「モンティ・ホール問題」を試行している部分で

for n := range ch {
    result := doors[n]
    if shuldChange {
        result = !result
    }
    if result {
        count++
    }
}

ドアを変更しない場合はそのまま，変更する場合は真偽が反転する。これは「はずれのドアを開ける」と当たりとはずれのドアが必ずひとつづつになるため，最初に選択したドアとそうでないドアで真偽が反対になるからである。

では実際にコードを実行してみる。

$ go run monty-hall-problem.go
nochange: 0.3464
  change: 0.6675

というわけで，それっぽい値になった。めでたし。

「モンティ・ホール問題」は確かに直感に反するが²，こうやって具体的なコードで記述していくと「何故そうなるのか」が何となく分かってくる。どうせプログラミング教育をやるのならこういう感じでやっていただきたいものである（笑）

おまけ：N個のドアでモンティ・ホール問題

応用として $n$ 個のドアで「モンティ・ホール問題」を検証してみよう。ルールはこんな感じ。

プレイヤーの前に閉まった $n$ 個のドアがある（$n \ge 3$）。当たりのドアは $1$ つ。残り $n-1$ 個ははずれ
プレイヤーが $1$ つのドアを選択
司会者が残りのドアのうち $n-2$ 個のはずれドアを開ける
プレイヤーは最初に選んだドアを変更してもよい

まず先ほどのコードのうち challenges() 関数と main() 関数を以下のように変更する。

func challenges(shuldChange bool, dct, max int) int {
    doors := make([]bool, dct, dct) //initialized by false
    doors[0] = true
    ch := selectDoor(len(doors), max)
    count := 0
    for n := range ch {
        result := doors[n]
        if shuldChange {
            result = !result
        }
        if result {
            count++
        }
    }
    return count
}

func main() {
    dct := 3
    max := 10000
    fmt.Println("nochange:", float64(challenges(false, dct, max))/float64(max))
    fmt.Println("  change:", float64(challenges(true, dct, max))/float64(max))
}

これで最初のコードとまったく同じ機能になる。ここで main() 関数内の dct を 100 にして実行してみる。

$ go run monty-hall-problem.go
nochange: 0.0114
  change: 0.9785

何故こういう値になるか考えてみませう。簡単だよね。

おまけ2：有理数表現

Go 言語では math/big パッケージを使った有理数表現 big.Rat が使える。これを使って main() 関数を書き直すと

func main() {
    dct := 3
    max := 10000
    fmt.Println("nochange:", big.NewRat(int64(challenges(false, dct, max)), int64(max)).FloatString(4))
    fmt.Println("  change:", big.NewRat(int64(challenges(true, dct, max)), int64(max)).FloatString(4))
}

てな感じになる。 math/big パッケージを使うと，計算コストは高くなるが，浮動小数点数型特有の計算誤差を緩和できるメリットがある。まぁ，今回はあんまり関係ないけどね。

おおっ。なんか Go 言語っぽい（笑）

参考図書

プログラマの数学第2版: 結城浩 (著); SBクリエイティブ 2018-01-16 (Release 2018-02-08); Kindle版; B079JLW5YN (ASIN); 評価

[Comment] タイトル通りプログラマ必読書。第2版では機械学習に関する章が付録に追加された。

reviewed by Spiegel on 2018-03-19 (powered by PA-APIv5)

プログラミング言語Go (ADDISON-WESLEY PROFESSIONAL COMPUTING SERIES): Alan A.A. Donovan (著), Brian W. Kernighan (著), 柴田芳樹 (翻訳); 丸善出版 2016-06-20; 単行本（ソフトカバー）; 4621300253 (ASIN), 9784621300251 (EAN), 4621300253 (ISBN); 評価

reviewed by Spiegel on 2016-07-13 (powered by PA-APIv5)

事後確率についての説明は割愛する。ベイズ主義とか頻度主義とかちゃんと説明しようとするととてつもなく面倒臭いので。ただし事前確率とか事後確率とかいったものは統計学（ベイズ統計学）ではよく出てくる話なので，興味のある方は自力でどうぞ。 ↩︎
「モンティ・ホール問題」はジレンマやパラドックスの一種と見なされることがあるらしい。実際には論理的な矛盾はないので疑似パラドックスといったところだろうけど。 ↩︎

1を1億回足して1億にならない場合

2017-01-18T12:45:30+00:00

（この記事は Qiita に投稿した記事の転載です）

今回は軽めのネタで。

C > 浮動小数点型変数はループカウンタとして使用しない - Qiita

まぁ浮動小数点数型の仕様を知れば当たり前の話なのだが，面白そうなので「1を1億回足す」ってのを Go 言語でも書いてみる。

package main

import "fmt"

func main() {
    var d float32 = 0.0
    for i := 0; i < 100000000; i++ {
        d += 1.0
    }
    fmt.Println(d)
}

実行結果は予想通り

$ go run loop1.go
1.6777216e+07

となる¹。念のため float64 でも試してみよう。

package main

import "fmt"

func main() {
    var d float64 = 0.0
    for i := 0; i < 100000000; i++ {
        d += 1.0
    }
    fmt.Println(d)
}

結果は

$ go run loop2.go
1e+08

で，ちゃんと1億になる。 Go 言語では基本型のサイズが厳密に決まってるので（int, uint, uintptr は除く），浮動小数点数型の計算誤差についてもきちんと見積もれるはずである。

ちなみに

package main

import "fmt"

func main() {
    for d := 0.0; d < 1.0; d += 0.1 {
        fmt.Println(d)
    }
}

とすると²

$ go run loop3.go
0
0.1
0.2
0.30000000000000004
0.4
0.5
0.6
0.7
0.7999999999999999
0.8999999999999999
0.9999999999999999

ってなことになる³ ので浮動小数点数型の変数をループカウンタにするのは止めましょうね。約束だよ！

math/big パッケージ（追記）

浮動小数点数演算の「情報落ち」や「丸め誤差」等を緩和する方法として math/big パッケージの Float 型を使う手がある。 Float 型では有効桁数を指定できる。たとえば先程の 0.1 ずつカウントアップさせる処理ならこんなコードになる。

package main

import (
    "fmt"
    "math/big"
)

func main() {
    var x, y, z big.Float //zero initialize
    x.SetPrec(128)
    y.SetPrec(128)

    y.SetFloat64(0.1)
    for i := 0; i < 10; i++ {
        z.Add(&x, &y)
        fmt.Printf("z = %v (prec = %d bits)\n", &z, z.Prec())
        x.Set(&z)
    }
}

このコードでは精度を128ビットに揃えて計算している。これを実行するとこうなる。

$ go run big2.go
z = 0.100000000000000005551115123125782702118 (prec = 128 bits)
z = 0.200000000000000011102230246251565404236 (prec = 128 bits)
z = 0.300000000000000016653345369377348106354 (prec = 128 bits)
z = 0.400000000000000022204460492503130808473 (prec = 128 bits)
z = 0.50000000000000002775557561562891351059 (prec = 128 bits)
z = 0.60000000000000003330669073875469621271 (prec = 128 bits)
z = 0.700000000000000038857805861880478914827 (prec = 128 bits)
z = 0.800000000000000044408920985006261616945 (prec = 128 bits)
z = 0.900000000000000049960036108132044319063 (prec = 128 bits)
z = 1.00000000000000005551115123125782702118 (prec = 128 bits)

もうひとつ。 Rat 型を使う手もある。 Rat 型は有理数の内部表現で値を保持するため記述によっては誤差を小さくできる。たとえばこんな感じ。

package main

import (
    "fmt"
    "math/big"
)

func main() {
    x := &big.Rat{} //Zero initialize
    y := big.NewRat(1, 10)

    for i := 0; i < 10; i++ {
        z := (&big.Rat{}).Add(x, y)
        fmt.Printf("z = %s (%v)\n", z.FloatString(20), z)
        x.Set(z)
    }
}

実行結果は以下の通り。

$ go run big3.go
z = 0.10000000000000000000 (1/10)
z = 0.20000000000000000000 (1/5)
z = 0.30000000000000000000 (3/10)
z = 0.40000000000000000000 (2/5)
z = 0.50000000000000000000 (1/2)
z = 0.60000000000000000000 (3/5)
z = 0.70000000000000000000 (7/10)
z = 0.80000000000000000000 (4/5)
z = 0.90000000000000000000 (9/10)
z = 1.00000000000000000000 (1/1)

Decimal 型（追記）

残念ながら Go 言語の標準パッケージには Java で言うところの BigDecimal に相当するものがない。ただし似たパッケージを提供している人はいるようだ。

shopspring/decimal: Arbitrary-precision fixed-point decimal numbers in go

たとえばこんな感じに記述する。

package main

import (
    "fmt"

    "github.com/shopspring/decimal"
)

func main() {
    x := decimal.NewFromFloat(0)
    y, _ := decimal.NewFromString("0.1")

    for i := 0; i < 10; i++ {
        x = x.Add(y)
        fmt.Printf("x = %s\n", x.StringFixed(20))
    }
}

実行結果はこんな感じ。

$ go run big4.go
x = 0.10000000000000000000
x = 0.20000000000000000000
x = 0.30000000000000000000
x = 0.40000000000000000000
x = 0.50000000000000000000
x = 0.60000000000000000000
x = 0.70000000000000000000
x = 0.80000000000000000000
x = 0.90000000000000000000
x = 1.00000000000000000000

じゃあ試しに1を1億回足してみよう。

package main

import (
    "fmt"

    "github.com/shopspring/decimal"
)

func main() {
    x := decimal.NewFromFloat(0)
    y, _ := decimal.NewFromString("1.0")

    for i := 0; i < 100000000; i++ {
        x = x.Add(y)
    }
    fmt.Printf("x = %s\n", x.StringFixed(20))
}

実行結果はこうなる。

$ go run big4b.go
x = 100000000.00000000000000000000

結構な時間がかかった。でも「情報落ち」もなく綺麗に1億になったようだ。

ブックマーク

参考図書

プログラミング言語Go (ADDISON-WESLEY PROFESSIONAL COMPUTING SERIES): Alan A.A. Donovan (著), Brian W. Kernighan (著), 柴田芳樹 (翻訳); 丸善出版 2016-06-20; 単行本（ソフトカバー）; 4621300253 (ASIN), 9784621300251 (EAN), 4621300253 (ISBN); 評価

reviewed by Spiegel on 2016-07-13 (powered by PA-APIv5)

float32 は32ビットサイズの浮動小数点数型で，符号部1ビット，指数部8ビット，仮数部23ビット，という内訳になっている（仮数部は仮数の小数点以下を表す）。つまり有効桁数が24ビット（10進数で約7桁）しかない。したがって今回のような「1づつ加算する動作を繰り返す」処理では16,777,216（=0xffffff+1）以降は「情報落ち」が発生する。ちなみに float64 は64ビットサイズで仮数部は52ビットあり，10進数にして約15桁の有効桁数になる。 ↩︎
“d := 0.0” と記述した場合，変数 d は float64 として宣言・初期化される。厳密には定数 “0.0” は，いったん「型付けなし」の浮動小数点数として評価された後，変数宣言時に float64 に暗黙的に変換される。 Go 言語におけるこの定数の機能は何かと便利なので覚えておくとよいだろう。 ↩︎
このような結果になるのは float32/float64 の浮動小数点数型の内部表現が2進数になっているため。たとえば 0.1 を2進数で表すと「0.000110011…」と循環しキリのいい値にならない。このため 0.1 を加算していくと「丸め誤差」が蓄積していくのである。 ↩︎

List of Floating-Point [text.Baldanders.info]

0.1 たす 0.2 が 0.3 にならない場合

ブックマーク

参考図書

Go 言語で浮動小数点数をいろいろな書式で表示してみる

その前に…

0xa0000001 を様々な書式で表記してみる

【おまけの追記】 encoding/json パッケージにおける浮動小数点数の扱いと json.Number 型

ブックマーク

参考図書

スプレッド・シートでフィボナッチ数列を列挙する

【事前準備】 フィボナッチ数列の一般項

スプレッドシートでフィボナッチ数列の一般項を計算する

Machine Epsilon

というわけで

ブックマーク

参考図書

モンティ・ホール問題で遊ぶ

おまけ：N個のドアでモンティ・ホール問題

おまけ2：有理数表現

参考図書

1を1億回足して1億にならない場合

math/big パッケージ（追記）

Decimal 型（追記）

ブックマーク

参考図書

【事前準備】フィボナッチ数列の一般項