List of Slice [text.Baldanders.info]

Go 1.21.0 がリリースされた

2023-08-09T04:58:32+00:00

予定通り8月に Go 1.21.0 がリリースされた。

お気づきだろうか。今回のバージョン番号は 1.21 ではなく 1.21.0 なのですよ。これからは2月8月の初期リリースでも後ろにちゃんと 1.xx.0 って付けるんだってさ。これで Go の機械的なバージョン管理がしやすくなると思う。

Windows 7, 8, Server 2008, Server 2012 サポート終了のお知らせ

1.21 からは Windows 10 および Windows Server 2016 が最低要件となる。それより前の Windows バージョンに対応するには 1.20 系が必要。それでも2024年2月でサポートが終わるんだよな。

log/slog パッケージ

個人的に最大のトピックはこれ。 log/slog 構造化ログパッケージが追加されたこと。これでサードパーティの logger も log/slog パッケージの下に統合されることを期待したい。

ログなんて「詳細」ですよ。偉い人には分からんのです。

min/max 組み込み関数

多分，他の言語の人には「今までなかったんかい！」ってツッコまれるんだろうなぁ。マジでなかったんスよ。つか，いわゆる Generics が導入されてようやく実現したというか。

slices, maps, cmp パッケージ

slices, maps, cmp 各パッケージの追加も Generics 導入の恩恵だよね。何せ，今までは配列要素の反転（reverse）でさえ自前で

func reverse(s []int) {
    for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
        s[i], s[j] = s[j], s[i]
    }
}

プログラミング言語Goより

てな感じに書いてたんだぜ。クールだろ（笑）

こうやって Go の標準ライブラリのイケてないところが徐々に解消されていくといいねぇ。 math/rand/v2 のプロポーザルとか見てても，着々と Go 2 に進んでる気がする。

例によって…

Ubuntu の APT で管理している Go コンパイラは古いので，ダウンロードページからバイナリ（go1.21.0.linux-amd64.tar.gz）を取ってきてインストールすることを強く推奨する。以下は完全手動での作業例。

$ cd /usr/local/src
$ sudo curl -L "https://go.dev/dl/go1.21.0.linux-amd64.tar.gz" -O
$ cd ..
$ sudo unlink go # 以前の Go が入っている場合
$ sudo tar xvf src/go1.21.0.linux-amd64.tar.gz
$ sudo mv go go1.21.0
$ sudo ln -s go1.21.0 go
$ go version # /usr/local/go/bin にパスが通っている場合
go version go1.21.0 linux/amd64

Windows は Scoop 経由で OK

複数バージョンの Go コンパイラを扱いたい場合は

$ go install golang.org/dl/go1.21.0@latest
$ go1.21.0 download
$ go1.21.0 version
go version go1.21.0 linux/amd64

てな感じで導入できる。

アップデートは計画的に。

ブックマーク

（随時追加予定）

公式の構造化 Logger (になるかもしれない) slog パッケージ

参考図書

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

初めてのGo言語 ―他言語プログラマーのためのイディオマティックGo実践ガイド: Jon Bodner (著), 武舎広幸 (翻訳); オライリージャパン 2022-09-26; 単行本（ソフトカバー）; 4814400047 (ASIN), 9784814400041 (EAN), 4814400047 (ISBN); 評価

2021年に出た “Learning Go” の邦訳版。私は版元で PDF 版を購入。 Go 特有の語法（idiom）を切り口として Go の機能やパッケージを解説している。 Go 1.19 対応。

reviewed by Spiegel on 2022-10-11 (powered by PA-APIv5)

実用 Go言語 ―システム開発の現場で知っておきたいアドバイス: 渋川よしき (著), 辻大志郎 (著), 真野隼記 (著); オライリージャパン 2022-04-22; 単行本（ソフトカバー）; 4873119693 (ASIN), 9784873119694 (EAN), 4873119693 (ISBN); 評価

版元のデジタル版を購入。 Go で躓きやすい点を解説していくのが最初の動機らしい。「◯◯するには」を調べる際にこの本を調べるといいかも。

reviewed by Spiegel on 2022-10-26 (powered by PA-APIv5)

Go言語による並行処理: Katherine Cox-Buday (著), 山口能迪 (翻訳); オライリージャパン 2018-10-26; 単行本（ソフトカバー）; 4873118468 (ASIN), 9784873118468 (EAN), 4873118468 (ISBN); 評価

Eブック版もある。感想はこちら。 Go 言語で並行処理を書くならこの本は必読書になるだろう。

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

Go言語による分散サービス ―信頼性、拡張性、保守性の高いシステムの構築: Travis Jeffery (著), 柴田芳樹 (翻訳); オライリージャパン 2022-08-03; 単行本（ソフトカバー）; 4873119979 (ASIN), 9784873119977 (EAN), 4873119979 (ISBN); 評価

版元でデジタル版を購入。読書会の課題図書。ハンズオンぽい構成でコードがたくさん書かれているのがよい。

reviewed by Spiegel on 2022-08-03 (powered by PA-APIv5)

Goならわかるシステムプログラミング第2版: 渋川よしき (著), ごっちん (イラスト); ラムダノート 2022-03-23; 単行本（ソフトカバー）; 4908686122 (ASIN), 9784908686122 (EAN), 4908686122 (ISBN); 評価

第1版はとてもためになる内容だったので第2版も PDF 版で確保しておく。

reviewed by Spiegel on 2022-10-08 (powered by PA-APIv5)

デベロッパーゴースーパーゴラン Tシャツ: Geek Go Super Golang Tees; ウェア&シューズ; B09C2XBC2F (ASIN); 評価

ついカッとなってポチった。反省はしない

reviewed by Spiegel on 2022-04-10 (powered by PA-APIv5)

#shimanego より：配列とスライスとソート

2020-02-13T13:43:11+00:00

今月も Shimane.go#04 に参加して図々しくもまた喋ってきた。以下にそのとき使ったスライドを公開しておく。

配列とスライスとソート | slide.Baldanders.info

ターゲットとしては “A Tour of Go” をひととおり終わらせて「なんとなく」 Go が分かってきたかなぁ，という感じの人。さすが松江は「お膝元」なので Ruby 経験者は多いが Go には馴染みのない人が多いようなので。

実はソートの速度とかベンチマークを取ってやろうかとも考えたのだが，いい感じのデータが作れず（ただのランダムなデータ列ならいくらでも作れるけど，多分そうじゃない），諦めた。いい方法を考えたらそのうちブログ記事にするかも。

たぶん Go 言語で引っかかりやすいのは interface と slice だと思う。 “interface の slice” とか最凶ダッグである（笑）ちうわけで slice 周りで「あれ？」と思ったらこのスライドのことも思い出してあげてください。

まぁでも，やっぱ座学は退屈だよねぇ。プログラムは書いてナンボだし。なんか面白い遊びを提示できればいいんだけど。

ブックマーク

参考図書

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

CSV/TSV データの読み書き

2018-10-13T20:41:02+00:00

今回は小ネタ。以下の記事を見て，思いつきで書いてみる。

tsvファイルの入出力を簡単にする技

「Python ならこんなに簡単に書けるのに Go 言語で書いたらワケワカメだよ」という，まぁよくある DIS り記事なのだが，関数型言語に慣れている人から見ると Go 言語が標準で提供しているコンテナ操作のアレコレはまだるっこしい感じに見えると思う。

特に配列や連想配列については zip/unzip や map のような標準的で気の利いた高階関数は用意されておらず，頑張って汎用パッケージを作ってみたところで実用的なパフォーマンスが得られずに打ち捨てられてしまうのがオチのようである。

リンク先の例にしても，結局 Go 言語では for 文で回していかざるを得ないのだから連想配列に格納するという発想自体を捨ててしまったほうが得策である。

というわけで，手遊びで書いてみた。

