List of Circle-Ratio [text.Baldanders.info]

モンテカルロ法による円周率の推定（その4 PRNG）

2016-11-20T14:33:55+00:00

「モンテカルロ法による円周率の推定」もひととおり終わったので，今回は擬似乱数生成器（pseudo random number generator）の話。

math/rand の擬似乱数生成器

Go 言語では math/rand パッケージで擬似乱数を取り扱えることは「その1」で紹介した通り。 math/rand パッケージに実装されている擬似乱数生成器はラグ付フィボナッチ法（Lagged Fibonacci Generator）のバリエーションらしい。

If I am not mistaken again, the generator is an ALFG (Additive Lagged Fibonacci Generator, thats what Wikipedia calls it). Knuth describes the algorithm in Volume 2 of The art of computer programming in section 3.2.2 (around equation 7). Both Wikipedia and Knuth state the parameter combination 607,273 as possible combination with a period length of 2^(e-1) * (2^607-1) where e is the length of the random number in bits.
I actually found a few references examining its properties and it seems to be a good rng so faar, but there is still seems to be a lack of mathematical background and it is fairly easy to get into trouble by not seeding properly.

via [Announce] A rand package for high quality 64bit random numbers (possibly go2)

ラグ付フィボナッチ法は線形合同法（後述）を改善することを目的としたものでフィボナッチ数の生成法を元にしている。

Lagged Fibonacci generator - Wikipedia

ラグ付フィボナッチ法は以下の式で表される。

\begin{alignat*}{2} S_{n} \equiv S_{n-j} * S_{n-k} \pmod{m}, & \; & 0 \lt j \lt k \end{alignat*}

ラグ付フィボナッチ法は $ * $ 演算子によってバリエーションがあるが math/rand パッケージの実装では加算を使うため “Additive Lagged Fibonacci Generator” ということらしい。ソースコードで言うとこの部分かな。

// Int63 returns a non-negative pseudo-random 63-bit integer as an int64.
func (rng *rngSource) Int63() int64 {
    rng.tap--
    if rng.tap < 0 {
        rng.tap += _LEN
    }

    rng.feed--
    if rng.feed < 0 {
        rng.feed += _LEN
    }

    x := (rng.vec[rng.feed] + rng.vec[rng.tap]) & _MASK
    rng.vec[rng.feed] = x
    return x
}

擬似乱数生成器のバリエーション

math/rand パッケージでは以下の interface を持つ別の擬似乱数生成器を使うことができる。

// A Source represents a source of uniformly-distributed
// pseudo-random int64 values in the range [0, 1<<63).
type Source interface {
    Int63() int64
    Seed(seed int64)
}

以下に2つほど紹介する。

線形合同法

線形合同法（Linear Congruential Generator）は昔の擬似乱数ライブラリでよく使われていたアルゴリズムで，以下の式で表される。

\[ X_{n+1} = (A \times X_{n} + B) \bmod M \]

定数 $A$ および $B$ の与え方により幾つかバリエーションがある。

線形合同法のメリットは実装サイズが小さく計算量も少ない点だろうか。一方デメリットとしては，多次元で疎に分布する性質があり，周期も小さいため乱数を大量に発生させる必要がある科学技術シミュレーションなどには向かないと言われている。このためメモリサイズが限られるマイクロ・コントローラのようなものでもない限り線形合同法が使われることはなくなった。

Go 言語でわざわざ線形合同法を実装しているパッケージは少ないのだが，たとえば以下のパッケージがある¹。

davidminor/gorand: Basic golang implementation of a permuted congruential generator for pseudorandom number generation

Mersenne Twister

Mersenne Twister とは松本眞・西村拓士両氏によって1996年に発表された擬似乱数生成アルゴリズムである。他の擬似乱数生成アルゴリズムと比べて以下の特徴があるそうだ。（「Mersenne Twister とは?」より）

従来の様々な生成法の欠点を考慮して設計されています。
従来にない長周期，高次元均等分布を持ちます。（周期が $2^{19937}-1$ で²、623次元超立方体の中に均等に分布することが証明されています。）
生成速度がかなり速い。（処理系にもよりますが、パイプライン処理やキャッシュメモリのあるシステムでは、Cの標準ライブラリの rand() より高速なこともあります。なお、開発当時には cokus 版は rand() より4倍程度高速でしたが、その後 ANSI-C の rand() が LCG 法から lagged-fibonacci に変更されたこともあり、2002年現在 rand と MT の速度差はあまりありません。）
メモリ効率が良い。（32ビット以上のマシン用に設計された mt19937.c は、 624ワードのワーキングメモリを消費するだけです。 1ワードは32ビット長とします。

ちなみに Mersenne Twister のオリジナル・コードは BSD ライセンスで提供されている。

