お気楽 Ruby プログラミング入門

Enumerator

Enumerator はオブジェクトの要素を列挙するためのクラス
Enumerable をインクルードしているので、Enumerable のメソッドを利用できる
Enumerator の生成にはメソッド Object#to_enum (または Object#enum_for) を使う
```
object.to_enum(method, *args) => Enumerator
```
- method は object から要素を取得するためのメソッドをシンボルで指定する
- args には method に渡す引数を指定する
- method を省略すると each() が使用される
- Ruby 2.3 以降ではブロックを省略すると Enumerator を返すメソッドがたくさん用意されている
要素を返すメソッドは next(), next_values(), peek(), peek_values() がある
next 系はイテレータを次の要素に進めるが、peek 系は進めない
values 系は要素を配列に格納して返す
メソッド rewind() は最初の状態に巻き戻す
メソッド with_index() はインデックス付きの each()
```
with_index(offset=0) {|(*args), idx| ... } => object
```
- メソッド each_with_index() と違って offset を指定できる

irb> class Foo
irb>   def each
irb>     yield 1
irb>     yield 2
irb>     yield 3
irb>   end
irb> end
=> :each
irb> a = Foo.new
=> #<Foo: ... >
irb> a.map {|x| x * x}
(irb):?:in `<main>': undefined method `map' for #<Foo:...> (NoMethodError)
・・・省略・・・

