List of Recursion [text.Baldanders.info]

最大公約数と関数型プログラミング

2017-09-23T14:32:56+00:00

配列の全ての要素の最大公約数を求める (Java 8, Python) - Qiita

この記事を見て思いついた。そうだ。最大公約数（greatest common divisor）の話をしよう。

最大公約数を求める

まずは定義から。最大公約数の定義は以下の通り。

2つ以上の正の整数に共通な約数（公約数）のうち最大のもの

折角なので何か例題を立ててみよう。

例題1

20 と 32 の最大公約数を求めよ。

簡単な数だし，まずは暗算で解いてみる。それぞれの値を素因数分解すると以下のようになる。

\begin{align*} 20 &= 2^2 \times 5 \\ 32 &= 2^5 \end{align*}

これにより最大公約数は $2^2 = 4$ だということが分かる。簡単でよかったね。

ユークリッドの互除法

さて，最大公約数を求める機械向けの計算方法としては「ユークリッドの互除法」が有名である。具体的な手順は以下の通り。

32 を 20 で割った余りは 12
20 を 12 で割った余りは 8
12 を 8 で割った余りは 4
8 を 4 で割った余りは 0
したがって 32 と 20 の最大公約数は 4 である

これを図形で表すとこんな感じになる。（以下の図は Wikipedia のものを拝借した。 CC-BY-SA-3.0 で公開されている）

From Wikipedia

今回はユークリッドの互除法の証明は割愛するとして¹，上記の手順の 1 から 4 は再帰処理になっていることが分かる。というわけで，こんな感じのコードを組んでみる。（だいぶ端折ったコードでゴメン）

package main

import "fmt"

func gcd(a, b int) int {
    if b == 0 {
        return a
    }
    return gcd(b, a%b)
}

func main() {
    fmt.Println(gcd(32, 20)) // 4
}

これで実行結果は 4 になる。

実は Go 言語にも最大公約数を求める関数が標準パッケージ math/big に用意されている。こんな感じで使える。

package main

import (
    "fmt"
    "math/big"
)

func gcd(m, n uint64) uint64 {
    x := new(big.Int)
    y := new(big.Int)
    z := new(big.Int)
    a := new(big.Int).SetUint64(m)
    b := new(big.Int).SetUint64(n)
    return z.GCD(x, y, a, b).Uint64()
}

func main() {
    fmt.Println(gcd(20, 32)) // 4
}

big.Int.GCD() 関数もユークリッドの互除法の一種で，正の整数 $a$, $b$ に対する最大公約数を $\mathrm{gcd}(a, b)$ とすると

\[ \mathrm{gcd}(a, b) = ax + by \]

となる $x$, $y$ の組み合わせを探すものだ。

3つ以上の数の最大公約数

では3つ以上の数の最大公約数を求めるにはどうすればいいか。ちょっと考えれば分かるが，たとえば $a$, $b$, $c$ の最大公約数を求めたいなら $\mathrm{gcd}(\mathrm{gcd}(a, b), c)$ とすればいい。

では例題を立ててみよう。これは「配列の全ての要素の最大公約数を求める」の設問と同等と言える。

例題2

(290021904, 927964716, 826824516, 817140688) の最大公約数を求めよ。

まずはベタに for 文を回してベタに解いてみる。

package main

import (
    "fmt"
    "math/big"
)

func gcd(m, n uint64) uint64 {
    x := new(big.Int)
    y := new(big.Int)
    z := new(big.Int)
    a := new(big.Int).SetUint64(m)
    b := new(big.Int).SetUint64(n)
    return z.GCD(x, y, a, b).Uint64()
}

func main() {
    values := []uint64{290021904, 927964716, 826824516, 817140688}

    z := values[0]
    for _, n := range values {
        z = gcd(n, z)
    }
    fmt.Println(z) // 92
}

ふむふむ。イケてそうだな²。

Go で関数型プログラミング

「配列の全ての要素の最大公約数を求める」で紹介されているコードは高階関数（higher-order function）である reduce() による関数型プログラミングになっている。

Go 言語の関数は第一級関数（first-class function）なので関数型っぽいプログラミングも可能なのだが³， reduce() のような関数は標準では用意されていない。ただし，似たような機能を持つパッケージを公開しておられる人はいる。わざわざ自作するのもナニなので今回は以下のパッケージを利用させてもらおう。

robpike/filter: Simple apply/filter/reduce package.

これを使って先程の例題を以下のコードで解くことができる。

package main

import (
    "fmt"
    "math/big"

    "github.com/robpike/filter"
)

func gcd(m, n uint64) uint64 {
    x := new(big.Int)
    y := new(big.Int)
    z := new(big.Int)
    a := new(big.Int).SetUint64(m)
    b := new(big.Int).SetUint64(n)
    return z.GCD(x, y, a, b).Uint64()
}