GitHub - spiegel-im-spiegel/csvtable: Demonstration for CSV/TSV Access

CSV/TSV は要するに行・列の2次元配列なんだから，以下のクラスを作って連想配列ではなく普通の配列で管理する。

//CsvTable is CSV/TSV table class
type CsvTable struct {
    header []string
    col    map[string]int
    body   [][]string
}

その上でデータの読み込み時にヘッダの列名とカラム位置の関係を col フィールドに保持ってしまえばいいのである。

//New returns new CsvTable instance
func New(r *csv.Reader) (*CsvTable, error) {
    ct := &CsvTable{}
    err := ct.readAll(r)
    return ct, err
}

func (ct *CsvTable) readAll(r *csv.Reader) error {
    if ct == nil {
        ct = &CsvTable{}
    }
    ct.col = map[string]int{}

    dt, err := r.ReadAll()
    if err != nil {
        return err
    }
    l := len(dt)
    if l > 0 {
        ct.header = dt[0]
        for i, e := range ct.header {
            ct.col[e] = i
        }

        if l > 1 {
            ct.body = dt[1:]
        }
    }
    return nil
}

main 側は以下のようになる。

package main

import (
    "encoding/csv"
    "flag"
    "fmt"
    "io"
    "os"
    "strings"

    "github.com/spiegel-im-spiegel/csvtable"
)

func main() {
    flag.Parse()
    if flag.NArg() > 1 {
        fmt.Fprintln(os.Stderr, os.ErrInvalid)
        return
    }
    var r io.Reader
    if flag.NArg() == 0 {
        r = os.Stdin
    } else {
        f, err := os.Open(flag.Arg(0)) //maybe file path
        if err != nil {
            fmt.Fprintln(os.Stderr, err)
            return
        }
        defer f.Close()
        r = f
    }

    cr := csv.NewReader(r)
    cr.Comma = '\t'
    cr.LazyQuotes = true       // a quote may appear in an unquoted field and a non-doubled quote may appear in a quoted field.
    cr.TrimLeadingSpace = true // leading white space in a field is ignored.

    ct, err := csvtable.New(cr)
    if err != nil {
        fmt.Fprintln(os.Stderr, err)
        return
    }
    //fmt.Println("cols :", ct.Cols())
    //fmt.Println("rows :", ct.Rows())
    w := csv.NewWriter(os.Stdout)
    w.Comma = cr.Comma
    //w.UseCRLF = true
    //header, body := ct.OutputAll()
    header, body := ct.Output(strings.Split("city/temperature", "/"))
    w.Write(header)
    w.WriteAll(body)
}

念の為このパッケージの欠点を挙げておくと， CSV/TSV ファイルの内容の総てを一旦メモリ内に読み込んでいるため，巨大データを扱えないという問題がある。実際問題として CSV/TSV データは数万行から数十万行の規模になることもザラにあるため，このままでは全く実用に耐えられないだろう。

ブックマーク

参考図書

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

配列と Slice

2017-03-14T15:31:48+00:00

以下の記事を見て思わず膝を打った。

Goのarrayとsliceを理解するときがきた - Qiita

なるほど！こういう風に説明すればいいのか。というわけで，私も便乗してみる。あくまでも私のための覚え書きである。

配列は常に「値」である

まずはこんなコードを書いてみる。

package main

import "fmt"

type Array4 [4]int8

func main() {
    ary := Array4{0, 1, 2, 3}
    fmt.Printf("ary = %p\n", &ary)
    for i := 0; i < len(ary); i++ {
        fmt.Printf("%p: %v\n", &ary[i], ary[i])
    }
}

[4]int8 が「型」であることを意識してもらうために敢えて Array4 という型を宣言している。実行結果は以下の通り。

ary = 0x10410020
0x10410020: 0
0x10410021: 1
0x10410022: 2
0x10410023: 3

まぁ分かりやすいよね。今度はダンプ表示部分を別関数にしてみる。

package main

import "fmt"

type Array4 [4]int8

func dumpA(ary Array4) {
    fmt.Printf("dump(ary) = %p\n", &ary)
    for i := 0; i < len(ary); i++ {
        fmt.Printf("%p: %v\n", &ary[i], ary[i])
    }
}

func main() {
    ary := Array4{0, 1, 2, 3}
    fmt.Printf("ary = %p\n", &ary)
    dumpA(ary)
}

このコードの実行結果は以下の通り。

ary = 0x10410020
dump(ary) = 0x10410040
0x10410040: 0
0x10410041: 1
0x10410042: 2
0x10410043: 3

dumpA() 関数の引数として渡される配列（のポインタ）がオリジナルのものと異なることが分かるだろう。 Go 言語では関数の引数は原則として「値渡し（call by value）」であるため，配列を渡す場合でも配列のコピーを作って渡すことになる。配列の値（＝コピー）を渡すのではなく配列の実体を渡すにはポインタを使う。

package main

import "fmt"

type Array4 [4]int8

func dumpA(ary *Array4) {
    fmt.Printf("dump(ary) = %p\n", ary)
    for i := 0; i < len(ary); i++ {
        fmt.Printf("%p: %v\n", &ary[i], ary[i])
    }
}

func main() {
    ary := Array4{0, 1, 2, 3}
    fmt.Printf("ary = %p\n", &ary)
    dumpA(&ary)
}

結果は以下の通り。

ary = 0x10410020
dump(ary) = 0x10410020
0x10410020: 0
0x10410021: 1
0x10410022: 2
0x10410023: 3

slice は配列を参照するオブジェクトである

次は配列を slice に置き換えてみよう。

package main

import "fmt"

func dumpS(slc []int8) {
    fmt.Printf("dump(slc) = %p\n", slc)
    for i := 0; i < len(slc); i++ {
        fmt.Printf("%p: %v\n", &slc[i], slc[i])
    }
}

func main() {
    slc := []int8{0, 1, 2, 3}
    fmt.Printf("slc = %p\n", slc)
    dumpS(slc)
}

配列の場合の記述の違いが分かるだろうか。この場合 slc には配列 {0, 1, 2, 3} へのポインタがセットされる。したがって dumpS() 関数の引数には（見かけ上）配列 {0, 1, 2, 3} への参照がセットされていることになる。

slc = 0x10410020
dump(slc) = 0x10410020
0x10410020: 0
0x10410021: 1
0x10410022: 2
0x10410023: 3

では応用として今度はこんなコードを考えてみよう。

package main

import "fmt"

type Array4 [4]int8

func dumpS(slc []int8) {
    fmt.Printf("dump(slc) = %p\n", slc)
    for i := 0; i < len(slc); i++ {
        fmt.Printf("%p: %v\n", &slc[i], slc[i])
    }
}

func main() {
    ary := Array4{0, 1, 2, 3}
    fmt.Printf("ary = %p\n", &ary)
    slc := ary[:]
    dumpS(slc)
}

slc := ary[:] で配列 ary が slice slc にキャストされているのがポイントである。実行結果は以下の通り。

aary = 0x10410020
dump(slc) = 0x10410020
0x10410020: 0
0x10410021: 1
0x10410022: 2
0x10410023: 3

配列 ary のオリジナルのポインタ値がそのまま slc の配列への参照値になっているのが分かると思う。これを踏まえると以下の面白いコードも書ける。

package main

import "fmt"

type Array4 [4]int8

func dumpA(ary *Array4) {
    fmt.Printf("dump(ary) = %p\n", ary)
    for i := 0; i < len(ary); i++ {
        fmt.Printf("%p: %v\n", &ary[i], ary[i])
    }
}

func dumpS(slc []int8) {
    fmt.Printf("dump(slc, sz, cap) = %p, %d, %d\n", slc, len(slc), cap(slc))
    for i := 0; i < len(slc); i++ {
        fmt.Printf("%p: %v\n", &slc[i], slc[i])
    }
}