irb> e = a.to_enum
=> #<Enumerator: ...>
irb> e.map {|x| x * x}
=> [1, 4, 9]
irb> e.next
=> 1
irb> e.next
=> 2
irb> e.next
=> 3
irb> e.next
(irb):?:in `next': iteration reached an end (StopIteration)
・・・省略・・・

irb> e.rewind
=> #<Enumerator: ...>
irb> e.peek
=> 1
irb> e.peek
=> 1
irb> e.peek_values
=> [1]
irb> e.next_values
=> [1]
irb> e.next_values
=> [2]
irb> [1,2,3,4,5].to_enum.with_index{|k, i| print i, " ", k, "\n"}
0 1
1 2
2 3
3 4
4 5
=> [1, 2, 3, 4, 5]
irb> [1,2,3,4,5].to_enum.with_index(1){|k, i| print i, " ", k, "\n"} 
1 1
2 2
3 3
4 4
5 5
=> [1, 2, 3, 4, 5]
irb> [1,2,3,4,5].each_with_index{|k, i| print i, " ", k, "\n"}
0 1
1 2
2 3
3 4
4 5
=> [1, 2, 3, 4, 5]

Enumerator のオブジェクトは new() でも生成できる
```
1. Enumerator.new(object, method, *args) => Enumerator
2. Enumerator.new(size=nil) {|y| ... }  => Enumerator
```
- 1. は to_eum() と同じ
- 2. はブロックでデータを生成する
- ブロックの引数 y には Enumerator::Yielder オブジェクトが渡される
- 生成した要素 (item) は y << item で出力する
- 引数 size は Integer、Float::INFINITY、手続きオブジェクト、nil のいずれかを指定する
- size はメソッド size() で参照 (手続きオブジェクトの場合はそのときに実行される)

irb> ints = Enumerator.new(Float::INFINITY) {|y|
irb>   n = 1
irb>   loop {
irb>     y << n
irb>     n += 1
irb>   }
irb> }
=> #<Enumerator: ...>
irb> ints.next
=> 1
irb> ints.next
=> 2
irb> ints.next
=> 3
irb> ints.next
=> 4
irb> ints.next
=> 5
irb> ints.rewind
=> #<Enumerator: ...>
irb> ints.next
=> 1
irb> ints.next
=> 2
irb> ints.next
=> 3
irb> ints.size
=> Infinity

ints は無限の整数列 (1, 2, 3, ...) を生成する
無限リストの場合、map(), select(), drop() など配列を返すメソッドは使用できない (無限の配列を返そうとするため)
無限リストを取り扱うにはメソッド Enumerable#lazy で Enumerator を Enumerator::Lazy に変換する
本稿では Enumerator::Lazy のオブジェクトを「遅延リスト」と呼ぶことにする

●参考 URL

Rubyist Magazine - 標準添付ライブラリ紹介【第 5 回】enumerator, (西山さん)

Enumerator::Lazy

Enumerator::Lazy は遅延リストを表すクラス
map(), select(), drop() などのメソッドが遅延評価版に切り替わる
遅延リストはメソッド Enumerable#lazy で生成する
遅延リストから値を取り出すにはメソッド force() か first() を使う
first() は先頭要素を取り出す
first(n) は先頭から n 個の要素を取り出して配列に格納して返す

irb> intslazy = ints.lazy
=> #<Enumerator::Lazy: ...>
irb> intslazy.next
=> 1
irb> intslazy.next
=> 2
irb> intslazy.next
=> 3
irb> ints.lazy.drop(100)
=> #<Enumerator::Lazy: ...>
irb> ints.lazy.drop(100).first
=> 101
irb> ints.lazy.drop(100).first(10)
=> [101, 102, 103, 104, 105, 106, 107, 108, 109, 110]
irb> ints.lazy.map {|x| x * 2}
=> #<Enumerator::Lazy: ...>
irb> ints.lazy.map {|x| x * 2}.take(10).force
=> [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
irb> ints.lazy.map {|x| x * 2}.first(10)
=> [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

無限の整数列は (1..Float::INFINITY).lazy でも生成できる
Enumerator や Enumerator::Lazy は immutable ではない (メソッド next() は状態を変化させている)
また、実行結果もキャッシュしていない
一般に、関数型言語の「遅延ストリーム」は immutable なので、それとは使い勝手が異なることに注意

●簡単な例題

リスト : 無限数列の生成

def iterate(a, &func)
  Enumerator.new(Float::INFINITY) {|y|
    n = a
    loop {
      y << n
      n = func.call(n)
    }
  }.lazy
end

def tabulate(a = 0, &func)
  Enumerator.new(Float::INFINITY) {|y|
    n = a
    loop {
      y << func.call(n)
      n += 1
    }
  }.lazy
end

irb> iterate(1, &:itself).first(10)
=> [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
irb> iterate(2, &:itself).first(10)
=> [2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
irb> iterate(1){|x| x + 1}.first(10)
=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
irb> iterate(1){|x| x + 2}.first(10)
=> [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
irb> iterate([0, 1]){|x, y| [y, y + x]}.first(10)
=> [[0, 1], [1, 1], [1, 2], [2, 3], [3, 5], [5, 8], [8, 13], [13, 21], [21, 34],
 [34, 55]]
irb> iterate([0, 1]){|x, y| [y, y + x]}.map{|x| x[0]}.first(10)
=> [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
irb> iterate([2, 1]){|x, y| [y, y + x]}.map{|x| x[0]}.first(10)
=> [2, 1, 3, 4, 7, 11, 18, 29, 47, 76]
irb> iterate([0, 0, 1]){|x, y, z| [y, z, z + y + x]}.map{|x| x[0]}.first(20)
=> [0, 0, 1, 1, 2, 4, 7, 13, 24, 44, 81, 149, 274, 504, 927, 1705, 3136, 5768,
 10609, 19513]

irb> tabulate(&:itself).first(10)
=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
irb> tabulate(10, &:itself).first(10)
=> [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
irb> tabulate(1){|x| x * (x + 1) / 2}.first(10)
=> [1, 3, 6, 10, 15, 21, 28, 36, 45, 55]
irb> tabulate(1){|x| x * x}.first(10)
=> [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
irb> tabulate(1){|x| x * (3 * x - 1) / 2}.first(10)
=> [1, 5, 12, 22, 35, 51, 70, 92, 117, 145]

irb> def to_fizzbuzz(n)
irb>   if n % 15 == 0
irb>     "FizzBuzz"
irb>   elsif n % 3 == 0
irb>     "Fizz"
irb>   elsif n % 5 == 0
irb>     "Buzz"
irb>   else
irb>     n.to_s
irb>   end
irb> end
=> :to_fizzbuzz
irb> tabulate(1){|x| to_fizzbuzz(x)}.first(100)
=> ["1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", 
"13", "14", "FizzBuzz", "16", "17", "Fizz", "19", "Buzz", "Fizz", "22", "23", "Fizz", 
"Buzz", "26", "Fizz", "28", "29", "FizzBuzz", "31", "32", "Fizz", "34", "Buzz", 
"Fizz", "37", "38", "Fizz", "Buzz", "41", "Fizz", "43", "44", "FizzBuzz", "46", "47", 
"Fizz", "49", "Buzz", "Fizz", "52", "53", "Fizz", "Buzz", "56", "Fizz", "58", "59", 
"FizzBuzz", "61", "62", "Fizz", "64", "Buzz", "Fizz", "67", "68", "Fizz", "Buzz", 
"71", "Fizz", "73", "74", "FizzBuzz", "76", "77", "Fizz", "79", "Buzz", "Fizz", "82", 
"83", "Fizz", "Buzz", "86", "Fizz", "88", "89", "FizzBuzz", "91", "92", "Fizz", "94", 
"Buzz", "Fizz", "97", "98", "Fizz", "Buzz"]

irb> def newton(n)
irb>   iterate(n) {|x| (x + n / x) / 2.0}
irb> end
=> :newton
irb> newton(2).first(10)
=> [2, 1.5, 1.4166666666666665, 1.4142156862745097, 1.4142135623746899, 
1.414213562373095, 1.414213562373095, 1.414213562373095, 1.414213562373095, 
1.414213562373095]
irb> newton(3).first(10)
=> [3, 2.0, 1.75, 1.7321428571428572, 1.7320508100147274, 1.7320508075688772, 
1.7320508075688772, 1.7320508075688772, 1.7320508075688772, 1.7320508075688772]

リスト : 素数列 (myprime.rb)

class Myprime
  @@primes = [2, 3, 5]    # 求めた素数を格納

  # 次の素数を求める
  def Myprime.next_prime(n)
    while true
      for p in @@primes
        return n if p * p > n
        break if n % p == 0
      end
      n += 2
    end
  end

  # 素数列の生成
  def Myprime.make
    Enumerator.new(Float::INFINITY) {|y|
      n = 0
      while true
        if n == @@primes.size
          @@primes.push Myprime.next_prime(@@primes[-1] + 2)
        end
        y << @@primes[n]
        n += 1
      end
    }.lazy
  end
end

irb> load "myprime.rb"
=> true
irb> ps = Myprime.make
=> #<Enumerator::Lazy: ...>
irb> ps.first(25)
=> [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]
irb> ps.first(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, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 
173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 
269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 
373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 
467, 479, 487, 491, 499, 503, 509, 521, 523, 541]
irb> ps.drop(1000).first(10)
=> [7927, 7933, 7937, 7949, 7951, 7963, 7993, 8009, 8011, 8017]

●参考 URL

Rubyist Magazine - 無限リストを map 可能にする Enumerable#lazy, (原悠さん)

Fiber

概要
- Ruby の Fiber はコルーチン (co-routine) のこと
- 関数 (サブルーチン, sub-routine) は call してから return するまで途中で処理を中断することはできない
- コルーチンは途中で処理を中断し、そこから実行を再開することができる
- Ruby のコルーチンは「セミコルーチン (semi-coroutine)」が基本
- セミコルーチンには親子関係があり、コルーチン A からコルーチン B を呼び出した場合、A が親で B が子になる
- 本稿では Fiber をコルーチンと記述する
コルーチンは Fiber.new { ... } で生成する
コルーチンを実行 (または再開) するにはメソッド resume() を使う
rensume() を呼び出したほうが親、呼び出されたほうが子になる
子コルーチンの中でクラスメソッド Fiber.yield() を実行すると、そこでプログラムの実行を中断して親コルーチンに戻る
yield() の引数が親コルーチンで呼び出した resume() の返り値になる
resume() に引数を渡して実行を再開すると、それが Fiber.yield() の返り値となる

irb(main)> co = Fiber.new {
irb(main)>   for x in 1 .. 4
irb(main)>     Fiber.yield x
irb(main)>   end
irb(main)>   5
irb(main)> }
=> #<Fiber:0x000055e61811b3f0 (irb):? (created)>
irb> co.resume
=> 1
irb> co.resume
=> 2
irb> co.resume
=> 3
irb> co.resume
=> 4
irb> co.resume
=> 5
irb> co.resume
(irb):?:in `resume': attempt to resume a terminated fiber (FiberError)
・・・省略・・・