公式のリポジトリには C/C++ による実装のみのようだが， Go 言語で実装している人もいるようである。

seehuhn/mt19937: An implementation of Takuji Nishimura’s and Makoto Matsumoto’s Mersenne Twister pseudo random number generator in Go.
nutterts/randgen: Pseudo Random Number Generators implementing the Go(lang) math/rand.Source Interface
farces/mt19937_64: Mersenne Twister (int64) for Go
cuixin/goalg: golang algorithms
cpmech/gosl: Go scientific library : SFMT や TinyMT に対応。オリジナルのコードを cgo で結合しているのでクロス環境では注意

擬似乱数生成器を組み込む

では，先ほど紹介した擬似乱数生成器を今回のコードに組み込んでみることにしよう。こんな感じ。

package gencmplx

import (
    "math/rand"

    "github.com/davidminor/gorand/lcg"
    "github.com/seehuhn/mt19937"
)

//RNGs is kind of RNG
type RNGs int

const (
    NULL RNGs = iota
    GO
    LCG
    MT
)

//NewRndSource returns Source of random numbers
func NewRndSource(rng RNGs, seed int64) rand.Source {
    switch rng {
    case LCG:
        return lcg.NewLcg64(uint64(seed))
    case MT:
        mt := mt19937.New()
        mt.Seed(seed)
        return mt
    default:
        return rand.NewSource(seed)
    }
}

gencmplx.NewRndSource() 関数で rand.Source オブジェクトを生成する³。これを「その1」で作った gencmplx.New() 関数に渡せばよい。

CLI は以下のように調整してみた。

$ go run main.go estmt --help
Estimate of Pi with Monte Carlo method.

Usage:
  pi estmt [flags]

Flags:
  -e, --ecount int   Count of estimate (default 100)

Global Flags:
  -p, --pcount int       Count of points (default 10000)
  -r, --rsource string   Source of RNG (GO/LCG/MT) (default "GO")

で，それぞれの擬似乱数生成器で評価を行ってみようと思ったのだが，今回のケースに限ってはあまり違いが出ないようである。

まずは線形合同法の場合。

$ go run main.go estmt -e 10000 -p 100000 -r LCG > estmt100k-lcg.dat
random number generator: LCG
minimum value: 3.12204
maximum value: 3.16224
average value: 3.14164
standard deviation: 0.00524 (68.3%)

次は Mersenne Twister の場合。

$ go run main.go estmt -e 10000 -p 100000 -r MT > estmt100k-mt.dat
random number generator: MT
minimum value: 3.12380
maximum value: 3.16140
average value: 3.14165
standard deviation: 0.00517 (67.8%)

もっと多次元だったりすると変わってくるのかなぁ。

暗号技術用途の乱数生成器

Go 言語では暗号技術用途の乱数として crypto/rand パッケージが用意されている。これは math/rand とは互換性がない。

具体的には，UNIX 系のプラットフォームでは乱数生成に /dev/urandom デバイスを参照している⁴。また Windows プラットフォームでは CryptoAPI 2.0 の CryptGenRandom 関数を使っている⁵。

そもそも暗号技術用途の乱数生成器は科学技術シミュレーションやゲームで使う擬似乱数生成器とは要件が異なる。

従前の観点から統計的にテストされた乱雑性は、セキュリティ用途に要求される予測困難性と同等ではありません。
例えば、（CRC Standard Mathematical Tables からのランダムテーブルのような）広く利用可能な一定のシーケンスの利用は、攻撃者に対して非常に弱いです。これを学習したり、推測する攻撃者は、容易に（過去・未来を問わず）そのシーケンス [CRC] に基づいて、すべてのセキュリティを破ることができます。他の例として、AES を 1, 2, 3 ... のような連続した整数を暗号化する一定の鍵と共に使うことは、優れた統計的乱雑性をもつが予測可能な出力を作り出します。他方、6 面のサイコロを連続して転がして、その結果の値を ASCII にエンコードすることは、実質的に予測困難なコンポーネントをもちながらも「統計的に貧弱な出力」を作り出します。それゆえ、「統計的テストの合否は、『何かが予測不可能であるか否か、あるいは、予測可能であるか否か』を表さないこと」に注意してください。

RFC 4086 - セキュリティのための乱雑性についての要件より

暗号技術用途の乱数生成器は，暗号分野においては中核技術のひとつであるが，一度に大量の乱数を生成させる必要のある科学技術シミュレーションなどの用途には向かない。上手く使い分けてほしい。

ブックマーク

Go 言語に関するブックマーク集はこちら。

参考図書

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

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

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

暗号技術入門第3版　秘密の国のアリス: 結城浩 (著); SBクリエイティブ 2015-08-25 (Release 2015-09-17); Kindle版; B015643CPE (ASIN); 評価