func main() {
    ary := Array4{0, 1, 2, 3}
    dumpA(&ary)
    slc1 := ary[0:2]
    dumpS(slc1)
    slc2 := slc1[0:4]
    dumpS(slc2)
}

サイズ 2 の slc1 からサイズ4の slc2 を取得しているのがポイント。このコードの実行結果は以下の通り。

ddump(ary) = 0x10410020
0x10410020: 0
0x10410021: 1
0x10410022: 2
0x10410023: 3
dump(slc, sz, cap) = 0x10410020, 2, 4
0x10410020: 0
0x10410021: 1
dump(slc, sz, cap) = 0x10410020, 4, 4
0x10410020: 0
0x10410021: 1
0x10410022: 2
0x10410023: 3

実は slice は配列に対するポインタとサイズと容量の3つの属性を持つオブジェクトである。上述のコードでは配列 ary のサイズが反映されて slc1 の容量が4となるため slc2 ではサイズ4の slice を作ることができるわけだ。

ここで，たとえば slc1 := ary[2:4] と書き換えると

package main

import "fmt"

type Array4 [4]int8

func dumpA(ary * Array4) {
    fmt.Printf("dump(ary) = %p\n", ary)
    for i := 0; i < len(ary); i++ {
        fmt.Printf("%p: %v\n", &ary[i], ary[i])
    }
}

func dumpS(slc []int8) {
    fmt.Printf("dump(slc, sz, cap) = %p, %d, %d\n", slc, len(slc), cap(slc))
    for i := 0; i < len(slc); i++ {
        fmt.Printf("%p: %v\n", &slc[i], slc[i])
    }
}

func main() {
    ary := Array4{0, 1, 2, 3}
    dumpA(&ary)
    slc1 := ary[2:4]
    dumpS(slc1)
    slc2 := slc1[0:4]
    dumpS(slc2)
}

slc1 の容量が変わるため，以下のように実行時 panic になる。

dump(ary) = 0x10410020
0x10410020: 0
0x10410021: 1
0x10410022: 2
0x10410023: 3
dump(slc, sz, cap) = 0x10410022, 2, 2
0x10410022: 2
0x10410023: 3
panic: runtime error: slice bounds out of range

このように配列と slice の関係が分かると append() 関数の挙動も理解しやすくなる。

【追記】 たとえば，配列 ary := Array4{0, 1, 2, 3} の先頭2要素を slice として切り出す場合，普通は ary[0:2] でいいのだが，容量を含めて2要素のみとしたい場合は ary[0:2:2] と記述する。

package main

import "fmt"

type Array4 [4]int8

func dumpS(slc []int8) {
    fmt.Printf("dumpS(slc, sz, cap) = %p, %d, %d\n", slc, len(slc), cap(slc))
    for i := 0; i < len(slc); i++ {
        fmt.Printf("%p: %v\n", &slc[i], slc[i])
    }
}

func main() {
    ary := Array4{0, 1, 2, 3}
    slc1 := ary[0:2:2]
    dumpS(slc1)
}

このコードの実行結果は以下の通り。

dumpS(slc, sz, cap) = 0x10414020, 2, 2
0x10414020: 0
0x10414021: 1

ary[0:2:2] の3番目の要素は（容量の）サイズではなくインデックス値である点に注意。たとえば ary の2番目と3番目の要素を切り出そうとして ary[1:3:2] などと書くとコンパイルエラーになる。

invalid slice index: 3 > 2

ところで先ほど slice は「ポインタとサイズと容量の3つの属性を持つオブジェクト」と書いた。つまり厳密に言えば，関数の引数に slice をセットするということは「ポインタとサイズと容量の3つの属性を持つオブジェクト」を値渡しでセットしているということになる。たとえば以下のようなコードを考える。

package main

import "fmt"

func dumpS(slc []int8) {
    fmt.Printf("dump(slc) = %p\n", slc)
    for i := 0; i < len(slc); i++ {
        fmt.Printf("%p: %v\n", &slc[i], slc[i])
    }
}

func addS(slc []int8, e int8) {
    slc = append(slc, e)
    dumpS(slc)
}

func main() {
    slc := make([]int8, 4, 8)
    slc[0] = 0
    slc[1] = 1
    slc[2] = 2
    slc[3] = 3
    dumpS(slc)
    addS(slc, 4)
    dumpS(slc)
    slc2 := slc[0:5]
    dumpS(slc2)
}

杜撰なコードではあるが，サイズ4容量8の配列に5番目の要素を append() しても内部の配列そのものは更新されないため動きとしては問題ないように見える。しかし実際には以下のような実行結果になる。

dump(slc) = 0x10410020
0x10410020: 0
0x10410021: 1
0x10410022: 2
0x10410023: 3
dump(slc) = 0x10410020
0x10410020: 0
0x10410021: 1
0x10410022: 2
0x10410023: 3
0x10410024: 4
dump(slc) = 0x10410020
0x10410020: 0
0x10410021: 1
0x10410022: 2
0x10410023: 3
dump(slc) = 0x10410020
0x10410020: 0
0x10410021: 1
0x10410022: 2
0x10410023: 3
0x10410024: 4

つまり addS() 関数に渡す slc は値渡しなので addS() 関数内で slc のサイズが変わっても関数の呼び出し元には反映されないことになる（ただし配列自体には値がセットされている）。 append() 関数実行後は必ず状態が変わるため正しく slice の「値」を更新する必要がある。

配列の複製と比較

Go 言語では配列は値であるため，代入時に自動的に複製が発生する。また同じ型であれば == 演算子で配列の内容を比較できる。

package main

import "fmt"

type Array4 [4]int8

func dumpA(ary *Array4) {
    fmt.Printf("dump(ary) = %p\n", ary)
    for i := 0; i < len(ary); i++ {
        fmt.Printf("%p: %v\n", &ary[i], ary[i])
    }
}

func main() {
    ary := Array4{0, 1, 2, 3}
    var ary2 Array4
    dumpA(&ary)
    ary2 = ary
    dumpA(&ary2)
    if ary == ary2 {
        fmt.Println("ary == ary2")
    } else {
        fmt.Println("ary != ary2")
    }
}

実行結果は以下の通り。

dump(ary) = 0x10410020
0x10410020: 0
0x10410021: 1
0x10410022: 2
0x10410023: 3
dump(ary) = 0x10410024
0x10410024: 0
0x10410025: 1
0x10410026: 2
0x10410027: 3
ary == ary2

ただし配列の型が異なる場合（たとえば [3]int8 と [4]int8）は単純比較はできないので注意が必要である。

slice の複製と比較

一方， slice は配列のポインタを属性値として持っているだけなので代入を行っても配列自体は複製されない。 slice の複製が欲しい場合は copy() 関数を使う。

package main

import "fmt"

func dumpS(slc []int8) {
    fmt.Printf("dump(slc) = %p\n", slc)
    for i := 0; i < len(slc); i++ {
        fmt.Printf("%p: %v\n", &slc[i], slc[i])
    }
}

func main() {
    slc1 := []int8{0, 1, 2, 3}
    dumpS(slc1)
    slc2 := make([]int8, len(slc1), cap(slc1))
    copy(slc2, slc1)
    dumpS(slc2)
}

コピー先の slc2 について make() 関数であらかじめサイズと容量を確保しておくのがポイント。実行結果は以下の通り。

dump(slc) = 0x10410020
0x10410020: 0
0x10410021: 1
0x10410022: 2
0x10410023: 3
dump(slc) = 0x10410024
0x10410024: 0
0x10410025: 1
0x10410026: 2
0x10410027: 3

なお slice インスタンス同士は == 演算子による比較ができない。

package main

import "fmt"