resume() が返す値は Fiber.yield() だけではなくブロックの実行結果も返す
終了したコルーチンに resume() を適用するとエラーになる

●簡単な例題

リスト : 複数のコルーチン

def print_code(code)
  loop {
    print code
    Fiber.yield true
  }
end

def test_a(n)
  xs = ["h", "e", "y", "!", " "].map {|x| Fiber.new {print_code(x)}}
  n.times {
    xs.each {|co| co.resume}
  }
end

irb> test_a(5)
hey! hey! hey! hey! hey! => 5
irb> test_a(10)
hey! hey! hey! hey! hey! hey! hey! hey! hey! hey! => 10

リスト : 順列の生成

def perm_sub(xs, n)
  if xs.size == n
    Fiber.yield []
  else
    co = Fiber.new { perm_sub(xs, n + 1) }
    while ys = co.resume
      for x in xs
        if not ys.member? x
          Fiber.yield(ys + [x])
        end
      end
    end
  end
end

def permutation(xs)
  Fiber.new { perm_sub(xs, 0) }
end

irb> co = permutation([1,2,3])
=> #<Fiber:0x0000563306296ac8 sample_fiber.rb:? (created)>
irb> while xs = co.resume
irb>   print xs, "\n"
irb> end
[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]
=> nil

リスト : エラトステネスの篩

# n から始まる整数列
def integers(n)
  Fiber.new {
    loop {
      Fiber.yield n
      n += 1
    }
  }
end

# フィルター
def filter(src)
  Fiber.new {
    while m = src.resume
      Fiber.yield(m) if yield(m)
    end
  }
end

def sieve(x)
  nums = integers(2)
  x.times {
    n = nums.resume
    print n, " "
    nums = filter(nums) {|x| x % n != 0}
  }
end

irb> sieve 25
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 => 25
irb> sieve 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 101 103 107 
109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199 211 223 227 
229 233 239 241 251 257 263 269 271 277 281 283 293 307 311 313 317 331 337 347 349 
353 359 367 373 379 383 389 397 401 409 419 421 431 433 439 443 449 457 461 463 467 
479 487 491 499 503 509 521 523 541 => 100

Rational

Rational は有理数 (分数) を表すクラス
require は必要ない
有理数の生成は Kernel#Rational を使う
Rational.new はエラー

Rational(分子, [分母])

分母を省略すると 1 になる
分子と分母は数または文字列
実数 (Float) の場合、分数には正確に変換できないことがある
文字列の場合、分数の形式 "1/3" や実数の形式でも OK

irb> Rational(1, 3)
=> (1/3)
irb> Rational("1/3")
=> (1/3)
irb> Rational(0.1)
=> (3602879701896397/36028797018963968)
irb> Rational("0.1")
=> (1/10)
irb> Rational(1e-3)
=> (1152921504606847/1152921504606846976)
irb> Rational("1e-3")
=> (1/1000)

numerator, 分子を返す
denominator, 分母を返す
算術演算子 (+, -, *, /, %, **)

有理数と有理数、有理数と整数の演算は有理数になる
除算の結果を実数で得たいときは fdiv を使う
有理数と実数の演算結果は実数になる

比較演算子 (==, !=, <=>, < > <=, >=)
数に適用できるメソッドであれば、たいていは有理数にも適用可

zero?, positive?, negative?, ceil, floor, round, truncate, etc...

irb> a = Rational(1, 2)
=> (1/2)
irb> b = Rational(1, 3)
=> (1/3)
irb> a + b
=> (5/6)
irb> a - b
=> (1/6)
irb> b - a
=> (-1/6)
irb> a * b
=> (1/6)
irb> a / b
=> (3/2)
irb> b / a
=> (2/3)
irb> a ** 2
=> (1/4)
irb> a ** 10
=> (1/1024)
irb> 2 ** a
=> 1.4142135623730951
irb> 8 ** b
=> 2.0
irb> a < b
=> false
irb> a > b
=> true
irb> a == b
=> false
irb> a != b
=> true
irb> a == a
=> true
irb> a <=> b
=> 1
irb> b <=> a
=> -1
irb> b <=> b
=> 0