func main() {
    values := []uint64{290021904, 927964716, 826824516, 817140688}

    fmt.Println(filter.Reduce(values, gcd, 1).(uint64)) // 92
}

もしくは gcd() 関数自体を引数に組み込んで

package main

import (
    "fmt"
    "math/big"

    "github.com/robpike/filter"
)

func main() {
    values := []uint64{290021904, 927964716, 826824516, 817140688}

    fmt.Println(filter.Reduce(values,
        func(m, n uint64) uint64 {
            x := new(big.Int)
            y := new(big.Int)
            z := new(big.Int)
            a := new(big.Int).SetUint64(m)
            b := new(big.Int).SetUint64(n)
            return z.GCD(x, y, a, b).Uint64()
        },
        1).(uint64)) // 92
}

としてもよい。ほら，これなら「実質的にワンライナー」と呼べないこともない（笑）

robpike/filter パッケージの作者も書いておられるが

I wanted to see how hard it was to implement this sort of thing in Go, with as nice an API as I could manage. It wasn't hard.

Having written it a couple of years ago, I haven't had occasion to use it once. Instead, I just use "for" loops.

You shouldn't use it either.

via robpike/filter

filter.Reduce() 関数を駆動するコストを考えれば⁴ 普通に for 文で回したほうが安上がりだよね。イマドキっぽく関数型言語の利点をいくつか取り込んでいるとはいえ Haskell のようなガッツリした関数型言語とは役割が異なるので，無理に関数型にこだわらなくてもいいということである。

ブックマーク

参考図書

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

改訂2版みんなのGo言語: 松木雅幸 (著), mattn (著), 藤原俊一郎 (著), 中島大一 (著), 上田拓也 (著), 牧大輔 (著), 鈴木健太 (著); 技術評論社 2019-08-01 (Release 2019-08-01); Kindle版; B07VPSXF6N (ASIN); 評価

改訂2版の目玉は7章の「データベースの扱い方」が追加されたことだろう。他の章では，大まかな構成は1版と同じだが細かい部分が変わっていて Go 1.12 への言及まであるのには驚いた。

reviewed by Spiegel on 2019-08-12 (powered by PA-APIv5)

数学ガールの秘密ノート／整数で遊ぼう: 結城浩 (著); SBクリエイティブ 2013-12-17 (Release 2014-07-24); Kindle版; B00L0PDMJ0 (ASIN); 評価

小中学生にお薦め。小学生高学年くらいならギリで理解可能と思われ。

reviewed by Spiegel on 2014-09-26 (powered by PA-APIv5)

数学ガール／フェルマーの最終定理: 結城浩 (著); SBクリエイティブ 2008-07-29 (Release 2014-03-12); Kindle版; B00I8AT1CM (ASIN); 評価

「フェルマーの最終定理」というサブタイトルをみたとき「なんちう大風呂敷を広げるねん」と思ったものだが，実際に読んでみるとぐいぐい引き込まれる。ひっさびさに頭を使ったような気がする。

reviewed by Spiegel on 2019-01-13 (powered by PA-APIv5)

結城浩さんが連載しておられる「数学ガールの秘密ノート」にユークリッドの互除法が出て来る。はやく本にならないかなぁ。 ↩︎
繰り返し処理が1回余分に回っているが $gcd(a, a) = a$ で影響はないのでご容赦。 ↩︎
あくまでも「ぽい」である。たとえば Go 言語では if 文や for 文などは関数でも演算子でもない単なる制御構文（stateement）であり，直接ロジックにコンパイルされる。これまでの手続き型言語と関数型言語の利点を合わせたような言語は「マルチパラダイム・プログラミング言語（multiparadigm programming language）」などと呼ばれたりする。 Python や Swift といった近頃流行りの言語もマルチパラダイムの流れのひとつである。 ↩︎
Go 言語には総称型（Generics）がないため filter.Reduce() 関数内部で reflect パッケージを駆使することになるが，その分はどうしてもパフォーマンスに影響を与えてしまう（参考：きみは Generics がとくいなフレンズなんだね，または「制約は構造を生む」）。しかし reflect パッケージが悪というわけではなく，たとえば先日紹介した sort.Slice() 関数は reflect パッケージを効果的に使用した例といえる。高階関数は見た目はクールだが，それに惑わされることなく目的に適うコードを選ぶことが重要である。とはいえ，勉強のために Go 言語で高階関数を組んでみようというのは悪くないと思う。 ↩︎

再帰呼び出しと関数テーブル

2016-01-18T13:59:07+00:00

今回は再帰呼び出しの話。

再帰呼び出しのサンプルとして典型的なのはフィボナッチ数かな。フィボナッチ数の定義を愚直にコードにするとこんな感じになる。

package main

import "fmt"

func fibonacciNumber(n int) int {
    switch n {
    case 0:
        return 0
    case 1:
        return 1
    default:
        return fibonacciNumber(n-2) + fibonacciNumber(n-1)
    }
}