func dumpS(slc []int8) {
    fmt.Printf("dump(slc) = %p\n", slc)
    for i := 0; i < len(slc); i++ {
        fmt.Printf("%p: %v\n", &slc[i], slc[i])
    }
}

func main() {
    slc1 := []int8{0, 1, 2, 3}
    dumpS(slc1)
    slc2 := make([]int8, len(slc1), cap(slc1))
    copy(slc2, slc1)
    dumpS(slc2)
    if slc1 == slc2 {
        fmt.Println("slc1 == slc2")
    } else {
        fmt.Println("slc1 != slc2")
    }
}

とやっても

prog.go:18:10: invalid operation: slc1 == slc2 (slice can only be compared to nil)

という感じでコンパイルエラーになる¹。

slice の内容を比較したいのであれば reflect.DeepEqual() 関数が使える²。

package main

import (
    "fmt"
    "reflect"
)

func dumpS(slc []int8) {
    fmt.Printf("dump(slc) = %p\n", slc)
    for i := 0; i < len(slc); i++ {
        fmt.Printf("%p: %v\n", &slc[i], slc[i])
    }
}

func main() {
    slc1 := []int8{0, 1, 2, 3}
    dumpS(slc1)
    slc2 := make([]int8, len(slc1), cap(slc1))
    copy(slc2, slc1)
    dumpS(slc2)
    if reflect.DeepEqual(slc1, slc2) {
        fmt.Println("slc1 == slc2")
    } else {
        fmt.Println("slc1 != slc2")
    }

}

とすれば以下の結果になる。

dump(slc) = 0x10410020
0x10410020: 0
0x10410021: 1
0x10410022: 2
0x10410023: 3
dump(slc) = 0x10410024
0x10410024: 0
0x10410025: 1
0x10410026: 2
0x10410027: 3
slc1 == slc2

需要があるかどうか分からないが， slice が参照している配列のインスタンスが同一であるかどうか調べるには reflect.ValueOf() 関数で値（＝配列）を取得し，そのポインタ値を == 演算子で比較する。

package main

import (
    "fmt"
    "reflect"
)

func dumpS(slc []int8) {
    fmt.Printf("dump(slc) = %p\n", slc)
    for i := 0; i < len(slc); i++ {
        fmt.Printf("%p: %v\n", &slc[i], slc[i])
    }
}

func main() {
    slc1 := []int8{0, 1, 2, 3}
    dumpS(slc1)
    slc2 := make([]int8, len(slc1), cap(slc1))
    copy(slc2, slc1)
    dumpS(slc2)
    if reflect.ValueOf(slc1).Pointer() == reflect.ValueOf(slc2).Pointer() {
        fmt.Println("slc1 == slc2")
    } else {
        fmt.Println("slc1 != slc2")
    }
    slc3 := slc1
    dumpS(slc3)
    if reflect.ValueOf(slc1).Pointer() == reflect.ValueOf(slc3).Pointer() {
        fmt.Println("slc1 == slc3")
    } else {
        fmt.Println("slc1 != slc3")
    }
}

結果は以下の通り。

dump(slc) = 0x10410020
0x10410020: 0
0x10410021: 1
0x10410022: 2
0x10410023: 3
dump(slc) = 0x10410024
0x10410024: 0
0x10410025: 1
0x10410026: 2
0x10410027: 3
slc1 != slc2
dump(slc) = 0x10410020
0x10410020: 0
0x10410021: 1
0x10410022: 2
0x10410023: 3
slc1 == slc3

slice のポインタ値を比較すればいいぢゃん，と思うかもしれないが，その場合は単に slice インスタンスが同一かどうかを比較しているに過ぎない。

package main

import "fmt"

func dumpS(slc []int8) {
    fmt.Printf("dump(slc) = %p\n", slc)
    for i := 0; i < len(slc); i++ {
        fmt.Printf("%p: %v\n", &slc[i], slc[i])
    }
}

func main() {
    slc1 := []int8{0, 1, 2, 3}
    dumpS(slc1)
    slc2 := slc1
    dumpS(slc2)
    if &slc1 == &slc2 {
        fmt.Println("&slc1 == &slc2")
    } else {
        fmt.Println("&slc1 != &slc2")
    }
}

なので，結果は以下の通り。

dump(slc) = 0x10410020
0x10410020: 0
0x10410021: 1
0x10410022: 2
0x10410023: 3
dump(slc) = 0x10410020
0x10410020: 0
0x10410021: 1
0x10410022: 2
0x10410023: 3
&slc1 != &slc2

【2023-08-10 追記】 slices 標準パッケージを使う

Go 1.21 から slices 標準パッケージが追加された。これは slice の操作を Generics を使って定義したもので，たとえば slice の複製や比較を行うメソッドは

// Clone returns a copy of the slice.
// The elements are copied using assignment, so this is a shallow clone.
func Clone[S ~[]E, E any](s S) S {
    // Preserve nil in case it matters.
    if s == nil {
        return nil
    }
    return append(S([]E{}), s...)
}

// Equal reports whether two slices are equal: the same length and all
// elements equal. If the lengths are different, Equal returns false.
// Otherwise, the elements are compared in increasing index order, and the
// comparison stops at the first unequal pair.
// Floating point NaNs are not considered equal.
func Equal[S ~[]E, E comparable](s1, s2 S) bool {
    if len(s1) != len(s2) {
        return false
    }
    for i := range s1 {
        if s1[i] != s2[i] {
            return false
        }
    }
    return true
}

といった感じに定義されている。これを使えば前節のコードは

package main

import (
    "fmt"
    "reflect"
    "slices"
)

func dumpS(slc []int8) {
    fmt.Printf("dump(slc) = %p\n", slc)
    for i := 0; i < len(slc); i++ {
        fmt.Printf("%p: %v\n", &slc[i], slc[i])
    }
}

func main() {
    slc1 := []int8{0, 1, 2, 3}
    dumpS(slc1)
    slc2 := slices.Clone(slc1)
    dumpS(slc2)
    if reflect.ValueOf(slc1).Pointer() == reflect.ValueOf(slc2).Pointer() {
        fmt.Println("slc1.Pointer == slc2.Pointer")
    } else {
        fmt.Println("slc1.Pointer != slc2.Pointer")
    }
    if slices.Equal(slc1, slc2) {
        fmt.Println("slc1 == slc2")
    } else {
        fmt.Println("slc1 != slc2")
    }
}

てな感じに書き直すことができる。これを実行すると

dump(slc) = 0xc000012028
0xc000012028: 0
0xc000012029: 1
0xc00001202a: 2
0xc00001202b: 3
dump(slc) = 0xc000012050
0xc000012050: 0
0xc000012051: 1
0xc000012052: 2
0xc000012053: 3
slc1.Pointer != slc2.Pointer
slc1 == slc2

といった出力になる。 slices.Clone() 関数によって新たにコピーが生成されているのが確認できるだろう。また slices.Equal() 関数が配列の内容（値）を比較している点にも注目してほしい。

ブックマーク

参考図書

プログラミング言語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言語 ―他言語プログラマーのためのイディオマティックGo実践ガイド: Jon Bodner (著), 武舎広幸 (翻訳); オライリージャパン 2022-09-26; 単行本（ソフトカバー）; 4814400047 (ASIN), 9784814400041 (EAN), 4814400047 (ISBN); 評価

reviewed by Spiegel on 2022-10-11 (powered by PA-APIv5)

同様に比較演算子が使えない基本型としては map と関数値（function value）がある。 ↩︎
byte 型の slice であれば bytes.Compare() を使って比較できる。 ↩︎

「ズンドコチェック」なるものが流行っているらしい

2016-03-12T13:12:53+00:00

Javaの講義、試験が「自作関数を作り記述しなさい」って問題だったから
「ズン」「ドコ」のいずれかをランダムで出力し続けて「ズン」「ズン」「ズン」「ズン」「ドコ」の配列が出たら「キ・ヨ・シ！」って出力した後終了って関数作ったら満点で単位貰ってた
— てくも (@kumiromilk) 2016年3月9日