詳細は Ruby のリファレンス class Rational を参照

Complex

Complex は複素数を表すクラス
require は必要ない
数学では複素数 \(z\) を \(x + yi\) と表記する

x を実部、y を虚部、i を虚数単位という
虚数単位は 2 乗すると -1 になる数
実部と虚部の 2 つの数値を格納するデータ構造を用意すれば、プログラミング言語でも複素数を表すことができる

複素数の生成は Kernel#Complex, Complex.polor, Complex.rect, Numeric#to_c, String#to_c のいずれかを使う
Complex.new はエラー

Complex(実部, 虚部 = 0)
Complex.rect(実部, 虚部 = 0)
Complex.rectangular(実部, 虚部 = 0)

虚部を省略すると 0 になる
実部と虚部は数または文字列
文字列の場合、複素数の形式 "1+2i" も OK

実部は real, 虚部は imag で取得できる
複素共役 (虚部の符号を反転した数) は conjugate または conj で求める
虚数単位は Complex::I

irb> Complex(1, 2)
=> (1+2i)
irb> Complex.rect(3, 4)
=> (3+4i)
irb> Complex(1)
=> (1+0i)
irb> Complex("1+2i")
=> (1+2i)
irb> Complex("1.0+2.0i")
=> (1.0+2.0i)
irb> Complex::I
=> (0+1i)
irb> a = Complex(1.2, 3.4)
=> (1.2+3.4i)
irb> a.real
=> 1.2
irb> a.imag
=> 3.4
irb> a.conjugate
=> (1.2-3.4i)
irb> a.conj
=> (1.2-3.4i)

複素数は極形式 \(z = |z|(\cos \theta + i \sin \theta)\) で表すことができる
このとき、\(|z|\) を絶対値、\(\theta\) を偏角という
絶対値はメソッド abs, magnitude で求めることができる
偏角は複素平面において正の実軸とベクトル (x, y) との角度 \(\theta\) を表す
偏角 \(\theta\) を求めるメソッドには arg, angle, phase がある
返り値 \(\theta\) は \(-\pi \leq \theta \leq \pi\) (\(\pi\) : 円周率)
Complex.polar() は絶対値と偏角から複素数を生成する

Complex.polar(絶対値, 偏角)

irb> b = Complex(1, 1)
=> (1+1i)
irb> b.abs
=> 1.4142135623730951
irb> b.arg
=> 0.7853981633974483
irb> Complex.polar(b.abs, b.arg)
=> (1.0000000000000002+1.0i)
irb> Complex(1.0, 0.0).arg
=> 0.0
irb> Complex(1.0, 1.0).arg
=> 0.7853981633974483
irb> Complex(0.0, 1.0).arg
=> 1.5707963267948966
irb> Complex(-1.0, 1.0).arg
=> 2.356194490192345
irb> Complex(-1.0, 0.0).arg
=> 3.141592653589793
irb> Complex(1.0, -1.0).arg
=> -0.7853981633974483
irb> Complex(0.0, -1.0).arg
=> -1.5707963267948966
irb> Complex(-1.0, -1.0).arg
=> -2.356194490192345
irb> Complex(-1.0, -0.0).arg
=> -3.141592653589793

\(-1.0+0.0i\) の偏角 \(\theta\) は \(\pi\) になり、\(-1.0-0.0i\) の偏角は \(-\pi\) になる
-0.0 は「負のゼロ」を表す
ゼロと負のゼロを区別しないプログラミング言語もある

その場合は、偏角 \(\theta\) の範囲を \(-\pi \lt \theta \leq \pi\) に制限して、\(-1.0 + 0.0i \ (= -1.0 - 0.0i)\) の偏角を \(\pi\) とする

Ruby の場合、負のゼロは Float のメソッド arg, angle, phase で判定できる
符号が正ならば 0 を、負ならば Math::PI を返す

irb> 1.0.arg
=> 0
irb> -1.0.arg
=> 3.141592653589793
irb> 0.0.arg
=> 0
irb> -0.0.arg
=> 3.141592653589793

複素数の四則演算

\( \begin{array}{l} (a + bi) + (c + di) = (a + c) + (b + d)i \\ (a + bi) - (c + di) = (a - c) + (b - d)i \\ (a + bi) \times (c + di) = (ac - bd) + (bc + ad)i \\ (a + bi) \div (c + di) = \dfrac{ac + bd + (bc - ad)i}{c^2 + d^2} \end{array} \)

算術演算子 (+, -, *, /, **)

Complex 以外の数との演算も可能、返り値は Complex になる

比較演算子 (==, !=, <=>)

複素数で大小の比較はできない、等値演算子は適用可
演算子 <=> は両辺の虚部が 0 のときのみ適用可

irb> a = Complex(1.0, 2.0)
=> (1.0+2.0i)
irb> b = Complex(3.0, 4.0)
=> (3.0+4.0i)
irb> a + b
=> (4.0+6.0i)
irb> a - b
=> (-2.0-2.0i)
irb> a * b
=> (-5.0+10.0i)
irb> a / b
=> (0.44+0.08i)
irb> a ** 2
=> (-3.0+4.0i)
irb> a * a
=> (-3.0+4.0i)
irb> a ** 3
=> (-11.0-2.0i)
irb> a * a * a
=> (-11.0-2.0i)
irb> a == a
=> true
irb> a == b
=> false
irb> a != b
=> true