func main() {
    fmt.Println(fibonacciNumber(40))
}

一般に手続き型言語は再帰呼び出しに弱いと言われている（関数型のほうが有利）。特に Go 言語の場合は goroutine に最適化を割り振っている関係で，関数呼び出しやその戻り¹ のパフォーマンスが冷遇されているようだ。したがって，再帰呼び出し部分のパフォーマンスを改善したければ，なるべく呼び出し回数を減らすようにするのがコツである。たとえば上のフィボナッチ数の場合は

package main

import "fmt"

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

func main() {
    fmt.Println(fibonacciNumber(40, make(map[int]int)))
}

という感じに計算結果を保持っておくことでかなり改善する。

ところで，再帰呼び出しで怖いのが無限呼び出しに陥るパターンである。 Go 言語では関数値（function value）を介す場合であれば再帰呼び出しを禁止する。

たとえば先ほどのコードを以下のように書き換えてみる。

package main

import "fmt"

var fibonacciNumbers = make(map[int]int)

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

type ff func(int) int

var fib ff = fibonacciNumber

func main() {
    fmt.Println(fib(40))
}

fibonacciNumber() を fib() で別名定義しているだけだが，これを実行しようとすると以下のコンパイルエラーになる。

prog.go:25: initialization loop:
    prog.go:25 fib refers to
    prog.go:7 fibonacciNumber refers to
    prog.go:25 fib

関数値 fib の部分でエラーになっている点に注目してほしい。

本当に「ついうっかり」再帰呼び出しになってしまう場合はエラーではじいてもらってありがたいのだが，そうでない場合もある。あまり例示がうまくなくて申し訳ないのだが，以下の簡単なステート・マシンを考えてみる。

package main

import "fmt"

func f0(evt int) int {
    fmt.Println("processing f0")
    return 1
}

func f1(evt int) int {
    fmt.Println("processing f1")
    return 2
}

func f2(evt int) int {
    fmt.Println("processing f2")
    return 3
}

func f3(evt int) int {
    fmt.Println("processing f3")
    return 0
}

type fn func(int) int

var fs = []fn{
    f0,
    f1,
    f2,
    f3,
}

func StateMachin(stat, evt int) int {
    return fs[stat](evt)
}

func main() {
    s := 0
    for e := 0; e < 10; e++ {
        s = StateMachin(s, e)
        if s == 0 {
            break
        }
    }
    fmt.Println("end")
}

fs が関数テーブルになっていて，状態 s とイベント e に対する処理 fs[s](e) を呼び出して処理後の状態を返してもらう。一応 StateMachine() 関数で詳細を隠蔽しているつもりである²。

ここで StateMachine(3, evt) の処理に続けて StateMachine(1, evt) の処理がしたくなり

func f3(evt int) int {
    fmt.Println("processing f3")
    return StateMachin(1, evt)
}

などと書いたらどうなるか。もちろんこれもコンパイルエラーになる。

prog.go:32: initialization loop:
    prog.go:32 fs refers to
    prog.go:20 f3 refers to
    prog.go:34 StateMachin refers to
    prog.go:32 fs

しかし実際には f3 を無限に呼び出しているわけではないので，このコンパイルエラーでは困ってしまう³。このエラーを回避するには関数テーブル fs を介さなければよい。たとえば

var fs = []fn{
    f0,
    f1,
    f2,
    //f3,
}

func StateMachin(stat, evt int) int {
    if stat == 3 {
        return f3(evt)
    }
    return fs[stat](evt)
}

とすれば，めでたく f1 → f2 → f3 → f1 とエンドレスにつながる。ちなみにここでうっかり

func f3(evt int) int {
    fmt.Println("processing f3")
    return StateMachin(3, evt)
}

などと書くと，コンパイルエラーにもならず無限呼び出しが発生する。

再帰呼び出しは計画的に。

ブックマーク

Goで再帰使うと遅くなりますがそれが何だ - YAMAGUCHI::weblog
.\hoge.go:7: initialization loop - Qiita
Fibonacci exercise (go tour) - Qiita
Golangでゴルーチンにより再帰関数を並列処理 : 再帰処理を goroutine で並行処理するという業なコード。 goroutine が大量発生して面白い

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

再帰呼び出しが「末尾呼び出し（tail call）」の場合は，戻りの最適化でパフォーマンスの向上が期待できるが， Go 言語のコンパイラはこの辺の最適化も行っていないらしい。 ↩︎
実際には別パッケージにしてちゃんとクラス設計すべきだろうけど色々端折っている。ゴメンペコン。 ↩︎
このコードに限れば StateMachine(1, evt) ではなく f1(evt) を呼び出せば済む話なのでこれは言いがかりであるが，「話の都合」ということで軽く流していただけるとありがたい。 ↩︎