「習作（study）」としてはなかなか秀逸なアイデアだと思う。これで満点くれる教官も流石だが（笑）巷では「ズンドコキヨシ」とか「キヨシチェック」とか「ズンドコチェック」とか呼ばれているらしい。

というわけで

「ズン」「ドコ」のいずれかをランダムで出力し続けて「ズン」「ズン」「ズン」「ズン」「ドコ」の配列が出たら「キ・ヨ・シ！」って出力した後終了って関数

を Go 言語で実装することを考えてみる。私はコレを「ズンドコ・コール（zundoko-choir）」と呼ぶことにする。

とはいえ，ズンドコ・コールを実装する事自体はそう難しくない。たとえばこんな感じ。

package main

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

const (
    zun     = "ズン"
    doko    = "ドコ"
    kiyoshi = "キ・ヨ・シ！"
)

func generate() chan string {
    ch := make(chan string)
    go func() {
        var zundoko = [2]string{zun, doko}
        rand.Seed(time.Now().UnixNano())
        for {
            ch <- zundoko[rand.Intn(2)]
        }
    }()
    return ch
}

func main() {
    zundoko := generate()
    zcount := 0
    for {
        zd := <-zundoko
        fmt.Print(zd)
        if zd == zun {
            zcount++
        } else if zcount >= 4 {
            break
        } else {
            zcount = 0
        }
    }
    fmt.Print(kiyoshi)
}

「ズン」および「ドコ」をランダムに生成する部分は channel と goroutine を使えばいいだろう（generate() 関数内の処理）。擬似乱数は厳密でなくてもいいので安直に math/rand を使うことにした¹。さらに「ズン」「ズン」「ズン」「ズン」「ドコ」の配列パターンのチェックだが，「ズン」が4回以上連続で来た直後に「ドコ」が来たら OK としてみた。まぁ，これがもっとも素朴な実装でパフォーマンスとしてもそれほど遜色ない筈。

と，ここまで考えてハタと気づいた。問題は「自作関数を作り記述しなさい」なんだからメイン関数にロジック書いたらアカンやん！

というわけでまたもゴリゴリとコードを書いてパッケージにしてしまった。アホだ，私（笑）

spiegel-im-spiegel/zundoko: Zundoko-choirs

出力は標準出力に直書きするのではなく string の slice に append() することで実現する。この出力先を Choirs 型として定義した。

//Choirs - zundoko-choirs list
type Choirs struct {
    c []string
}

//Push is append choirs
func (c *Choirs) Push(s string) {
    c.c = append(c.c, s) //maybe panic if c is nil.
}

func (c *Choirs) String() string {
    if c == nil {
        return ""
    }
    content := make([]byte, 0, 128)
    for _, s := range c.c {
        content = append(content, s...)
    }
    return string(content)
}

ちなみに文字列の連結は strings.Join() 関数は使わず「文字列連結はどれが速い？」で紹介した方法を使っている。

これで最初のコードは

func generate() chan string {
    ch := make(chan string)
    go func() {
        var zd = [2]string{Zun, Doko}
        rand.Seed(time.Now().UnixNano())
        for {
            ch <- zd[rand.Intn(2)]
        }
    }()
    return ch
}

//Run zundoko-choirs
func Run() *Choirs {
    zd := generate()
    c := &Choirs{make([]string, 0)}
    zcount := 0
    for {
        s := <-zd
        c.Push(s)
        if s == Zun {
            zcount++
        } else if zcount >= 4 {
            break
        } else {
            zcount = 0
        }
    }
    c.Push(Kiyoshi)
    return c
}

と書き換えることができる。このパッケージを呼び出すメイン側は例えば

package main

import (
    "fmt"

    "github.com/spiegel-im-spiegel/zundoko"
)

func main() {
    c := zundoko.Run()
    fmt.Println(c)
}

と書けばいい。

ところで「ズン」「ドコ」の出力は Choirs 型で保持られているので，末尾の5要素のパターンを調べる別の方法もあると気づく。たとえばこんな感じ。

var matchingPattern = []string{Zun, Zun, Zun, Zun, Doko}

func (c *Choirs) match() bool {
    if c == nil {
        return false
    }
    if len(c.c) < 5 {
        return false
    }
    return reflect.DeepEqual(c.c[len(c.c)-5:], matchingPattern)
}

この関数を使えば Run() 関数は

//Run2 zundoko-choirs (another logic)
func Run2() *Choirs {
    zd := generate()
    c := &Choirs{make([]string, 0)}
    for {
        s := <-zd
        c.Push(s)
        if c.match() {
            break
        }
    }
    c.Push(Kiyoshi)
    return c
}

となり随分すっきりする。ただこれコストが高くつきそうである。というわけで，これも調べてみた。まず以下のベンチマークを書く。

package zundoko

import "testing"

func BenchmarkRun1(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Run()
    }
}

func BenchmarkRun2(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Run2()
    }
}

BenchmarkRun1 が従来のもの， BenchmarkRun2 が先程の match() 関数を使ったバージョンである。結果は以下のとおり。

$ go test -bench Run -benchmem
testing: warning: no tests to run
PASS
BenchmarkRun1-4    50000     28141 ns/op    1800 B/op     9 allocs/op
BenchmarkRun2-4    30000     40102 ns/op    3912 B/op   115 allocs/op
ok      github.com/spiegel-im-spiegel/zundoko   4.261s

乱数の要素が絡むので毎回同じ値ではないが，傾向としてはこんな感じ。 BenchmarkRun2 のほうが allocation 回数が圧倒的に多いのが分かるだろう。これがスピードにもダイレクトに反映されている感じである。

今回は「「ズン」が4回以上連続で来た直後に「ドコ」が来たら OK」という単純なロジックだったが，もっと複雑なパターンが要求される場合は工夫が必要かもしれない²。

「ズン」と「ドコ」の出現回数を数える関数も作ってみた。

//CountZunDoko returns count of "ZUN" and "DOKO" choirs
func (c *Choirs) CountZunDoko() (int, int) {
    z := 0
    d := 0
    if c == nil {
        return z, d
    }
    for _, s := range c.c {
        switch s {
        case Zun:
            z++
        case Doko:
            d++
        }
    }
    return z, d
}

たとえば generate() 関数内で使っている擬似乱数パッケージを別のものに換えた時に統計処理で簡単な性能評価ができるかもしれない。今回はそこまではしなけど（擬似乱数の話はいずれやりたい）。

こうやって手遊びでコードを弄るのは楽しいものである。

ブックマーク

ズンドコキヨシまとめ - Qiita
ズンドコキヨシ with Go (n番煎じ) - Qiita
ズンドコキヨシGolang並列版 - Qiita : 「ズン」「ドコ」の生成部分を CPU の数だけ並列処理で行わせてひとつの channel に入力するというユニークな実装
「ズンドコキヨシ」と擬似乱数 - Qiita : Qiita で擬似乱数について簡単にまとめてみた。整理できたらこちらでも記事にするかも

参考図書

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

math/rand の乱数生成アルゴリズムの既定は線形合同法らしい。線形合同法は性能が良くなくゲームや暗号等では使えない。math/rand の乱数生成アルゴリズムは他のものに入れ替えることができる。たとえば seehuhn/mt19937 パッケージが使える。 ↩︎
たとえば container/list や container/ring といったパッケージを使う手がある。 ↩︎

素数探索アルゴリズムで遊ぶ

2015-09-17T12:23:42+00:00

（初出：はじめての Go 言語 (on Windows) その2 - Qiita）

Go 言語は公式のドキュメントがとても充実していて（ただしほぼ英語だけど），私のような初学者に易しい環境といえる。