実部と虚部の値は無限大 (Float::INFINITY) や非数 (FLOAT::NAN) になることもある
finite? は実部と虚部が有限の値であれば真を返す
infinite? は実部と虚部がどちらも無限大でなければ nil を、そうでなければ 1 を返す
実数の場合、無限大は Float のメソッド finite? や infinite? で、非数の判定は nan? で行うことができる

irb> Float::INFINITY
=> Infinity
irb> Float::NAN
=> NaN
irb> a = Complex(1e300, 1e300)
=> (1.0e+300+1.0e+300i)
irb> a.finite?
=> true
irb> a.infinite?
=> nil
irb> b = a * a
=> (NaN+Infinity*i)
irb> b.finite?
=> false
irb> b.infinite?
=> 1
irb> b.real.nan?
=> true
irb> b.real.nan?
=> true
irb> b.imag.infinite?
=> 1

整数のビット演算

論理演算子

x & y
x と y の論理積を求める
x | y
x と y の論理和を求める
x ^ y
x と y の排他的論理和を求める
~x
x の否定 (ビットの反転)

シフト演算子

x << n
x を n ビット左シフトする
x >> n
x を n ビット右シフトする

これらの演算子はＣ言語のそれと同じ
[] 演算子

x[n]
n 番目のビットがオンならば 1 を返す, (x >> n) & 1 と同じ
x[n, k]
n 番目のビットから上位 k 個のビットを返す, (x >> n) & ((1 << k) - 1) と同じ
x[i..j]
(x >> i) & ((1 << (j - i + 1)) - 1) と同じ
x[i...j]
(x >> i) & ((1 << (j - i)) - 1) と同じ

allbits?(mask)
self & mask == mask と同じ
anybits?(mask)
self & mask != 0 と同じ
bit_length
整数を表すのに必要なビット数 (符号ビットを除く最上位のビット位置 + 1) を返す。

irb> printf "%04b\n", 0b0101 & 0b0011
0001
=> nil
irb> printf "%04b\n", 0b0101 | 0b0011
0111
=> nil
irb> printf "%04b\n", 0b0101 ^ 0b0011
0110
=> nil
irb> ~1
=> -2
irb> ~0
=> -1
irb> 1 << 8
=> 256
irb> 1 << 16
=> 65536
irb> 256 >> 8
=> 1
irb> 65536 >> 8
=> 256
irb> -256 >> 8
=> -1
irb> for i in 0..5
irb>   print 0b010101[i], " "
irb> end
1 0 1 0 1 0 => 0..5
irb> printf "%b\n", 0b11001101[3, 1]
1
=> nil
irb> printf "%b\n", 0b11001101[3...7]
1001
=> nil
irb> printf "%b\n", 0b11001101[3..7]
11001
=> nil
irb> 0b11001101.allbits?(0b1101)
=> true
irb> 0b11001100.allbits?(0b1101)
=> false
irb> 0b11001101.anybits?(0b1100)
=> true
irb> 0b11000000.anybits?(0b1100)
=> false
irb> 0x100.bit_length
=> 9
irb> 0x800.bit_length
=> 12
irb> 0xffff.bit_length
=> 16
irb> 0.bit_length
=> 0

初版 2017 年 1 月 22 日
改訂 2023 年 1 月 28 日

構造体

クラス Struct は構造体 (Struct のサブクラス) を表すクラスを生成する
他言語の場合、構造体はユーザーが既存のデータ型を組み合わせて、新しいデータ型を定義する機能
Ruby の場合、構造体はクラスで代用できるが、いちいちクラスを定義するのはちょっと面倒なこともある
Struct を使うと、構造体に必要となる最低限の機能を実装したクラスを簡単に作成できる
構造体は Struct.new() で定義する

1. Struct.new("Class_name", name1, name2, ...) => Struct::Class_name
2. Class_name = Struct.new(name1, name2, ...)

構造体のメンバ変数 (インスタンス変数) name1, name2, ... は文字列またはシンボルで指定する
1 の場合、第 1 引数にクラス名を文字列で指定する

生成されたクラスは Struct に定数として格納される

2 のように第 1 引数を省略すると生成した構造体を返す

返り値は定数 Class_name にセットする
1 の方法でも、返り値を定数にセットすることができる

Class_name の先頭は大文字であること
インスタンスの生成は new() を使う

1. Struct::Class_name.new(...) => object
2. Class_name.new(...) => object

new() の引数はメンバ変数を定義した順番でセットされる
Ruby 3.1 からキーワード引数を使うことができるようだ
引数の個数が足りない場合、残ったメンバ変数は nil に初期化される
引数の個数が多い場合はエラー (ArgumentError)
メンバ変数のアクセスはハッシュと同じ形式、またはメソッド (メンバ変数名) で行う
演算子 == の等値判定はクラスと異なる
構造体の場合、メンバ変数の値が等しい (==) ならば true を返す
当然だが、演算子 === やメソッド instance_of?() でデータ型 (クラス) の判定もできる

irb> Foo = Struct.new(:a, :b)
=> Foo
irb> x = Foo.new(1, 2)
=> #<struct Foo a=1, b=2>
irb> x.a
=> 1
irb> x[:a]
=> 1
irb> x["a"]
=> 1
irb> x.b
=> 2
irb> x.b = 20
=> 20
irb> x[:b]
=> 20
irb> x["b"] = 200
=> 200
irb> x.b
=> 200
irb> y = Foo.new(10)
=> #<struct Foo a=10, b=nil>
irb> y = Foo.new(10, 20, 30)
=> エラー (ArgumentError)
irb> Foo.new(1, 2) == Foo.new(1, 2)
=> true
irb> Foo.new(1, 2) == Foo.new(1, 3)
=> false
irb> Foo === Foo.new(10, 20)
=> true
irb> Foo.new(10, 20).instance_of?(Foo)
=> true