SHA-3 や Bitcoin/Blockchain など新しい知見や技術要素を大幅追加。暗号技術を使うだけならこれ1冊でとりあえず無問題。

reviewed by Spiegel on 2015-09-20 (powered by PA-APIv5)

ただし github.com/davidminor/gorand/lcg には不具合があって Int63() 関数で負の値を出力する場合がある。とりあえず fork 版の github.com/spiegel-im-spiegel/gorand/lcg で修正している。 Pull request も出したけど，古いコードだし，もうメンテしてないかなぁ。 ↩︎
$2^{19937}-1$ はメルセンヌ素数で Mersenne Twister の名前の由来になっている。 Mersenne Twister では周期サイズごとに複数の実装があるが， $2^{19937}-1$ がポピュラーな実装として広く使われているようだ。 ↩︎
Go 言語におけるオブジェクトの多態性については「Go 言語における「オブジェクト」」を参考にどうぞ。 ↩︎
/dev/urandom はハードウェア・デバイスから十分なエントロピー源が得られない場合は内部で疑似乱数生成器を使用する。このため一時は /dev/urandom の脆弱性が疑われたが，現時点では事実上は問題ないとされている。一方で，スマートデバイスのような場合はハードウェア・デバイスからのエントロピー源だけでは外部から推測され易いため，性能のよい疑似乱数生成器を組み合わせるほうが有効になる場合もあるようだ。 ↩︎
CryptGenRandom 関数の内部実装は公開されていないが，やはりキーボードやマウス等のデバイスの挙動をエントロピー源とし， NIST の SP800-90 勧告に従った実装をしているようである。余談だが SP800-90 は乱数生成の一部のアルゴリズムで脆弱性が発見され（これがまた NSA 絡みだったものだから大騒ぎになった），現在は修正版の SP800-90A Revision 1が発行されている。（参考：擬似乱数生成アルゴリズム Dual_EC_DRBG について） ↩︎

モンテカルロ法による円周率の推定（その3 Gaussian）

2016-11-14T11:50:56+00:00

推定結果の分布

さて，前回書いたコードを利用して，いよいよ円周率の推定結果を評価してみる。

spiegel-im-spiegel/pi: Estimate of Pi with Monte Carlo method.

CLI はこんな感じになった。

$ go run main.go estmt --help
Estimate of Pi with Monte Carlo method.

Usage:
  pi estmt [flags]

Flags:
  -e, --ecount int   Count of estimate (default 100)
  -p, --pcount int   Count of points (default 10000)

Global Flags:
      --config string   config file (default is $HOME/.pi.yaml)

まずは円周率の推定処理を10,000回繰り返してみる。また推定処理のためのランダムな点の数 $n$ を1,000個，10,000個，100,000個と変えて実行してみようか。

$ go run main.go estmt -e 10000 -p 1000 > estmt1k.dat
minimum value: 2.94800
maximum value: 3.31600
average value: 3.14199
standard deviation: 0.05104 (69.9%)

$ go run main.go estmt -e 10000 -p 10000 > estmt10k.dat
minimum value: 3.07240
maximum value: 3.20360
average value: 3.14178
standard deviation: 0.01654 (68.0%)

$ go run main.go estmt -e 10000 -p 100000 > estmt100k.dat
minimum value: 3.12360
maximum value: 3.16184
average value: 3.14163
standard deviation: 0.00518 (68.3%)

最後のはさすがに時間がかかるので，お茶でも飲みながら優雅に待ちましょう（笑）

標準エラー出力に最小値，最大値，平均値（$E$），標準偏差（$\sigma$）を出力してみた。標準偏差の後ろの括弧は $\left[ E-\sigma, E+\sigma \right]$ の範囲にある推定値の割合を示したものだ。

円周率の推定処理の試行回数が十分大きいなら推定値の分布は正規分布（またはガウス分布）に近似できる筈である。（以下の図は Wikimedia Commons のものを拝借した。 CC-BY-2.5 Generic で公開されている）

normal distribution from Wikimedia

そこで $n=100,000$ のときの推定結果についてヒストグラムを描いてみる。幸いなことに gnuplot では簡単にヒストグラムを作図できる。こんな感じ（階級幅を0.001としている）。

gnuplot> filter(x,y)=int(x/y)*y
gnuplot> plot "estmt100k.dat" u (filter($1,0.001)):(1) smooth frequency with boxes lc rgb "black"

gnuplot の出力結果はこんな感じ。

んー。まぁ正規分布っぽい？

もうひとつ，正規確率の分布を調べてみよう。これも gnuplot で描こうと思ったけど，少し面倒そうなので，ズルして以下を参考に LibreOffice の Calc で描くことにした¹。

正規確率プロット（Normal Q-Q Plot）の作成 with Excel