Documentation - The Go Programming Language : 言語仕様に関するドキュメントはこちら（一部日本語化されている）
Packages - The Go Programming Language : 標準パッケージのドキュメントはこちら（一部日本語化されている）

とはいえ，コードが実際にどのように機能するかは書いてみないと分からない部分もある。なので，今回からは実際にコードを書きながら言語の癖のようなものを調べていくことにする。仕事に使うなら厳密な評価が必要だけど，今のところはそんな予定もないし，まずはテキトーで（笑）

早速，みんな大好き素数探索アルゴリズムで遊ぶ。

素数の定義

一応，素数（prime number）の定義を以下に示す。

1 と自分自身以外に正の約数を持たない 1 より大きい自然数

ここで自然数（natural number）は「ペアノの公理」に従う（0 が自然数に含まれるかどうかについては色々あるみたいだが，素数の定義には影響がないので，ここでは無視する）。

ちなみに結城浩さんの『数学ガール／ゲーデルの不完全性定理』にペアノの公理について分かりやすく解説した章がある。お勧め。

素数探索アルゴリズム（その1）

素数の定義を愚直にコードで表すなら以下のようになる。

package main

import (
    "fmt"
    "time"
)

func main() {
    max := 100
    primes := make([]int64, 0) // 素数のリスト

    start := time.Now() //Start
    for n := 2; n <= max; n++ {
        flag := true
        for m := 2; m < n; m++ {
            if (n % m) == 0 { // n が m で割り切れる → 素数ではない
                flag = false
                break
            }
        }
        if flag {
            primes = append(primes, int64(n)) // 素数を追加
        }
    }
    goal := time.Now() //Goal
    fmt.Printf("%v 以下の素数: %v\n", max, primes)
    fmt.Printf("%v 経過", goal.Sub(start)) //経過時間を表示
}

実行結果はこんな感じ。

C:>go run prime01.go
100 以下の素数: [2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97]
0 経過

この値を覚えておいてね。検算に使うから。

素数探索アルゴリズム（その2: エラトステネスの篩の変形）

もう少しだけ効率的に素数を探すアルゴリズムとして「エラトステネスの篩」と呼ばれる方法がある。コードで書くとこんな感じ。

package main

import (
    "fmt"
    "time"
)

func main() {
    max := 100
    primes := make([]int64, 0)        // 素数のリスト
    isNotPrime := make([]bool, max+1) // false で初期化される（全てを素数候補とする）
    isNotPrime[0] = true              // 0 は非素数
    isNotPrime[1] = true              // 1 は非素数

    start := time.Now() //Start
    n := 2
    for ; n*n <= max; n++ { // √max まで篩にかける
        if !isNotPrime[n] { // n は素数
            primes = append(primes, int64(n)) // 素数を追加
            for m := 2; n*m <= max; m++ {
                isNotPrime[n*m] = true // max 以下の n の倍数を全て非素数とする
            }
        }
    }
    for ; n <= max; n++ {
        if !isNotPrime[n] { // n は素数
            primes = append(primes, int64(n)) // 素数を追加
        }
    }
    goal := time.Now() //Goal
    fmt.Printf("%v 以下の素数: %v\n", max, primes)
    fmt.Printf("%v 経過", goal.Sub(start)) //経過時間を表示
}

C:>go run prime01b.go
100 以下の素数: [2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97]
0 経過

割り算がない。ブラボー！

ただし「エラトステネスの篩」は決まった範囲を探索するものなので少々使いづらい。しかも掛け算を使うので大きな数を探索するのには向いていない。そこで「エラトステネスの篩」で使われている以下の素数の特徴を最初のアルゴリズムに加えてみる。

2 以上の全ての自然数はひとつ以上の素数の積で構成される（この素数の集合を素因数（prime factor）という）。したがってある数が素数か否かの判定は，その数より小さい素数のみで調べればよい
更に，積の可換則（commutative property あるいは交換法則）により，自然数 $n$ が素数か否か判定する場合は $\sqrt{n}$ 以下の素数で調べればよい
（たとえば 35 の素因数は 5 と 7 だが， $5 \times 7 = 7 \times 5 = 35$ なので，直前の素数 31 まで回さずとも 3 および 5 ($\le \sqrt{35}$) まで調べれば判定できる）
素数の定義から 2 が素数であることは自明なので（1 と 2 の間に自然数は存在しない）， 2 より大きい 2 の倍数（すなわち偶数）については判定しなくてもよく，対象となる自然数は 3 以上の奇数のみでいいことになる。

では，この特徴を加えたコードを書いてみよう。

package main

import (
    "fmt"
    "math"
    "time"
)

func main() {
    primes := make([]int64, 1)     // 素数のリスト
    primes_f := make([]float64, 1) // 素数のリスト（浮動小数点へのキャスト）
    primes[0] = 2                  // 2 は素数
    primes_f[0] = 2.0              // 2 は素数（浮動小数点）
    var max int64 = 100

    start := time.Now() // Start
    var n int64 = 3
    for n = 3; n < max; n += 2 { // 3 から始まる奇数のみを探索
        flag := true
        f := float64(n)                    // 浮動小数点に cating
        rf := math.Sqrt(f)                 // n に対して √n をとる
        for i := 1; i < len(primes); i++ { // 2 より大きい既知の素数でチェックする
            if primes_f[i] > rf { // n に対して √n 以下の素数まで探索すればよい
                break
            } else if (n % primes[i]) == 0 { // n が既知の素数で割り切れる → 素数ではない
                flag = false
                break
            }
        }
        if flag {
            primes = append(primes, n)     // 素数を追加
            primes_f = append(primes_f, f) // 素数を追加（浮動小数点）
        }
    }
    goal := time.Now() // Goal
    fmt.Printf("%v 以下の素数: %v\n", max, primes)
    fmt.Printf("%v 経過", goal.Sub(start)) // 経過時間を表示
}

実行結果はこんな感じ。

C:>go run prime02.go
100 以下の素数: [2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97]
0 経過

slice と make() と append()

コード中

primes := make([]int64, 1)     // 素数のリスト
primes_f := make([]float64, 1) // 素数のリスト（浮動小数点へのキャスト）
primes[0] = 2                  // 2 は素数
primes_f[0] = 2.0              // 2 は素数（浮動小数点）

の変数 primes および primes_f は slice と呼ばれる可変長の配列型である。更に組み込み関数 make() は slice, map, channel のみ使用可能なメモリ割り当て関数である。ちなみに slice, map, channel 以外は new() を使う。 slice, map, channel のみ特別なのは，これらの型は初期値と内部状態を持つためである。

slice に要素を追加する場合は append() 関数を使えばいいのだが，これが結構クセがある。 append() 関数では slice の容量（capacity）がいっぱいになると新たにメモリを確保してオリジナルの内容をコピーする。つまりポインタが変わってしまうのだ。（メモリの割り当て方のパターンにも注目）

package main

import "fmt"

func main() {
    a := make([]int, 0)                                         // 空の配列を用意
    fmt.Printf("Slice(%02d) : %p : %v (%v)\n", 0, a, a, cap(a)) // 配列の表示（初期状態）
    for num := 1; num <= 17; num++ {
        a = append(a, num)                                            //配列要素の追加
        fmt.Printf("Slice(%02d) : %p : %v (%v)\n", num, a, a, cap(a)) //配列の表示
    }
}