このほかにも、each, each_pair, to_a, to_h, to_s など基本的なメソッドがいくつか定義されている
また、モジュール Enumberable も include されている
詳細は Ruby のリファレンス Class Struct を参照
独自のメソッドを追加したい場合は Struct.new() で指定するブロックで行う

Class_name = Struct.new(...) do
  # メソッドの定義など
  ...
end

構造体で「パターンマッチ」を使うときに便利
簡単な連結リストの例

irb> Cons = Struct.new(:car, :cdr) do
irb>   def deconstruct() = self.to_a
irb> end
=> Cons
irb> x = Cons.new(1, nil)
=> #<struct Cons car=1, cdr=nil>
irb> y = Cons.new(2, x)
=> #<struct Cons car=2, cdr=#<struct Cons car=1, cdr=nil>>
irb> z = Cons.new(3, y)
=> #<struct Cons car=3, cdr=#<struct Cons car=2, cdr=#<struct Cons car=1,
 cdr=nil>>>
irb> case z
irb>   in [a, d]
irb>     p a
irb>     p d
irb> end
3
#<struct Cons car=2, cdr=#<struct Cons car=1, cdr=nil>>
=> #<struct Cons car=2, cdr=#<struct Cons car=1, cdr=nil>>
irb> case z
irb>   in [a, [b, [c, _]]]
irb>     p a
irb>     p b
irb>     p c
irb> end
3
2
1
=> 1

初版 2023 年 2 月 25 日

パターンマッチ

「パターンマッチ (pattern matching)」は Ruby 2.7 から導入された機能です。Ruby のパターンマッチは関数型言語のパターンマッチングと同様の機能です。パターンマッチを使って条件分岐を行ったり、配列やハッシュなどのデータ構造を分解し、それらの要素を取り出すことができます。

●パターンマッチの基本

Ruby では case 文 (case / in) でパターンマッチを行います。パターンマッチの基本的な構文を以下に示します。

case expr
in pattern_1
  処理_1
  ...
in pattern_2
  処理_2
  ...
else
  処理_z
end

パターンマッチの動作は case / when と良く似ています。case は最初に式 expr を評価します。そのあと複数の in 節が続きます。in の後ろにはパターンを指定します。パターンはあとで説明します。そして、expr の評価結果とパターンを照合します。照合に成功 (マッチ) した場合、その in 節の処理を順番に実行します。照合に失敗した場合は、次の in 節をチェックします。

たとえば、pattern_1 とマッチしなかった場合、次の節に移り pattern_2 と照合します。一度 in 節が選択されたら、それ以降の in 節は実行されません。case は最後に実行した処理の結果を返します。もしも、どのパターンともマッチしなかった場合は else 節が実行されます。なお、else 節は省略することができますが、マッチングするパターンが見つからない場合は例外 (NoMatchingPatternError) が送出されます。ご注意くださいませ。

それでは簡単な例を示しましょう。パターンマッチを使って階乗を求める関数 fact() を定義すると次のようになります。

リスト : 階乗

# パターンマッチング未使用
def fact(n)
  if n == 0
    1
  else
    n * fact(n - 1)
  end
end

# パターンマッチング
def fact(n)
  case n
  in 0
    1
  in m
    m * fact(m - 1)
  end
end

数値や文字列などのリテラル、クラス名などの定数は、それ自身がパターンになります。この場合、式の評価結果とパターンを演算子 === で比較して、等しければその節とマッチします。これは case / when の動作とほとんど同じです。

最初の節はパターンが 0 なので、引数 n が 0 の場合にマッチします。これは if n == 0 と同じ処理です。パターンが変数 (局所変数) の場合はどんな値とでもマッチします。そして、その値が変数に代入されます。したがって、n が 0 以外の場合は 2 番目のパターンとマッチし、変数 m の値は n になります。ここで再帰呼び出しが行われます。

変数 m は n と同じ値なので、パターンにワイルドカード (_) を使う、もしくは else 節を使って定義してもかまいません。

リスト : 別解

def fact1(n) 
  case n
  in 0
    1
  in _
    n * fact1(n - 1)
  end
end

def fact2(n)
  case n
  in 0
    1
  else
    n * fact2(n - 1)
  end
end

なお、パターンマッチを使うときは、節を定義する順番に気をつけてください。fact() の場合、最初にパターン m を定義すると、引数が 0 の場合でもマッチするので、パターン 0 の節が実行されることはありません。特定のパターンから定義するように注意してください。

case / when は when の後ろに複数の値を , で区切って指定することができました。case / in でも in の後ろに複数のパターンを | で区切って指定することができます。複数指定したパターンのどれかとマッチすれば、その節の処理が実行されます。簡単な例として、フィボナッチ関数 fibo() を定義してみましょう。

リスト : フィボナッチ関数 (二重再帰)

def fibo(n)
  case n
  in 0 | 1
    n
  else
    fibo(n - 1) + fibo(n - 2)
  end
end

最初の in 節の 0 | 1 は、if n == 0 || n == 1 と同じ動作になります。n が 0 または 1 であれば n を返します。そうでなければ else 節で fibo() を再帰呼び出しします。fibo() は二重再帰なので、実行時間はとても遅くなります。