とりあえず結果だけ。

プロットが直線状に並んでいれば正規分布であると言える。図から見る限り，概ね正規分布になっているようである。

しまった。ここまで Go 言語が全然出てこなかった。まぁ，いいや。多分あと1回続きます。

おまけ：誤差評価

モンテカルロ法を使ってどの程度の精度で円周率が求まるかの考察については以下が参考になる。

モンテカルロ法の誤差を考える

これも横着して結果だけを拝借すると， $n=100,000$ で推定を行った場合の値の分布は，中央値を $\pi$，99%信頼区間を $\frac{4.230}{\sqrt{100,000}} = 0.013$ として， $\left[ \pi - 0.013, \pi + 0.013 \right]$ の範囲になるようだ。

おまけの追記：正規確率の分布図について

正規確率の分布図（Q-Q プロット）を描くのに毎回 Excel や Calc を使うのもどうかという気がしたので，こちらのプログラム側であらかじめ計算して，結果のプロット・データを gnuplot に食わせるよう考えてみる。

まず qq サブコマンドを追加し，この qq サブコマンド時にデータファイルを読み込んで Q-Q プロットの計算を行うように CLI を変更する。（ついでに他のオプションも整理した）

$ go run main.go qq --help
make Q-Q plot data.

Usage:
  pi qq [data file] [flags]

Global Flags:
  -p, --pcount int   Count of points (default 10000)

実際の処理部分はこんな感じ。

//Execute output Q-Q plot data.
func Execute(cxt *Context) error {
    scanner := bufio.NewScanner(cxt.ui.Reader())
    pis := make([]float64, 0)
    for scanner.Scan() {
        pi, err := strconv.ParseFloat(scanner.Text(), 64)
        if err != nil {
            return errors.Wrap(err, "invalid data")
        }
        pis = append(pis, pi)
    }
    ecf := float64(len(pis))

    sort.Float64s(pis)
    for i, pi := range pis {
        rank := (float64(i+1) - 0.5) / ecf
        cxt.ui.Outputln(fmt.Sprintf("%v\t%v", qnorm(rank), pi))
    }

    return nil
}

qnorm() 関数は標準正規分布に対する累積分布関数の逆関数の値を返すのだが（Excel の NORM.S.INV 関数相当），Go 言語で書かれた適当なパッケージが見つからなかったので（もしあれば誰か教えて）以下のページのコードを Go 言語用に書き直した。

RangeVoting.org - Java normal distribution calculator II

実際にはこんな感じ²。

//qnorm function refers to http://rangevoting.org/Qnorm.html
// This function is licensed under GNU GPL version 3 or later.
func qnorm(p float64) float64 {
    const (
        split = 0.42
        a0    = 2.50662823884
        a1    = -18.61500062529
        a2    = 41.39119773534
        a3    = -25.44106049637
        b1    = -8.47351093090
        b2    = 23.08336743743
        b3    = -21.06224101826
        b4    = 3.13082909833
        c0    = -2.78718931138
        c1    = -2.29796479134
        c2    = 4.85014127135
        c3    = 2.32121276858
        d1    = 3.54388924762
        d2    = 1.63706781897
    )

    q := p - 0.5
    ppnd := float64(0)
    if math.Abs(q) <= split {
        r := q * q
        ppnd = q * (((a3*r+a2)*r+a1)*r + a0) / ((((b4*r+b3)*r+b2)*r+b1)*r + 1)
    } else {
        r := p
        if q > 0 {
            r = 1 - p
        }
        if r > 0 {
            r = math.Sqrt(-math.Log(r))
            ppnd = (((c3*r+c2)*r+c1)*r + c0) / ((d2*r+d1)*r + 1)
            if q < 0 {
                ppnd = -ppnd
            }
        }
    }
    return ppnd
}

では早速動かしてみよう。

$ go run main.go qq estmt100k.dat > qq100k.dat

生成した qq100k.dat ファイルを gnuplot に食わせる。こんな感じでいいだろう。

gnuplot> unset key
gnuplot> set style line 1 pointsize 0.1 pointtype 7 linecolor rgb "black"
gnuplot> plot "qq100k.dat" linestyle 1

結果はこんな感じ。

ついでにこの分布図にフィットする直線 $y=ax+b$ の $a, b$ 値を調べてみる。

gnuplot> f(x)=a*x+b
gnuplot> fit f(x) "qq100k.dat" via a,b
iter      chisq       delta/lim  lambda   a             b            
   0 5.5761271099e+04  0.00e+00 1.00e+00  1.000000e+00  1.000000e+00
   1 6.0252530865e-04 -9.25e+12 1.00e-01  5.277253e-03  3.141418e+00
   2 4.5071534394e-05 -1.24e+06 1.00e-02  5.177775e-03  3.141632e+00
   3 4.5071534393e-05 -1.23e-06 1.00e-03  5.177775e-03  3.141632e+00