C:>go run slice.go
Slice(00) : 0x5cebb8 : [] (0)
Slice(01) : 0xc082002340 : [1] (1)
Slice(02) : 0xc082002380 : [1 2] (2)
Slice(03) : 0xc082006740 : [1 2 3] (4)
Slice(04) : 0xc082006740 : [1 2 3 4] (4)
Slice(05) : 0xc0820083c0 : [1 2 3 4 5] (8)
Slice(06) : 0xc0820083c0 : [1 2 3 4 5 6] (8)
Slice(07) : 0xc0820083c0 : [1 2 3 4 5 6 7] (8)
Slice(08) : 0xc0820083c0 : [1 2 3 4 5 6 7 8] (8)
Slice(09) : 0xc082050000 : [1 2 3 4 5 6 7 8 9] (16)
Slice(10) : 0xc082050000 : [1 2 3 4 5 6 7 8 9 10] (16)
Slice(11) : 0xc082050000 : [1 2 3 4 5 6 7 8 9 10 11] (16)
Slice(12) : 0xc082050000 : [1 2 3 4 5 6 7 8 9 10 11 12] (16)
Slice(13) : 0xc082050000 : [1 2 3 4 5 6 7 8 9 10 11 12 13] (16)
Slice(14) : 0xc082050000 : [1 2 3 4 5 6 7 8 9 10 11 12 13 14] (16)
Slice(15) : 0xc082050000 : [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15] (16)
Slice(16) : 0xc082050000 : [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16] (16)
Slice(17) : 0xc082056000 : [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17] (32)

容量が変化するごとにポインタ値も変化していることがお分かりだろうか。

ちなみに Go コンパイラは，返値を無視するコーディングに対してエラーを吐く。

a = append(a, num)

の部分を

append(a, num)

とすると

C:>go run prime02.go
# command-line-arguments
.\slice.go:9: append(a, num) evaluated but not used

とエラーになる。

また，容量はあらかじめ指定できる。

a := make([]int, 0)

の部分を

a := make([]int, 0, 32)

とすると

C:>go run slice.go
Slice(00) : 0xc082050000 : [] (32)
Slice(01) : 0xc082050000 : [1] (32)
Slice(02) : 0xc082050000 : [1 2] (32)
Slice(03) : 0xc082050000 : [1 2 3] (32)
Slice(04) : 0xc082050000 : [1 2 3 4] (32)
Slice(05) : 0xc082050000 : [1 2 3 4 5] (32)
Slice(06) : 0xc082050000 : [1 2 3 4 5 6] (32)
Slice(07) : 0xc082050000 : [1 2 3 4 5 6 7] (32)
Slice(08) : 0xc082050000 : [1 2 3 4 5 6 7 8] (32)
Slice(09) : 0xc082050000 : [1 2 3 4 5 6 7 8 9] (32)
Slice(10) : 0xc082050000 : [1 2 3 4 5 6 7 8 9 10] (32)
Slice(11) : 0xc082050000 : [1 2 3 4 5 6 7 8 9 10 11] (32)
Slice(12) : 0xc082050000 : [1 2 3 4 5 6 7 8 9 10 11 12] (32)
Slice(13) : 0xc082050000 : [1 2 3 4 5 6 7 8 9 10 11 12 13] (32)
Slice(14) : 0xc082050000 : [1 2 3 4 5 6 7 8 9 10 11 12 13 14] (32)
Slice(15) : 0xc082050000 : [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15] (32)
Slice(16) : 0xc082050000 : [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16] (32)
Slice(17) : 0xc082050000 : [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17] (32)

となる。メモリ割り当ては意外に高コストの操作なので， slice を扱う場合はこの辺がチューニング・ポイントになるだろう。

100万個目の素数

上のコードを少し修正して $x$ 個目の素数を調べることにしよう。

package main

import (
    "flag"
    "fmt"
    "math"
    "os"
    "strconv"
    "time"
)

func main() {
    //コマンドライン引数の解析
    algno := flag.Int("alg", 0, "0: Basic algorithm , 1: Sieve of Eratosthenes")
    flag.Parse()
    args := flag.Args()
    if *algno < 0 || *algno > 1 {
        fmt.Fprintln(os.Stderr, os.ErrInvalid)
        return
    }
    if len(args) != 1 {
        fmt.Fprintln(os.Stderr, os.ErrInvalid)
        return
    }
    max, err := strconv.ParseInt(args[0], 10, 64)
    if err != nil {
        fmt.Fprintln(os.Stderr, err)
        return
    }
    if max <= 0 {
        max = 1
    }

    //素数探索
    prime := int64(0)
    start := time.Now() // Start
    switch *algno {
    case 1:
        prime = LastPrimeE(max)
    default:
        prime = LastPrimeB(max)
    }
    goal := time.Now()                       // Goal
    fmt.Printf("%v 個目の素数: %v\n", max, prime) // max 個目の素数
    fmt.Printf("%v 経過\n", goal.Sub(start))   // 経過時間を表示
}

func LastPrimeB(max int64) int64 {
    count := int64(0)

    for n := int64(2); ; n++ {
        flag := true
        for m := int64(2); m < n; m++ {
            if (n % m) == 0 { // n が m で割り切れる → 素数ではない
                flag = false
                break
            }
        }
        if flag {
            count++
            if count >= max {
                return n
            }
        }
    }
}

func LastPrimeE(max int64) int64 {
    if max <= 1 {
        return 2
    }
    primes := make([]int64, 1, max)     // 素数のリスト
    primes_f := make([]float64, 1, max) // 素数のリスト（浮動小数点へのキャスト）
    primes[0] = 2                       // 2 は素数
    primes_f[0] = 2.0                   // 2 は素数（浮動小数点）

    count := int64(1)
    for n := int64(3); ; n += 2 { // 3 から始まる奇数のみを探索
        flag := true
        f := float64(n)                    // 浮動小数点に cating
        rf := math.Sqrt(f)                 // n に対して √n をとる
        for i := 1; i < len(primes); i++ { // 2 より大きい既知の素数でチェックする
            if primes_f[i] > rf { // n に対して √n 以下の素数まで探索すればよい
                break
            } else if (n % primes[i]) == 0 { // n が既知の素数で割り切れる → 素数ではない
                flag = false
                break
            }
        }
        if flag {
            count++
            if count >= max {
                return n
            }
            primes = append(primes, n)     // 素数を追加
            primes_f = append(primes_f, f) // 素数を追加（浮動小数点）
        }
    }
}

今後のためにコマンドライン解析の部分と実際の素数探索アルゴリズムを分けている。まず検算。 25個目の素数が 97 なら OK。

C:>go run prime03.go -alg=0 25
25 個目の素数: 97
0 経過

C:>go run prime03.go -alg=1 25
25 個目の素数: 97
0 経過

では実際に動かしてみよう。まずは「その1」のアルゴリズムから。

C:>go run prime03.go -alg=0 100
100 個目の素数: 541
0 経過

C:>go run prime03.go -alg=0 10000
10000 個目の素数: 104729
4.4072521s 経過

100万個目の素数は有意の時間で見つかりませんでした orz

次に「その2」のアルゴリズムで。

C:>go run prime03.go --alg=1 100
100 個目の素数: 541
0 経過

C:>go run prime03.go --alg=1 10000
10000 個目の素数: 104729
7.0004ms 経過

C:>go run prime03.go --alg=1 1000000

1000000 個目の素数: 15485863
4.9042805s 経過

C:>go run prime03.go --alg=1 10000000
10000000 個目の素数: 179424673
2m13.8686568s 経過

というわけで，100万個目の素数探索に5秒弱，1000万個目の素数探索に2分ちょっとかかってしまった。まぁ，でも，こんなもんか。

素数探索アルゴリズム（その3: エラトステネスの篩を並行処理で）

これまでのアルゴリズムは基本的に2重のループで値を順番に付き合わせているだけだったが，この部分を並行処理で行えば速いんじゃね？と思うよね。

Go 言語で並行処理を行うには goroutine（「ゴルーチン」と読むらしい）を使う。また goroutine の worker 間ではメモリ共有ができないため， channel を使い message-passing 方式¹で通信を行う。