●演算子 === の動作

演算子 === の標準動作は演算子 == と同じです。Ruby の演算子はメソッドなので、'左辺 === 右辺' はメソッド呼び出し '左辺.===(右辺)' と同じです。左辺のオブジェクトによって === の動作を変更することが可能です。たとえば、左辺が範囲オブジェクトの場合、右辺の数値が範囲内にあれば true を返します。

irb> (1..10) === 1
=> true
irb> (1..10) === 11
=> false
irb> (1..10) === 1.5
=> true
irb> (1..10) === 0.5
=> false

左辺がクラスの場合、右辺のオブジェクトがそのクラスまたはサブクラスのインスタンスであれば true を返します。

irb> Integer === 123
=> true
irb> Integer === 123.4
=> false
irb> Numeric === 123.4
=> true
irb> Numeric === 123
=> true
irb> String === "abc"
=> true
irb> String === 123
=> false

範囲オブジェクトやクラスは case / when や case / in でも使用することができます。

irb> case 123
irb> in Integer
irb>   "integer"
irb> else
irb>   "other"
irb> end
=> "integer"
irb> case "abc"
irb> in Integer
irb>   "integer"
irb> else
irb>   "other"
irb> end
=> "other"
irb> case 5
irb> in (1..10)
irb>   "ok"
irb> else
irb>   "ng"
irb> end
=> "ok"
irb> case 15
irb> in (1..10)
irb>   "ok"
irb> else
irb>   "ng"
irb> end
=> "ng"

●配列のパターンマッチ

配列もパターンとマッチングすることができます。配列のパターンは角カッコ [ ... ] を使って表します。基本的な動作は、配列の要素とパターンの要素を照合し、それらがすべてマッチしたとき、配列とパターンはマッチしたと判定されます。簡単な例を示します。

(1) [x]         要素が 1 つの配列とマッチ
(2) [x, y]      要素が 2 つの配列とマッチ
(3) [x, *y]     要素が 1 つ以上ある配列とマッチ
    [*x, y]     末尾の要素が y とマッチ、それ以外の要素は x にマッチ
(4) [x, y, *z]  要素が 2 つ以上ある配列とマッチ
    [*x, y, z]  末尾から 2 つの要素が y と z にマッチ、それ以外の要素は x にマッチ
(5) [x, y, x]   エラー

(1), (2) は簡単ですね。パターンの要素は変数、定数、リテラルだけではありません。あとから説明しますが、配列のパターンやハッシュのパターンでもかまいません。(3), (4) の * は可変個引数を表す * と似ていて、複数の要素とマッチします。(3) の場合、先頭要素以外の要素は、配列に格納されて変数 y にセットされます。(4) は 2 つの要素を変数に取り出し、それ以外の要素をもう一つの変数に取り出します。* の後ろの変数名を省略すると、マッチした要素は捨てられます。

簡単な例を示しましょう。

irb> case [1]
irb>   in [x]
irb>     p x
irb> end
1
=> 1
irb> case [1, 2]
irb>   in [x]
irb>     p x
irb> end
=> エラー (NoMatchingPatternError)

irb> case [1, 2]
irb>   in [x, y]
irb>     p x
irb>     p y
irb> end
1
2
=> 2
irb> case [1, 2, 3, 4, 5]
irb>   in [x, *y]
irb>     p x
irb>     p y
irb> end
1
[2, 3, 4, 5]
=> [2, 3, 4, 5]
irb> case [1, 2, 3, 4, 5]
irb>   in [*x, y]
irb>     p x
irb>     p y
irb> end
[1, 2, 3, 4]
5
=> 5
irb> case [1, 2, 3, 4, 5]
irb>   in [*, y]
irb>     p y
irb> end
5
=> 5
irb> case [1, 2, 3, 4, 5]
irb>   in [x, *y, z]
irb>     p x
irb>     p y
irb>     p z
irb> end
1
[2, 3, 4]
5
=> 5

●ガード節

(5) のように、パターンの中に同名の変数を使うことはできません。この場合、[x, y, z] とマッチングさせてから x と z が等しいかチェックします。このような場合、次のようにパターンの後ろに条件式を指定することができます。

case 式
in パターン if 条件式
  処理
  ...
end

このようなマッチング節を「ガード付き節」とか「ガード節」といいます。パターンとの照合に成功して、かつ if の条件式が真を返す場合に限り処理が実行されます。if のかわりに unless を指定することもできます。その場合は、条件式が偽を返す場合に処理が実行されます。

簡単な例を示しましょう。

irb> case [1, 2, 1]
irb>   in [x, y, z] if x == z
irb>     p x
irb>     p y
irb>     p z
irb> end
1
2
1
=> 1
irb> case [1, 2, 3]
irb>   in [x, y, z] if x == z
irb>     p x
irb>     p y
irb>     p z
irb> end
=> エラー (NoMatchingPatternError)

●配列パターンの入れ子

配列のパターンを入れ子にすると、入れ子の配列とマッチさせることができます。簡単な例を示しましょう。

irb> case [[1, 2], [3, 4]]
irb>   in [[a, b], [c, d]]
irb>     p a
irb>     p b
irb>     p c
irb>     p d
irb> end
1
2
3
4
=> 4
irb> case [1, [2, [3], 4], 5]
irb>   in [a, [b, [c], d], e]
irb>     p a
irb>     p b
irb>     p c
irb>     p d
irb>     p e
irb> end
1
2
3
4
5
=> 5

●As pattern