iter      chisq       delta/lim  lambda   a             b            

After 3 iterations the fit converged.
final sum of squares of residuals : 4.50715e-005
rel. change during last iteration : -1.23364e-011

degrees of freedom    (FIT_NDF)                        : 9998
rms of residuals      (FIT_STDFIT) = sqrt(WSSR/ndf)    : 6.71421e-005
variance of residuals (reduced chisquare) = WSSR/ndf   : 4.50806e-009

Final set of parameters            Asymptotic Standard Error
=======================            ==========================
a               = 0.00517777       +/- 6.715e-007   (0.01297%)
b               = 3.14163          +/- 6.714e-007   (2.137e-005%)

correlation matrix of the fit parameters:
                a      b      
a               1.000 
b               0.000  1.000

ここで $a$ が標準偏差， $b$ が平均値にマッチしている点に注目。分布図と上の直線を重ねあわせるとこうなる。

んー。こんなもんかな。

そうそう。 qq サブコマンドは，フィルタとしても機能するので

$ go run main.go estmt -e 100 -p 10000 | go run main.go qq > qq.dat
minimum value: 3.09640
maximum value: 3.18600
average value: 3.14158
standard deviation: 0.01654 (68.0%)

といった感じにパイプでつなぐこともできる。

ブックマーク

Go 言語に関するブックマーク集はこちら。

参考図書

プログラミング言語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)

数学ガール／乱択アルゴリズム: 結城浩 (著); SBクリエイティブ 2011-02-25 (Release 2014-03-12); Kindle版; B00I8AT1FO (ASIN); 評価

工学ガール，リサちゃん登場！

reviewed by Spiegel on 2015-04-19 (powered by PA-APIv5)

数学ガールの秘密ノート／やさしい統計: 結城浩 (著); SBクリエイティブ 2016-10-28 (Release 2016-11-10); Kindle版; B01MSJMKMW (ASIN); 評価

統計の本当に基礎の部分から。学業成績でよく聞く「偏差値」とは何を表していて何を意味しているのか。なんてなあたりから。

reviewed by Spiegel on 2016-12-11 (powered by PA-APIv5)

Calc でも Excel の関数がそのまま使えるようだ。助かる。 ↩︎
余談だが， Go 言語では untyped な定数を設定できる。型が評価されるのは，処理の中でその定数が使われた時点となる。数値の精度も使用時点で評価されるため，定義では大きい桁数の値を設定しても問題ない。（参考： Go の定数の話 - Qiita） ↩︎

モンテカルロ法による円周率の推定（その2 CLI）

2016-11-06T08:57:37+00:00

コマンドライン・インタフェース

さっそく推定結果について評価を行いたいところだが，その前に CLI (command-line interface) を整備する。どういうことかというと，前回作った2つの main() 関数の処理

package main

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

    "github.com/spiegel-im-spiegel/pi/gencmplx"
)

func main() {
    c := gencmplx.New(rand.NewSource(time.Now().UnixNano()), int64(10000))
    for p := range c {
        fmt.Printf("%v\t%v\n", real(p), imag(p))
    }
}

package main

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

    "github.com/spiegel-im-spiegel/pi/gencmplx"
)

func main() {
    c := gencmplx.New(rand.NewSource(time.Now().UnixNano()), int64(100000))
    n := int64(0) // total
    m := int64(0) // plot in circle
    for p := range c {
        n++
        if cmplx.Abs(p) <= float64(1) {
            m++
        }
    }
    fmt.Printf("n = %v, m = %v, 4m/n = %v\n", n, m, float64(4*m)/float64(n))
}

これをひとつの CLI で呼び出せるよう統合してしまおうというわけ。

CLI については以前に解説した。

コマンドライン・インタフェースとファサード・パターン

このときは mitchellh/cli を紹介したが，今回は spf13/cobra を使うことにする。

spf13/cobra パッケージ

spf13/cobra パッケージの作者 spf13 (Steve Francia) さんは Docker の中の人で Hugo の作者としても有名な方。もちろん Hugo の CLI にも spf13/cobra が使われている。

さらにありがたいことに spf13/cobra にはテンプレートコードを出力する CLI も用意されている。インストールは go get コマンドで行う。

$ go get -v github.com/spf13/cobra/cobra

これで spf13/cobra パッケージ本体と CLI がインストールされる。テンプレートコードの生成は以下のコマンドを叩く。

$ cobra init github.com/spiegel-im-spiegel/pi
Your Cobra application is ready at
C:\workspace\pi\src\github.com\spiegel-im-spiegel\pi
Give it a try by going there and running `go run main.go`
Add commands to it by running `cobra add [cmdname]`