で，実際にチュートリアルには並行処理を使った素数探索アルゴリズムが紹介されている²。いくつかサイトを巡ったが，このやり方がもっとも素直なようだ（後述するが速いわけではない）。そこで，このコードを流用させてもらうことにした。

func LastPrimeE2(max int64) int64 {
    if max <= 1 {
        return 2 // 最初の素数は2
    }

    count := int64(1)
    primes := sieve()
    for {
        prime := <-primes
        count++
        if count >= max {
            return prime
        }
    }
}

// 素数候補の数を生成する
func generate() chan int64 {
    ch := make(chan int64)
    go func() {
        for n := int64(3); ; n += 2 { // 3 以降の奇数を送信（2 以外の偶数は素数ではない）
            ch <- n
        }
    }()
    return ch
}

// 素数 'prime' に対するフィルタ
// 'prime' で割り切れない値のみ通過可能
func filter(in chan int64, prime int64) chan int64 {
    out := make(chan int64)
    go func() {
        for {
            n := <-in
            if (n % prime) != 0 {
                out <- n
            }
        }
    }()
    return out
}

// エラトステネスの篩
func sieve() chan int64 {
    out := make(chan int64)
    go func() {
        ch := generate()
        for {
            prime := <-ch
            out <- prime
            ch = filter(ch, prime)
        }
    }()
    return out
}

そうそう。 Go 言語では関数は全て関数閉包（closure）として機能する。

main 関数も少しいじって -alg=2 でこのアルゴリズムを起動するようにする。まずは検算ね。

C:>go run prime04.go -alg=2 25
25 個目の素数: 97
0 経過

じゃあ，早速うごかしてみよっか。

C:>go run prime04.go -alg=2 100
100 個目の素数: 541
2.0002ms 経過

C:>go run prime04.go -alg=2 10000
10000 個目の素数: 104729
4.2002402s 経過

100万個目の素数は有意の時間で見つかりませんでした orz

まぁアルゴリズム的に「篩」っぽくはあるんだけどね。

ある値が素数であると判定されるためには，その値より小さい全ての素数フィルタを通過しなければならない（つまり「その2」で紹介した特徴の2番目を全く生かせていない）。これが致命的。しかもこのフィルタ処理 filter() は素数フィルタの生成も兼ねていて，前の素数フィルタの出力を次の素数フィルタの入力として連結しているのでスキップできない。

かなりインチキではあるけど，捜索範囲を「100万個目」までと限定し，「100万個目」の素数が 15,485,863 であると分かっているならもう少し速くできるかもしれない。つまり以下のように改良する。

func LastPrimeE2(max int64) int64 {
    if max <= 1 {
        return 2 // 最初の素数は2
    }

    count := int64(1)
    primes := sieve()
    for prime := range primes {
        count++
        if count >= max {
            return prime
        }
    }
    return count
}

// 素数候補の数を生成する
// ただし上限を 15485863 とする
func generate() chan int64 {
    ch := make(chan int64)
    go func() {
        for n := int64(3); n <= 15485863; n += 2 { // 3 以降の奇数を送信（2 以外の偶数は素数ではない）
            ch <- n
        }
        close(ch)
    }()
    return ch
}

// 素数 'prime' に対するフィルタ
func filter(in chan int64, prime int64) chan int64 {
    out := make(chan int64)
    go func() {
        for n := range in {
            if (n % prime) != 0 {
                out <- n
            }
        }
        close(out)
    }()
    return out
}

// エラトステネスの篩
func sieve() chan int64 {
    out := make(chan int64)
    go func() {
        ch := generate()
        fflag := true
        for {
            prime, ok := <-ch
            if !ok {
                break
            }
            out <- prime
            if fflag && prime*prime <= 15485863 {
                ch = filter(ch, prime)
            } else { // 素数が最大値の平方根（√15485863）より大きい場合はフィルタを作らず無条件に通す
                fflag = false
            }
        }
        close(out)
    }()
    return out
}

これで実行してみる。

C:>go run prime05.go -alg=2 100
100 個目の素数: 541
2.0001ms 経過

C:>go run prime05.go -alg=2 10000
10000 個目の素数: 104729
378.0216ms 経過

C:>go run prime05.go -alg=2 1000000
1000000 個目の素数: 15485863
39.4492564s 経過

おお。ようやく有意の時間で探索できた。それでも「その2」の10倍以上かかるけど。

channel への送信データが有限個の場合は最後に close(ch) でクローズする。一方 channel からの受信側は for range 構文を使うことで安全に扱うことができる。ただし上述の sieve() 関数では変数 ch が新しい素数フィルタの出力に上書きされていくので for range 構文は使えない。その代わり以下の記述で channel を安全に扱うことができる。

prime, ok := <-ch
if !ok {
    break // channel が閉じられた
}

今回はここまで。

ブックマーク

Go の並行処理 - Block Rockin’ Codes
(翻訳)Goでのパイプラインとキャンセル - Qiita
Go: 計算なしのFizzBuzz - Qiita : channel の説明するのにいいかも
Goのchannelの送受信用の型について - Qiita
Go言語のChannelは送信時にもブロックする - Qiita : 意外と見落とす channel 送信時のブロック
Go - select loop の小ネタ - Qiita
Goのforとgoroutineでやりがちなミスとたった一つの冴えたgo vetと - Qiita
golang - x/net/context の実装パターン - Qiita : golang.org/x/net/context を使って並行処理を細かく制御
Go言語でCPU数に応じて並列処理数を制限する | SOTA
やはり俺のgolangがCPUを一つしか使わないのはまちがっている。 - Qiita
Golangで「エラトステネスの篩」で「2.1秒で百万個」の素数を計算できる「無限シーケンス」を作ってみた - Qiita

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

参考図書

数学ガール／ゲーデルの不完全性定理: 結城浩 (著); SBクリエイティブ 2009-10-23 (Release 2014-03-12); Kindle版; B00I8AT1D6 (ASIN); 評価

結城浩さんの本はよく整備された遊歩道を散歩するような気楽さと安心感がある。だから「フェルマーの最終定理」とか「ゲーデルの不完全性定理」とかいった難解そうなテーマでも，迷うことなく，しかも一歩ずつ歩みを進めてゴールまで辿り着けるのかもしれない。

reviewed by Spiegel on 2014-10-21 (powered by PA-APIv5)

message-passing 方式は Erlang などで一躍有名になったやつ。ただし Erlang ではプロセス間通信の手段として message-passing を使う。これは Actor と呼ばれている。 goroutine は「並行処理」であり「並列処理」ではない。また，いわゆる thread とも異なる。Go 言語で並列処理を行うなら「Go言語でCPU数に応じて並列処理数を制限する」あたりが参考になる。 ↩︎
ただし現在の公式ドキュメントには存在しない。 ↩︎

List of Slice [text.Baldanders.info]

Go 1.21.0 がリリースされた

Windows 7, 8, Server 2008, Server 2012 サポート終了のお知らせ

log/slog パッケージ

min/max 組み込み関数

slices, maps, cmp パッケージ

例によって…

ブックマーク

参考図書

#shimanego より： 配列とスライスとソート

ブックマーク

参考図書

CSV/TSV データの読み書き

ブックマーク

参考図書

配列と Slice

配列は常に「値」である

slice は配列を参照するオブジェクトである

配列の複製と比較

slice の複製と比較

【2023-08-10 追記】 slices 標準パッケージを使う

ブックマーク

参考図書

「ズンドコチェック」なるものが流行っているらしい

ブックマーク

参考図書

素数探索アルゴリズムで遊ぶ

素数の定義

素数探索アルゴリズム（その1）

素数探索アルゴリズム（その2: エラトステネスの篩の変形）

slice と make() と append()

100万個目の素数

素数探索アルゴリズム（その3: エラトステネスの篩を並行処理で）

ブックマーク

参考図書

#shimanego より：配列とスライスとソート