ところで、パターン [a, b, c, d] を使うと配列から個々の要素を取り出すことができますが、要素だけではなく元の配列を参照したいときがあります。このような場合、=> を使うと変数とパターンを同時に設定することができます。

パターン => 変数名

関数型言語では => のかわりに as を使うことがあります。このため、これを As pattern と呼ぶようです。簡単な例を示しましょう。

irb> case [1, 2, 3, 4]
irb>   in [a, b, c, d] => e
irb>     p a
irb>     p b
irb>     p c
irb>     p d
irb>     p e
irb> end
1
2
3
4
[1, 2, 3, 4]
=> [1, 2, 3, 4]
irb> case [[1, 2], [3, 4]]
irb>   in [[a, b], [c, d] => e]
irb>     p a
irb>     p b
irb>     p c
irb>     p d
irb>     p e
irb> end
1
2
3
4
[3, 4]
=> [3, 4]

このように、変数 e の値は分解する前の配列の値 [1, 2, 3, 4] や [3, 4] になります。

●ハッシュのパターンマッチ

ハッシュもパターンとマッチングすることができます。ハッシュのパターンは波カッコ { ... } を使って表します。

{key1: pattern1, key2: pattern2, ..., **items}

照合するハッシュにキー key が存在し、その値とパターン pattern を照合します。パターンの要素がすべてマッチしたとき、ハッシュとパターンはマッチしたと判定されます。**items の ** は関数のキーワード引数と似ています。マッチした要素を除いた残りの要素をハッシュに格納し、それを変数 items にセットします。

pattern を省略して key だけを指定すると、キーに対応する値が変数 key にセットされます、つまり key: key と同じ動作になります。それから、パターン先頭の { と末尾の } は省略することができます。なお、ハッシュのパターンマッチで使用できるキーはシンボルだけです。ご注意くださいませ。

簡単な例を示します。

irb> case {foo: 10, bar: 20, baz: 30}
irb>   in {foo: a, baz: b}
irb>     p a
irb>     p b
irb> end
10
30
=> 30
irb> case {foo: 10, bar: 20, baz: 30}
irb>   in {foo:, **d}
irb>     p foo
irb>     p d
irb> end
10
{:bar=>20, :baz=>30}
=> {:bar=>20, :baz=>30}

もちろん、ハッシュのパターンも入れ子にすることができます。そして、配列のパターンにハッシュのパターンを入れる、逆に、ハッシュのパターンに配列のパターンを入れることもできます。簡単な例を示しましょう。

irb> d = {name: "Alice", data: {height: 150.0, rank: "a"}}
=> {:name=>"Alice", :data=>{:height=>150.0, :rank=>"a"}}
irb> case d
irb>   in {name:, data: {height:, rank:}}
irb>     p name
irb>     p height
irb>     p rank
irb> end
"Alice"
150.0
"a"
=> "a"
irb> d1 = {name: "Alice", data: [150.0, "a"]}
=> {:name=>"Alice", :data=>[150.0, "a"]}
irb> case d1
irb>   in {name:, data: [height, rank]}
irb>     p name
irb>     p height
irb>     p rank
irb> end
"Alice"
150.0
"a"
=> "a"

●クラスでパターンマッチを行う

クラスでパターンマッチを利用したい場合はメソッド deconstruct() または deconstruct_keys() を定義します。

deconstruct() => 配列
deconstruct_keys(keys) => ハッシュ

deconstruct() は配列のパターンマッチで、deconstruct_keys(keys) はハッシュのパターンマッチで使用します。引数の keys はパターンマッチで必要となるキーを格納した配列です。nil の場合はすべてのキーと値を格納したハッシュを返します。簡単な例を示しましょう。

irb> class Foo
irb>   def initialize(a, b, c)
irb>     @a = a
irb>     @b = b
irb>     @c = c
irb>   end
irb> end
=> :initialize
irb> class Foo
irb>   def deconstruct() = [@a, @b, @c]
irb> end
=> :deconstruct
irb> case Foo.new(1, 2, 3)
irb>   in [a, b, c]
irb>     printf "%d %d %d\n", a, b, c
irb> end
1 2 3
=> nil
irb> case Foo.new(1, 2, 3)
irb> in Foo[a, b, c]
irb>     printf "%d %d %d\n", a, b, c
irb> end
1 2 3
=> nil

irb> class Foo
irb>   def deconstruct_keys(keys) = {a: @a, b: @b, c: @c}
irb> end
=> :deconstruct_keys
irb> case Foo.new(1, 2, 3)
irb> in {a:, b:, c:}
irb>     printf "%d %d %d\n", a, b, c
irb> end
1 2 3
=> nil
irb> case Foo.new(1, 2, 3)
irb> in Foo(a:, b:, c:)
irb>     printf "%d %d %d\n", a, b, c
irb> end
1 2 3
=> nil

型 (クラス) をチェックしたい場合は、パターンの前にその名前を指定します。配列パターンの場合は Foo[ ... ] になりますが、ハッシュパターンは Foo{ ... } はなく Foo( ... ) となることに注意してください。

お気楽 Ruby プログラミング入門

付録 A

Enumerator

●参考 URL

Enumerator::Lazy

●簡単な例題

●参考 URL

Fiber

●簡単な例題

Rational

Complex

整数のビット演算

構造体

パターンマッチ

●パターンマッチの基本

●演算子 === の動作

●配列のパターンマッチ

●ガード節

●配列パターンの入れ子

●As pattern

●ハッシュのパターンマッチ

●クラスでパターンマッチを行う