既にパッケージ用のフォルダが作られている場合は，そのフォルダまで降りて

$ cobra init .
Your Cobra application is ready at
C:\workspace\pi\src\github.com\spiegel-im-spiegel\pi
Give it a try by going there and running `go run main.go`
Add commands to it by running `cobra add [cmdname]`

でもよい。

この時点で main.go と cmd/root.go のふたつが生成される。

// Copyright © 2016 NAME HERE <EMAIL ADDRESS>
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package main

import "github.com/spiegel-im-spiegel/pi/cmd"

func main() {
    cmd.Execute()
}

// Copyright © 2016 NAME HERE <EMAIL ADDRESS>
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package cmd

import (
    "fmt"
    "os"

    "github.com/spf13/cobra"
    "github.com/spf13/viper"
)

var cfgFile string

// RootCmd represents the base command when called without any subcommands
var RootCmd = &cobra.Command{
    Use:   "pi",
    Short: "A brief description of your application",
    Long: `A longer description that spans multiple lines and likely contains
examples and usage of using your application. For example:

Cobra is a CLI library for Go that empowers applications.
This application is a tool to generate the needed files
to quickly create a Cobra application.`,
// Uncomment the following line if your bare application
// has an action associated with it:
//    Run: func(cmd *cobra.Command, args []string) { },
}

// Execute adds all child commands to the root command sets flags appropriately.
// This is called by main.main(). It only needs to happen once to the rootCmd.
func Execute() {
    if err := RootCmd.Execute(); err != nil {
        fmt.Println(err)
        os.Exit(-1)
    }
}

func init() {
    cobra.OnInitialize(initConfig)

    // Here you will define your flags and configuration settings.
    // Cobra supports Persistent Flags, which, if defined here,
    // will be global for your application.

    RootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is $HOME/.pi.yaml)")
    // Cobra also supports local flags, which will only run
    // when this action is called directly.
    RootCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
}

// initConfig reads in config file and ENV variables if set.
func initConfig() {
    if cfgFile != "" { // enable ability to specify config file via flag
        viper.SetConfigFile(cfgFile)
    }

    viper.SetConfigName(".pi") // name of config file (without extension)
    viper.AddConfigPath("$HOME")  // adding home directory as first search path
    viper.AutomaticEnv()          // read in environment variables that match

    // If a config file is found, read it in.
    if err := viper.ReadInConfig(); err == nil {
        fmt.Println("Using config file:", viper.ConfigFileUsed())
    }
}

この状態でいきなり動かしてみる。

$ go run main.go
A longer description that spans multiple lines and likely contains
examples and usage of using your application. For example:

Cobra is a CLI library for Go that empowers applications.
This application is a tool to generate the needed files
to quickly create a Cobra application.

RootCmd で定義した説明が表示されているのがわかると思う。

次にサブコマンドを定義する。名前は plot と estmt としようか。

$ cobra add plot
plot created at C:\workspace\pi\src\github.com\spiegel-im-spiegel\pi\cmd\plot.go

$ cobra add estmt
estmt created at C:\workspace\pi\src\github.com\spiegel-im-spiegel\pi\cmd\estmt.go

これで cmd/plot.go と cmd/estmt.go のふたつが生成された。 cmd/plot.go の中身を見てみよう。

// Copyright Â© 2016 NAME HERE <EMAIL ADDRESS>
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package cmd

import (
    "fmt"

    "github.com/spf13/cobra"
)

// plotCmd represents the plot command
var plotCmd = &cobra.Command{
    Use:   "plot",
    Short: "A brief description of your command",
    Long: `A longer description that spans multiple lines and likely contains examples
and usage of using your command. For example:

Cobra is a CLI library for Go that empowers applications.
This application is a tool to generate the needed files
to quickly create a Cobra application.`,
    Run: func(cmd *cobra.Command, args []string) {
        // TODO: Work your own magic here
        fmt.Println("plot called")
    },
}

func init() {
    RootCmd.AddCommand(plotCmd)

    // Here you will define your flags and configuration settings.

    // Cobra supports Persistent Flags which will work for this command
    // and all subcommands, e.g.:
    // plotCmd.PersistentFlags().String("foo", "", "A help for foo")

    // Cobra supports local flags which will only run when this command
    // is called directly, e.g.:
    // plotCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")

}

spf13/cobra パッケージで特徴的なのは，サブコマンドを追加する際に cmd/root.go を変更する必要が無いことである。サブコマンドの組み込みは cmd パッケージ内の各ファイルに定義されている init() 関数によって main() 起動前に行われる。

この状態で動かしてみよう。

$ go run main.go
A longer description that spans multiple lines and likely contains
examples and usage of using your application. For example:

Cobra is a CLI library for Go that empowers applications.
This application is a tool to generate the needed files
to quickly create a Cobra application.

Usage:
  pi [command]

Available Commands:
  estmt       A brief description of your command
  plot        A brief description of your command

Flags:
      --config string   config file (default is $HOME/.pi.yaml)
  -t, --toggle          Help message for toggle

Use "pi [command] --help" for more information about a command.

$ go run main.go plot --help
A longer description that spans multiple lines and likely contains examples
and usage of using your command. For example:

Cobra is a CLI library for Go that empowers applications.
This application is a tool to generate the needed files
to quickly create a Cobra application.

Usage:
  pi plot [flags]

Global Flags:
      --config string   config file (default is $HOME/.pi.yaml)

$ go run main.go plot
plot called

問題なくサブコマンドが組み込まれていることがわかる。

CLI の作成

では，生成されたテンプレートをベースに機能を組み込んでいく。 …というわけで，出来上がりが以下の repository にある。

spiegel-im-spiegel/pi: Estimate of Pi with Monte Carlo method.

フォルダ構成は以下の通り。

github.com/spiegel-im-spiegel/pi
|   .editorconfig
|   .gitignore
|   glide.lock
|   glide.yaml
|   LICENSE
|   main.go
|   README.md
|
+---cmd
|       estmt.go
|       plot.go
|       root.go
|
+---estmt
|       estmt.go
|
+---gencmplx
|       gencmplx.go
|
+---genpi
|       genpi.go
|
\---plot
        plot.go

そして各パッケージの構成は以下のようになっている。

パッケージ構成

前回と変わったところは genpi パッケージを追加したことだろうか。こんな感じ。

package genpi

import (
    "math/cmplx"
    "math/rand"
    "time"

    "github.com/spiegel-im-spiegel/pi/gencmplx"
)

//New returns generator of Pi
func New(pc, ec int64) <-chan float64 {
    ch := make(chan float64)
    pcf := float64(pc)
    go func(pc, ec int64) {
        for i := int64(0); i < ec; i++ {
            c := gencmplx.New(rand.NewSource(time.Now().UnixNano()), pc)
            m := int64(0) // plot in circle
            for p := range c {
                if cmplx.Abs(p) <= float64(1) {
                    m++
                }
            }
            ch <- float64(4*m) / pcf
        }
        close(ch)
    }(pc, ec)

    return ch
}

指定した回数だけ推定処理を行い，結果を channel ch に渡している。たとえば100,000個の点から円周率を推定する処理を10回したければ

$ go run main.go estmt -e 10 -p 100000
3.14576
3.1422
3.13716
3.14648
3.14852
3.13952
3.14824
3.13828
3.14532
3.14312

とすればよい。

これでようやく評価のための準備が整った。

ブックマーク

Go 言語に関するブックマーク集はこちら。

参考図書

プログラミング言語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）

2016-11-05T14:26:29+00:00

乱数（random number）についていい例題がないかなぁ，と考えて「円周率をモンテカルロ法で求めるやつやればいいぢゃん」と思いついた。ので早速試してみる。ちなみに「モンテカルロ法」というのは数値計算やシミュレーションに乱数を用いる手法をさす。

モンテカルロ法による円周率の推定

では乱数を使ってどうやって円周率を求めるのか。まずは以下のように原点を中心とした半径 $1$ の円を考える。ただしここでは第一象限のみを対象とする。

そして $0 \le y \le 1$ および $0 \le y \le 1$ の範囲でランダムに点をプロットしていく。（以下の図は Wikimedia Commons のものを拝借した。 CC-BY-3.0 で公開されている）

From Wikimedia Commons

全ての点 $n$ が領域内に均等にプロットされていれば，円の内側に入る点の数 $m$ は，面積比から，以下の式のようになると期待できる。

\[ m \simeq \frac{1}{4}{\pi}n \]

この式を $\pi$ を求める形に変形すると

\[ \pi \simeq \frac{4m}{n} \]

となる。プロットした点が円の内側かどうかは原点からの距離で判定できる。すなわち

\[ \sqrt{x^2 + y^2} \le 1 \]

を満たしていればよい。

math/rand パッケージ

Go 言語にはコア・パッケージとして math/rand が用意されていて，このパッケージを使って擬似乱数を発生させることができる。今回は $0 \le r \le 1.0$ の範囲で乱数を発生させればいいのだが，生憎そのものズバリな関数が用意されていない。たとえば rand.Float64() が吐く値の範囲は $0 \le r \lt 1.0$ なのでそのままでは使えないのだ。

そこで，こんなコードを考えてみる。

package main

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

func main() {
    rand.Seed(time.Now().UnixNano())
    for i := 0; i < 10; i++ {
        fmt.Println(float64(rand.Int63n(10000001)) / float64(10000000))
    }
}

rand.Int63n(n) 関数は $0 \le i \lt n$ の範囲で整数を吐く。 $n=10,000,001$ なら $0 \le i \le 10,000,000$ の範囲になる。これを $10,000,000$ で割って $0 \le r \le 1.0$ の範囲の乱数を作るのである。

実際には2次元座標なので複素数（complex）表現にして

package main

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

func main() {
    rand.Seed(time.Now().UnixNano())
    for i := 0; i < 10; i++ {
        c := complex(float64(rand.Int63n(10000001))/float64(10000000), float64(rand.Int63n(10000001))/float64(10000000))
        fmt.Printf("%v (%v)\n", c, cmplx.Abs(c))
    }
}

とすればよい。ちなみに cmplx.Abs() 関数は複素数の絶対値を取るもので， $\sqrt{x^2 + y^2}$ と同じである。

では，以上を踏まえてランダムな点を生成する gencmplx パッケージを作ってみよう。 channel と goroutine を使ってこんな感じにするかな。

package gencmplx

import "math/rand"

//New returns generator of random complex number
func New(s rand.Source, count int64) <-chan complex128 {
    ch := make(chan complex128)
    r := rand.New(s)
    go func(r *rand.Rand, count int64) {
        for i := int64(0); i < count; i++ {
            ch <- complex(float64(r.Int63n(10000001))/float64(10000000), float64(r.Int63n(10000001))/float64(10000000))
        }
        close(ch)
    }(r, count)
    return ch
}

後々のことを考えて，乱数の rand.Source¹ と生成する点の個数は引数で指定するようにした。

いっぽう， gencmplx パッケージの呼び出し側はこんな感じになる。

package main

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

    "github.com/spiegel-im-spiegel/pi/gencmplx"
)

func main() {
    c := gencmplx.New(rand.NewSource(time.Now().UnixNano()), int64(10000))
    for p := range c {
        fmt.Printf("%v\t%v\n", real(p), imag(p))
    }
}

ここでは少なめに1万個の点を生成している。 channel c からの値の取り出しは for-range 構文を使うと記述がシンプルになり c が close() するまでループしてくれる。

早速これを動かしてみよう。

$ go run main.go > plot-1.dat

これで1万個の点を plot-1.dat に格納したことになる。 plot-1.dat を gnuplot に食わせてみるとこんな感じ。

うーん。均等？なのかなぁ。まぁ，この辺の評価については「その3」以降で。

最後に，生成した点の集合から円周率を推定するところまでやってみよう。 main() 関数はこのように変える。

package main

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

    "github.com/spiegel-im-spiegel/pi/gencmplx"
)

func main() {
    c := gencmplx.New(rand.NewSource(time.Now().UnixNano()), int64(100000))
    n := int64(0) // total
    m := int64(0) // plot in circle
    for p := range c {
        n++
        if cmplx.Abs(p) <= float64(1) {
            m++
        }
    }
    fmt.Printf("n = %v, m = %v, 4m/n = %v\n", n, m, float64(4*m)/float64(n))
}

点の数は10万個まで増やしている。実行結果は

$ go run main2.go
n = 100000, m = 78397, 4m/n = 3.13588

と，まぁそれっぽい値が出てきた。

今回はここまで。

ブックマーク

Go 言語に関するブックマーク集はこちら。

参考図書

プログラミング言語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)

数学ガール／乱択アルゴリズム: 結城浩 (著); SBクリエイティブ 2011-02-25 (Release 2014-03-12); Kindle版; B00I8AT1FO (ASIN); 評価

工学ガール，リサちゃん登場！

reviewed by Spiegel on 2015-04-19 (powered by PA-APIv5)

rand.Source は interface として定義されていて，これを満たす type であれば他の擬似乱数アルゴリズムも使えるようになっている。 ↩︎

List of Circle-Ratio [text.Baldanders.info]

モンテカルロ法による円周率の推定（その4 PRNG）

math/rand の擬似乱数生成器

擬似乱数生成器のバリエーション

線形合同法

Mersenne Twister

擬似乱数生成器を組み込む

暗号技術用途の乱数生成器

ブックマーク

参考図書

モンテカルロ法による円周率の推定（その3 Gaussian）

推定結果の分布

おまけ：誤差評価

おまけの追記： 正規確率の分布図について

ブックマーク

参考図書

モンテカルロ法による円周率の推定（その2 CLI）

コマンドライン・インタフェース

spf13/cobra パッケージ

CLI の作成

ブックマーク

参考図書

モンテカルロ法による円周率の推定（その1）

モンテカルロ法による円周率の推定

math/rand パッケージ

ブックマーク

参考図書

おまけの追記：正規確率の分布図について