Ruby 1.9.3 リファレンスマニュアル > ライブラリ一覧 > matrixライブラリ > Matrixクラス

class Matrix + Enumerable

クラスの継承リスト: Matrix < Enumerable < Object < Kernel < BasicObject

要約

数Numericを要素とする行列を扱うクラスです。

行列

m * n 個の数a(i,j)を 

[ a(0,0) a(0,1) a(0,2)  a(0,3) ... a(0,n-1)   ]
[ a(1,0) a(1,1) a(1,2)  a(1,3) ... a(1,n-1)   ]
[ a(2,0) a(2,1) a(2,2)  a(2,3) ... a(2,n-1)   ]
[                                             ]
[ a(m-1,0)                         a(m-1,n-1) ]

のように、縦横の表にあらわしたものを(m,n)型の行列といいます。 m=nの行列をm次の正方行列(square matrix)といいます。

上からi番目の横の数の並びを第i行(the i-th row)、 左からj番目の縦の数の並びを第j列(the j-th column)といいます。

(m,n)型行列は、 大きさnの行(横)ベクトルをm個縦に並べたものとみなすこともできますし、 大きさmの列(縦)ベクトルをn個横に並べたものとみなすこともできます。

第i行、第j列にある数a(i,j)を(i,j)要素(the (i,j)-th element)といいます。

i=jの要素a(i,j)を対角要素(diagonal element)、 それ以外の要素を非対角要素(nondiagonal element)といいます。

Complex クラスとの併用

require 'complex'することによって、 Matrixオブジェクトの要素はComplexクラスに拡張されます。 多くのメソッドは、この拡張されたMatrixクラスでも、期待通りに動作します。

次の例は、各要素を共役複素数に置換するメソッド Matrix#conjugate です。 

require 'matrix'
require 'complex'

class Matrix
  def conjugate
    collect{|e| e.conjugate }
  end
end

特異メソッド

identity(n) -> Matrix
unit(n) -> Matrix
I(n) -> Matrix

n次の単位行列を生成します。

[PARAM] n:
単位行列の次元

単位行列とは、対角要素が全て1で非対角要素が全て0であるような行列のことです。

self[rows] -> Matrix

rowsを要素とする行列を生成します。 配列を行列の行成分として行列を生成します。

[PARAM] rows:
行列の要素を配列の配列として渡します。

例: 

m = Matrix[[11, 12], [21, 22]]
p m  #=> Matrix[[11, 12], [21, 22]]
     #   [11, 12]
     #   [21, 22]
build(row_size, column_size) {|row, col| ... } -> Matrix

[TODO]

Creates a matrix of size +row_size+ x +column_size+. It fills the values by calling the given block, passing the current row and column. Returns an enumerator if no block is given. 

m = Matrix.build(2, 4) {|row, col| col - row }
  => Matrix[[0, 1, 2, 3], [-1, 0, 1, 2]]
m = Matrix.build(3) { rand }
  => a 3x3 matrix with random elements
column_vector(column) -> Matrix

要素がcolumnの(n,1)型の行列(列ベクトル)を生成します。

[PARAM] column:
(n,1)型の行列として生成するVector Array オブジェクト
columns(columns) -> Matrix

引数 columns を列ベクトルの集合とする行列を生成します。

[PARAM] columns:
配列の配列を渡します。
注意

Matrix.rows との違いは引数として渡す配列の配列を列ベクトルの配列とみなして行列を生成します。

例: 

require 'matrix'

a1 = [1, 2, 3]
a2 = [4, 5, 6]
a3 = [-1, -2, -3]

# 配列を行ベクトルとして生成
m = Matrix.rows([a1, a2, a3], true)
p m #=> Matrix[[1, 2, 3], [4, 5, 6], [-1, -2, -3]]
    # 行列としてのイメージ =>  [ 1,  2,  3]
    #                          [ 4,  5,  6]
    #                          [-1, -2, -3]

# 配列を列ベクトルとして生成
m = Matrix.columns([a1, a2, a3])
p m #=> Matrix[[1, 4, -1], [2, 5, -2], [3, 6, -3]]
    # 行列としてのイメージ =>  [1, 4, -1]
    #                          [2, 5, -2]
    #                          [3, 6, -3]
diagonal(values) -> Matrix

対角要素がvalues(オブジェクトの並び)で、非対角要素が全て0であるような 正方行列を生成します。

[PARAM] values:
行列の対角要素とするオブジェクトを指定します。
注意

valuesに一次元Arrayを1個指定すると、そのArrayを唯一の要素とした1×1の行列が生成されます。

例: 

require 'matrix'

m = Matrix.diagonal(1, 2, 3)
p m # => Matrix[[1, 0, 0], [0, 2, 0], [0, 0, 3]]
a = [1,2,3]
m = Matrix.diagonal(a)
p m # => Matrix[[[1, 2, 3]]]
row_vector(row) -> Matrix

要素がrowの(1,n)型の行列(行ベクトル)を生成します。

[PARAM] row:
(1,n)型の行列として生成するVector Array オブジェクト
rows(rows, copy = true) -> Matrix

引数 rows を要素とする行列を生成します。 引数 copy が偽(false)ならば、rows の複製を行いません。

例: 

require 'matrix'

a1 = [1, 2, 3]
a2 = [10, 15, 20]

m = Matrix.rows([a1, a2], false) # 配列を複製せずに行列を生成
p m #=> Matrix[[1, 2, 3], [10, 15, 20]]
a2[1] = 1000 # 配列のデータを変更
p m #=> Matrix[[1, 2, 3], [10, 1000, 20]]
scalar(n, value) -> Matrix

対角要素が全てvalue(数)で、非対角要素が全て0であるようなn次の正方行列を生成します。

[PARAM] n:
生成する行列の次元
[PARAM] value:
生成する行列の対角要素の値

例: 

require 'matrix'

m = Matrix.scalar(3, 2.5)
p m # => Matrix[[2.5, 0, 0], [0, 2.5, 0], [0, 0, 2.5]]
zero(n) -> Matrix

n次の零行列を生成します。 零行列とは、要素が全て0の行列です。

[PARAM] n:
生成する行列の次元

インスタンスメソッド

self * m -> Matrix

行列mを右から乗じた行列を返します。

[PARAM] m:
右から乗算する行列。乗算が定義可能な行列を渡します。
self ** n -> Matrix

self の n乗をした行列を返します。

[PARAM] n:
べき数の指定
self + m -> Matrix

行列mを加算した行列を返します。

[PARAM] m:
加算する行列。加算可能な行列を渡します。
self - m -> Matrix

行列mを減算した行列を返します。

[PARAM] m:
減算する行列。減算可能な行列を渡します。
self / m -> Matrix

行列mの逆行列を右から乗じた行列を返します。

[PARAM] m:
逆行列を右から乗算する行列。可逆行列でselfと乗算可能な行列を渡します。
self == other -> bool
eql?(other) -> bool

自分自身と other を比較し、同値であれば真(true)を返します。

self[i, j] -> ()
element(i, j) -> ()
component(i, j) -> ()

(i,j)要素を返します。

[PARAM] i:
要素の行成分を0オリジンで指定します。
[PARAM] j:
要素の列成分を0オリジンで指定します。
注意

行成分にMatrix#row_sizeより大きな値を指定した場合には例外が発生します。 列成分にMatrix#column_sizeより大きな値を指定した場合にはnilを返します。

例: 

a1 = [1, 2, 3]
a2 = [10, 15, 20]
a3 = [-1, 2, 1.5]
m = Matrix[a1, a2, a3]

p m[0, 0] #=> 1
p m[1, 1] #=> 15
p m[1, 2] #=> 20
p m[1, 3] #=> nil
all? -> bool
all? {|item| ... } -> bool

すべての要素が真である場合に true を返します。 偽である要素があれば、ただちに false を返します。

ブロックを伴う場合は、各要素に対してブロックを評価し、すべての結果 が真である場合に true を返します。ブロックが偽を返した時点で、 ただちに false を返します。

例: 

# すべて正の数か？
p [5,  6, 7].all? {|v| v > 0 }   # => true
p [5, -1, 7].all? {|v| v > 0 }   # => false
any? -> bool
any? {|item| ... } -> bool

すべての要素が偽である場合に false を返します。 真である要素があれば、ただちに true を返します。

ブロックを伴う場合は、各要素に対してブロックを評価し、すべての結果 が偽である場合に false を返します。ブロックが真を返した時点 で、ただちに true を返します。

例: 

p [1, 2, 3].any? {|v| v > 3 }   # => false
p [1, 2, 3].any? {|v| v > 1 }   # => true
chunk {|elt| ... } -> Enumerator
chunk(initial_state) {|elt, state| ... } -> Enumerator

要素を前から順にブロックで評価し、その結果によって 要素をチャンクに分けた(グループ化した)要素を持つ Enumerator を返します。

ブロックの評価値が同じ値が続くものを一つのチャンクとして 取り扱います。すなわち、ブロックの評価値が一つ前と 異なる所でチャンクが区切られます。

返り値の Enumerator は各チャンクのブロック評価値と 各チャンクの要素を持つ配列のペアを各要素とします。 そのため、eachだと以下のようになります。 

enum.chunk {|elt| key }.each {|key, ary| ... }
enum.chunk(initial_state) {|elt, state| key }.each {|key, ary| ... }

例として、整数列を連続する奇数/偶数に分ける例を見てみます。 「n.even?」が変換するところで区切られているのがわかるでしょう。 

[3,1,4,1,5,9,2,6,5,3,5].chunk {|n|
  n.even?
}.each {|even, ary|
  p [even, ary]
}
#=> [false, [3, 1]]
#   [true, [4]]
#   [false, [1, 5, 9]]
#   [true, [2, 6]]
#   [false, [5, 3, 5]]

このメソッドは各要素が既にソートされている場合に便利です。 以下の例では、テキスト辞書ファイル(中身がソートされている) に含まれる単語を先頭の文字ごとに数えています。 

# line.ord は先頭の文字のコードポイントを返す
open("/usr/share/dict/words", "r:iso-8859-1") {|f|
  f.chunk {|line| line.ord }.each {|ch, lines| p [ch.chr, lines.length] }
}
#=> ["\n", 1]
#   ["A", 1327]
#   ["B", 1372]
#   ["C", 1507]
#   ["D", 791]
#   ...

さらにこのメソッドは以下の値を特別扱いします。

  • ブロックの評価値が nil もしくは :_separator であった場合、 その要素を捨てます。チャンクはこの前後で区切られます。
  • ブロックの評価値 :_alone であった場合はその要素は 単独のチャンクをなすものと解釈されます。

アンダースコアで始まるシンボルはこのメソッドでは予約されています。 ブロックの返り値としては用いないでください。

nil、 :_separator はある要素を無視したい場合に用います。 例として svn log の出力のハイフンの所で区切りたい場合を考えます。 

sep = "-"*72 + "\n" # ハイフンが72個の行
IO.popen("svn log README") {|f|
  f.chunk {|line|
    line != sep || nil
  }.each {|_, lines|
    pp lines
  }
}
#=> ["r20018 | knu | 2008-10-29 13:20:42 +0900 (Wed, 29 Oct 2008) | 2 lines\n",
#    "\n",
#    "* README, README.ja: Update the portability section.\n",
#    "\n"]
#   ["r16725 | knu | 2008-05-31 23:34:23 +0900 (Sat, 31 May 2008) | 2 lines\n",
#    "\n",
#    "* README, README.ja: Add a note about default C flags.\n",
#    "\n"]
#   ...

テキストを空行で区切られた段落に分けたい場合にも nil が使えます。 

File.foreach("README").chunk {|line|
  /\A\s*\z/ !~ line || nil
}.each {|_, lines|
  pp lines
}

「:_alone」は要素を素通ししたい場合に用います。 以下の例では「Foo#bar」という形式の行が連続している場合のみ チャンク化し、それ以外は素通しします。 

pat = /\A[A-Z][A-Za-z0-9_]+\#/
open(filename) {|f|
  f.chunk {|line| pat =~ line ? $& : :_alone }.each {|key, lines|
    if key != :_alone
      print lines.sort.join('')
    else
      print lines.join('')
    end
  }
}

チャンク化に状態遷移が必要な場合は、 オプション引数 initial_state に状態を保持するオブジェクトを渡します。 この場合、ブロックの第2引数にはこのオブジェクトが dup で複製 されて渡されます。

[PARAM] initial_state:
状態を保持するオブジェクト
[EXCEPTION] RuntimeError:
予約されている値を用いた場合に発生します
clone -> Matrix

自分自身のコピーを返します。

coerce(other) -> Array

他の数値オブジェクトとの変換を行います。

他の数値オブジェクトをMatrix::Scalarのオブジェクトに変換し、selfとの組を配列として返します。

[PARAM] other:
変換する数値オブジェクト

例: 

a1 = [1, 2]
a2 = [-1.25, 2.2]
m = Matrix[a1, a2]
r = Rational(1, 2)
p m.coerce(r) #=> [#<Matrix::Scalar:0x832df18 @value=(1/2)>, Matrix[[1, 2], [-1.25, 2.2]]]
collect {|x| ... } -> Matrix
map {|x| ... } -> Matrix

行列の各要素に対してブロックの適用を繰り返した結果を、要素として持つ行列を生成します。

例: 

a1 = [ 1,  2,   3]
a2 = [10, 15,  20]
a3 = [-1, -2, 1.5]
m = Matrix[a1, a2, a3]

# 行列mのすべての要素に100を加える。
p m.collect { |x|
  x + 100
} #=> Matrix[[101, 102, 103], [110, 115, 120], [99, 98, 101.5]]
collect -> Enumerator
map -> Enumerator
collect {|item| ... } -> [object]
map {|item| ... } -> [object]

各要素に対してブロックを評価した結果を全て含む配列を返します。

ブロックを省略した場合、上で説明した繰り返しを実行し、その結果として 得られる配列を返すような Enumerator オブジェクトを返します。

例: 

# すべて 3 倍にする
p [1, 2, 3].map {|n| n * 3 }  # => [3, 6, 9]
flat_map -> Enumerator
collect_concat -> Enumerator
flat_map {| obj | block } -> Array
collect_concat {| obj | block } -> Array

各要素をブロックに渡し、その返り値を連結した配列を返します。

ブロックの返り値は基本的に配列を返すべきです。

ブロックを省略した場合は、ブロックを受けとり 上で説明した評価をし、その結果の配列を返す Enumerator オブジェクトを返します。 

[[1,2], [3,4]].flat_map{|i| i.map{|j| j*2}} # => [2,4,6,8]
column(j) -> Vector
column(j) {|x| ... } -> nil

第j番目の列ベクトルを返します。

selfのj列目を列ベクトルとして返します。 ブロックが与えられたときは、各列ベクトルの要素についてブロックを繰り返します。

[PARAM] j:
列ベクトルの位置を指定します。
注意

引数jは0オリジンで指定することに注意してください。

例: 

a1 = [ 1,  2,   3]
a2 = [10, 15,  20]
a3 = [-1, -2, 1.5]
m = Matrix[a1, a2, a3]

p m.column(1) #=> Vector[2, 15, -2]

cnt = 0
m.column(0) { |x|
  cnt = cnt + x
}
p cnt #=> 24.5
column_size -> Fixnum

列の大きさを返します。

column_vectors -> Array

自分自身を列ベクトルの配列として返します。

例: 

a1 = [ 1,  2,  3]
a2 = [10, 15, 20]
a3 = [-1, -2, 1.5]
m = Matrix[a1, a2, a3]

p m.row_vectors #=> [Vector[1, 10, -1], Vector[2, 15, -2], Vector[3, 20, 1.5]]
conjugate -> Matrix
conj -> Matrix

[TODO]

Returns the conjugate of the matrix. 

Matrix[[Complex(1,2), Complex(0,1), 0], [1, 2, 3]]
  => 1+2i   i  0
        1   2  3
Matrix[[Complex(1,2), Complex(0,1), 0], [1, 2, 3]].conjugate
  => 1-2i  -i  0
        1   2  3
count -> Integer
count(item) -> Integer
count {|obj| ... } -> Integer

レシーバの要素数を返します。

引数を指定しない場合は、レシーバの要素数を返します。 このとき、レシーバが size メソッドを持っていればそちらを使用します。 レシーバが size メソッドを持っていない場合は、要素数を一つずつカウントします。

引数を一つ指定した場合は、レシーバの要素のうち引数に一致するものの 個数をカウントして返します(一致は == で判定します)。

ブロックを指定した場合は、ブロックを評価して真になった要素の個数を カウントして返します。

[PARAM] item:
カウント対象となる値。

例: 

ary = [1, 2, 4, 2]
ary.count             # => 4
ary.count(2)          # => 2
ary.count{|x|x%2==0}  # => 3
cycle(n=nil) -> Enumerator
cycle(n=nil) {|obj| ... } -> object | nil

Enumerable オブジェクトの各要素を n 回 or 無限回(n=nil)繰り返し ブロックを呼びだします。

n に 0 もしくは負の値を渡した場合は何もしません。 繰り返しが最後まで終了した場合(つまりbreakなどで中断しなかった場合) は nil を返します。 このメソッドは内部の配列に各要素を保存しておくため、 一度 Enumerable の終端に到達した後に自分自身を変更しても このメソッドの動作に影響を与えません。 

a = ["a", "b", "c"]
a.cycle {|x| puts x }  # print, a, b, c, a, b, c,.. forever.
a.cycle(2) {|x| puts x }  # print, a, b, c, a, b, c.

ブロックを省略した場合は、n 回 or 無限回 enum の各要素を 繰り返す Enumerator を返します。

[RETURN]
ブロックを指定しなかった場合は、Enumerator を返します。 レシーバが空の場合は nil を返します。
determinant -> Rational | Float
det -> Rational | Float

行列式 (determinant) を返します。

行列式 (determinant) の値を返します。 self が正方行列ではない場合は0を返します。

注意

全ての要素が整数である場合、正しい答を返さないかも知れません。 その場合は mathn を require して下さい。 

p Matrix[[2, 1], [-1, 2]].det #=> 6

p Matrix[[2.0, 1.0], [-1.0, 2.0]].det #=> 5.0

require 'mathn'
p Matrix[[2, 1], [-1, 2]].det #=> 5
determinant_e -> Rational | Float
det_e -> Rational | Float

行列式 (determinant) を返します。

ユークリッドアルゴリズムに基づいて行列式を計算します。 行列の全成分が整数(Integer)の場合は正しい値を返します。 成分にFloatがあった場合には正しい値を返さないかもしれません。

find(ifnone = nil) -> Enumerator
detect(ifnone = nil) -> Enumerator
find(ifnone = nil) {|item| ... } -> object
detect(ifnone = nil) {|item| ... } -> object

要素に対してブロックを評価した値が真になった最初の要素を返します。

真になる要素が見つからず、ifnone も指定されていないときは nil を返します。 真になる要素が見つからず、ifnone が指定されているときは ifnone を call した結果を返します。

ブロックを省略した場合は、各要素に対しブロックを真になるまで評価し、最初に 真になった値を返すような Enumerator を返します。

[PARAM] ifnone:
call メソッドを持つオブジェクト (例えば Proc) を指定します。

例: 

# 最初の 3 の倍数を探す
p [1, 2, 3, 4, 5].find {|i| i % 3 == 0 }   # => 3
p [2, 2, 2, 2, 2].find {|i| i % 3 == 0 }   # => nil

# ifnone の使用例
ifnone = proc { raise ArgumentError, "item not found" }
p [1, 2, 3, 4, 5].find(ifnone) {|i| i % 7 == 0 }
    # ArgumentError: item not found
drop(n) -> Array

Enumerable オブジェクトの先頭の n 要素を捨てて、 残りの要素を配列として返します。

[PARAM] n:
捨てる要素数。 
a = [1, 2, 3, 4, 5, 0]
a.drop(3)             # => [4, 5, 0]
drop_while -> Enumerator
drop_while {|element| ... } -> Array

ブロックを評価して最初に偽となった要素の手前の要素まで捨て、 残りの要素を配列として返します。

ブロックを指定しなかった場合は、Enumerator を返します。 

a = [1, 2, 3, 4, 5, 0]
a.drop_while {|i| i < 3 }   # => [3, 4, 5, 0]
each {|e| ... } -> self

[TODO]

Yields all elements of the matrix, starting with those of the first row, or returns an Enumerator is no block given 

Matrix[ [1,2], [3,4] ].each { |e| puts e }
 # => prints the numbers 1 to 4
each_cons(n) -> Enumerator
each_cons(n) {|list| ... } -> nil

要素を重複ありで n 要素ずつに区切り、 ブロックに渡して繰り返します。

ブロックを省略した場合は重複ありで n 要素ずつ繰り返す Enumerator を返します。

[PARAM] n:
ブロックに渡す要素の数です。正の整数を与えます。 要素数より大きな数を与えると、ブロックは一度も実行されません。

例: 

(1..10).each_cons(3){|v| p v }
# => [1, 2, 3]
#    [2, 3, 4]
#    [3, 4, 5]
#    [4, 5, 6]
#    [5, 6, 7]
#    [6, 7, 8]
#    [7, 8, 9]
#    [8, 9, 10]

[SEE_ALSO] Enumerable#each_slice

each_entry -> Enumerator
each_entry {|obj| block} -> self

ブロックを各要素に一度ずつ適用します。

一要素として複数の値が渡された場合はブロックには配列として渡されます。 

class Foo
  include Enumerable
  def each
    yield 1
    yield 1,2
  end
end
Foo.new.each_entry{|o| print o, " -- "}
# => 1 -- [1, 2] --

ブロックを省略した場合は Enumerator が返されます。

[SEE_ALSO] Enumerable#slice_before

each_slice(n) -> Enumerator
each_slice(n) {|list| ... } -> nil

n 要素ずつブロックに渡して繰り返します。

要素数が n で割り切れないときは、最後の回だけ要素数が減ります。

ブロックを省略した場合は n 要素ずつ繰り返す Enumerator を返します。

[PARAM] n:
区切る要素数を示す整数です。

例: 

(1..10).each_slice(3) {|a| p a}
    # => [1, 2, 3]
    #    [4, 5, 6]
    #    [7, 8, 9]
    #    [10]

[SEE_ALSO] Enumerable#each_cons

each_with_index {|e, row, col| ... } -> self

[TODO]

Yields all elements of the matrix, starting with those of the first row, along with the row index and column index, or returns an Enumerator is no block given 

Matrix[ [1,2], [3,4] ].each_with_index do |e, row, col|
  puts "#{e} at #{row}, #{col}"
end
  # => 1 at 0, 0
  # => 2 at 0, 1
  # => 3 at 1, 0
  # => 4 at 1, 1
each_with_index -> Enumerator
each_with_index {|item, index| ... } -> self

要素とそのインデックスをブロックに渡して繰り返します。

self を返します。

ブロックを省略した場合は、 要素とそのインデックスを繰り返すような Enumerator を返します。

例: 

[5, 10, 15].each_with_index do |n, idx|
  p [n, idx]
end
    # => [5, 0]
    #    [10, 1]
    #    [15, 2]
each_with_object(obj) -> Enumerator
each_with_object(obj) {|(*args), memo_obj| ... } -> object

与えられた任意のオブジェクトと要素をブロックに渡し繰り返し、最初に与えられたオブジェクトを返します。

ブロックを省略した場合は、上の繰り返しをして、最初に与えたオブジェクトを 最後に返す Enumerator を返します。

[PARAM] obj:
任意のオブジェクトを指定します。 
evens = (1..10).each_with_object([]) {|i, a| a << i*2 }
# => [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

[SEE_ALSO] Enumerator#with_object

elements_to_f -> Array

各要素を浮動小数点数 Float に変換した行列を返します。

elements_to_i -> Array

各要素を整数 Integer に変換した行列を返します。

elements_to_r -> Array

各要素を有理数 Rational に変換した行列を返します。

empty? -> bool

[TODO]

Returns +true+ if this is an empty matrix, i.e. if the number of rows or the number of columns is 0.

to_a -> [object]
entries -> [object]

全ての要素を含む配列を返します。

find_all -> Enumerator
select -> Enumerator
find_all {|item| ... } -> [object]
select {|item| ... } -> [object]

各要素に対してブロックを評価した値が真であった要素を全て含む配列を 返します。真になる要素がひとつもなかった場合は空の配列を返します。

ブロックを省略した場合は、各要素に対しブロックを評価し 真になった値の配列を返すような Enumerator を返します。

find_index -> Enumerator
find_index {|obj| ... } -> Integer | nil

要素を先頭から順にブロックに渡して評価し、最初に真になった要素のインデックスを返します。 一つも真にならなければ nil を返します。 

(1..10).find_index  {|i| i % 5 == 0 and i % 7 == 0 }   #=> nil
(1..100).find_index {|i| i % 5 == 0 and i % 7 == 0 }   #=> 34

ブロックを指定しなかった場合は、Enumerator を返します。

first -> object | nil
first(n) -> Array

Enumerable オブジェクトの最初の要素、もしくは最初の n 要素を返します。

Enumerable オブジェクトが空の場合、引数を指定しない形式では nil を返します。 引数を指定する形式では、空の配列を返します。

[PARAM] n:
取得する要素数。 
e = "abcd".each_byte
e.first #=> 97
e.first(2) #=> [97,98]
e = "".each_byte
e.first #=> nil
e.first(2) #=> []
grep(pattern) -> [object]
grep(pattern) {|item| ... } -> [object]

pattern === item が成立する要素を全て含んだ配列を返します。

ブロックとともに呼び出された時には条件の成立した要素に対して それぞれブロックを評価し、その結果の配列を返します。 マッチする要素がひとつもなかった場合は空の配列を返します。

[PARAM] pattern:
「===」メソッドを持つオブジェクトを指定します。

例: 

  ['aa', 'bb', 'cc', 'dd', 'ee'].grep(/[bc]/)  # => ["bb", "cc"]

Array.instance_methods.grep(/gr/) # => [:grep, :group_by]
group_by -> Enumerator
group_by {|obj| ... } -> Hash

ブロックを評価した結果をキー、対応する要素の配列を値とするハッシュを返します。 

(1..6).group_by {|i| i%3}   #=> {0=>[3, 6], 1=>[1, 4], 2=>[2, 5]}

ブロックを省略した場合は、最後に Hash を返す Enumerator オブジェクトを返します。

hash -> Fixnum

行列のHash値を返します。

imaginary -> Matrix
imag -> Matrix

[TODO]

Returns the imaginary part of the matrix. 

Matrix[[Complex(1,2), Complex(0,1), 0], [1, 2, 3]]
  => 1+2i  i  0
        1  2  3
Matrix[[Complex(1,2), Complex(0,1), 0], [1, 2, 3]].imaginary
  =>   2i  i  0
        0  0  0
member?(val) -> bool
include?(val) -> bool

val と == の関係にある要素を含むとき真を返します。

[PARAM] val:
任意のオブジェクト
inject(init = self.first) {|result, item| ... } -> object
inject(sym) -> object
inject(init, sym) -> object
reduce(init = self.first) {|result, item| ... } -> object
reduce(sym) -> object
reduce(init, sym) -> object

リストのたたみこみ演算を行います。

最初に初期値 init と self の最初の要素を引数にブロックを実行します。 2 回目以降のループでは、前のブロックの実行結果と self の次の要素を引数に順次ブロックを実行します。 そうして最後の要素まで繰り返し、最後のブロックの実行結果を返します。

要素が存在しない場合は init を返します。

初期値 init を省略した場合は、 最初に先頭の要素と 2 番目の要素をブロックに渡します。 また要素が 1 つしかなければブロックを実行せずに最初の要素を返します。 要素がなければブロックを実行せずに nil を返します。

[PARAM] init:
最初の result の値です。任意のオブジェクトが渡せます。
[PARAM] sym:
ブロックの代わりに使われるメソッド名を表す Symbol オブジェクトを指定します。 実行結果に対して sym という名前のメソッドが呼ばれます。

例: 

# 合計を計算する。
p [2, 3, 4, 5].inject {|result, item| result + item }        #=> 14

# 自乗和を計算する。初期値をセットする必要がある。
p [2, 3, 4, 5].inject(0) {|result, item| result + item**2 }  #=> 54

この式は以下のように書いても同じ結果が得られます。 

result = 0
[1, 2, 3, 4, 5].each {|v| result += v }
p result   # => 15

p [1, 2, 3, 4, 5].inject(:+)                    #=> 15
p ["b", "c", "d"].inject("abbccddde", :squeeze) #=> "abcde"
inspect -> String

自分自身を見やすい形式に文字列化し、その文字列を返します。

例: 

a1 = [1, 2]
a2 = [3, 4.5]
m = Matrix[a1, a2]

p m.to_s #=> "Matrix[[1, 2], [3, 4.5]]"
inverse -> Matrix
inv -> Matrix

逆行列を返します。

inverse_from(src) -> Matrix

行列1次方程式の解(の行列)を返します。

行列1次方程式の解(の行列)を返します。 行列の関として src * X = self となるような行列Xを返します。 srcが正則行列ではないでは場合には、ExceptionForMatrix::ErrNotRegularの例外が発生します。

注意

inverse_fromメソッドは破壊的なメソッドです。

例: 

a1 = [1, 2]
a2 = [3, 4.5]
m = Matrix[a1, a2]

b1 = [1, 0]
b2 = [-1, 1]
n = Matrix[b1, b2]

p x = m.inverse_from(n) #=> Matrix[[1, 2.0], [4, 6.5]]
p m #=> Matrix[[1, 2.0], [4, 6.5]]
p n * x #=> Matrix[[1, 2.0], [3, 4.5]]
max -> object

最大の要素を返します。 全要素が互いに <=> メソッドで比較できることを仮定しています。

要素が存在しなければ nil を返します。 該当する要素が複数存在する場合、どの要素を返すかは不定です。

max {|a, b| ... } -> object

ブロックの評価結果で各要素の大小判定を行い、最大の要素を返します。 要素が存在しなければ nil を返します。

ブロックの値は、a > b のとき正、 a == b のとき 0、a < b のとき負の整数を、期待しています。

該当する要素が複数存在する場合、どの要素を返すかは不定です。

[EXCEPTION] TypeError:
ブロックが整数以外を返したときに発生します。
max_by -> Enumerator
max_by {|item| ... } -> object

各要素を順番にブロックに渡して実行し、 その評価結果を <=> で比較して、 最大であった値に対応する元の要素を返します。

要素が存在しないときは nil を返します。 該当する要素が複数存在する場合、どの要素を返すかは不定です。

Enumerable#max と Enumerable#max_by の 違いは Enumerable#sort と Enumerable#sort_by の違いと同じです。

ブロックを省略した場合は、各要素を順番にブロックに渡して評価し、 その結果が最小となる値に対応する要素を返す Enumerator を 返します。

[SEE_ALSO] Enumerable#sort_by

min -> object

最小の要素を返します。 全要素が互いに <=> メソッドで比較できることを仮定しています。

要素が存在しなければ nil を返します。 該当する要素が複数存在する場合、どの要素を返すかは不定です。

min {|a, b| ... } -> object

ブロックの評価結果で各要素の大小判定を行い、最小の要素を返します。 要素が存在しなければ nil を返します。

ブロックの値は、a > b のとき正、a == b のとき 0、 a < b のとき負の整数を、期待しています。

該当する要素が複数存在する場合、どの要素を返すかは不定です。

[EXCEPTION] TypeError:
ブロックが整数以外を返したときに発生します。
min_by -> Enumerator
min_by {|item| ... } -> object

各要素を順番にブロックに渡して評価し、 その評価結果を <=> で比較して、 最小であった値に対応する元の要素を返します。

要素が存在しないときは nil を返します。

該当する要素が複数存在する場合、どの要素を返すかは不定です。

ブロックを省略した場合は、各要素を順番にブロックに渡して評価し、 その結果が最小となる値に対応する要素を返す Enumerator を 返します。

Enumerable#min と Enumerable#min_by の 違いは Enumerable#sort と Enumerable#sort_by の違いと同じです。

[SEE_ALSO] Enumerable#sort_by

minmax -> [object, object]
minmax {|a, b| ... } -> [object, object]

Enumerable オブジェクトの各要素のうち最小の要素と最大の要素を 要素とするサイズ 2 の配列を返します。

該当する要素が複数存在する場合、どの要素を返すかは不定です。

一つ目の形式は、Enumerable オブジェクトのすべての要素が Comparable を 実装していることを仮定しています。二つ目の形式では、要素同士の比較を ブロックを用いて行います。 

a = %w(albatross dog horse)
a.minmax                                 #=> ["albatross", "horse"]
a.minmax{|a,b| a.length <=> b.length }   #=> ["dog", "albatross"]
[].minmax # => [nil, nil]

[SEE_ALSO] Enumerable#sort

minmax_by -> Enumerator
minmax_by {|obj| ... } -> [object, object]

Enumerable オブジェクトの各要素をブロックに渡して評価し、その結果を <=> で比較して 最小の要素と最大の要素を要素とするサイズ 2 の配列を返します。

該当する要素が複数存在する場合、どの要素を返すかは不定です。

Enumerable#minmax と Enumerable#minmax_by の 違いは sort と sort_by の違いと同じです。 詳細は Enumerable#sort_by を参照してください。 

a = %w(albatross dog horse)
a.minmax_by {|x| x.length }   #=> ["dog", "albatross"]

[].minmax_by{} # => [nil, nil]

ブロックを省略した場合は、Enumerator オブジェクトを 返します。

[SEE_ALSO] Enumerable#sort_by

minor(from_row, row_size, from_col, col_size) -> Matrix
minor(from_row..to_row, from_col..to_col) -> Matrix

selfの部分行列を返します。

自分自身の部分行列を返します。 ただし、パラメータは次の方法で指定します。

  1. 開始行番号, 行の大きさ, 開始列番号, 列の大きさ
  2. 開始行番号..終了行番号, 開始列番号..終了列番号
[PARAM] from_row:
部分行列の開始行(0オリジンで指定)
[PARAM] row_size:
部分行列の行サイズ
[PARAM] from_col:
部分行列の開始列(0オリジンで指定)
[PARAM] col_size:
部分行列の列サイズ

例: 

a1 = [ 1,  2,  3,  4,  5]
a2 = [11, 12, 13, 14, 15]
a3 = [21, 22, 23, 24, 25]
a4 = [31, 32, 33, 34, 35]
a5 = [51, 52, 53, 54, 55]
m = Matrix[a1, a2, a3, a4, a5]

p m.minor(0, 2, 1, 2) #=> Matrix[[2, 3], [12, 13]]
none? -> bool
none? {|obj| ... } -> bool

ブロックを指定しない場合は、 Enumerable オブジェクトのすべての 要素が偽であれば真を返します。そうでなければ偽を返します。

ブロックを指定した場合は、Enumerable オブジェクトのすべての要素を ブロックで評価した結果が、すべて偽であれば真を返します。 そうでなければ偽を返します。 

%w{ant bear cat}.none? {|word| word.length == 5}  #=> true
%w{ant bear cat}.none? {|word| word.length >= 4}  #=> false
[].none?                                          #=> true
[nil].none?                                       #=> true
[nil,false].none?                                 #=> true
one? -> bool
one? {|obj| ... } -> bool

ブロックを指定しない場合は、 Enumerable オブジェクトの要素のうち ちょうど一つだけが真であれば、真を返します。 そうでなければ偽を返します。

ブロックを指定した場合は、Enumerable オブジェクトの要素を ブロックで評価した結果、一つの要素だけが真であれば真を返します。 そうでなければ偽を返します。 

%w{ant bear cat}.one? {|word| word.length == 4}   #=> true
%w{ant bear cat}.one? {|word| word.length >= 4}   #=> false
[ nil, true, 99 ].one?                            #=> false
[ nil, true, false ].one?                         #=> true
partition -> Enumerator
partition {|item| ... } -> [[object], [object]]

各要素を、ブロックの条件を満たす要素と満たさない要素に分割します。 各要素に対してブロックを評価して、その値が真であった要素の配列と、 偽であった要素の配列の 2 つを配列に入れて返します。

ブロックを省略した場合は、各要素に対しブロックを評価し、 上のようにその値が真であった要素の配列と、 偽であった要素の配列のペアを返すような Enumerator を 返します。

例: 

[10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0].partition {|i| i % 3 == 0 }
 #=> [[9, 6, 3, 0], [10, 8, 7, 5, 4, 2, 1]]
rank -> Fixnum

階数 (rank) を返します。

selfの行列の階数(rank)を返します。 行列の成分がFloatの場合は正しい値を返さない場合があります。 その場合は行列成分にRationalを用いるか、Matrix#rank_eを使用してください。

rank_e -> Fixnum

階数 (rank) を返します。

ユークリッドアルゴリズムに基づいて階数(rank)を計算します。 行列の全成分が整数(Integer)の場合は正しい値を返します。 成分にFloatがあった場合には正しい値を返さないかもしれません。

real -> Matrix

[TODO]

Returns the real part of the matrix. 

Matrix[[Complex(1,2), Complex(0,1), 0], [1, 2, 3]]
  => 1+2i  i  0
        1  2  3
Matrix[[Complex(1,2), Complex(0,1), 0], [1, 2, 3]].real
  =>    1  0  0
        1  2  3
real? -> bool

[TODO]

Returns +true+ if all entries of the matrix are real.

rectangular -> [Matrix, Matrix]
rect -> [Matrix, Matrix]

[TODO]

Returns an array containing matrices corresponding to the real and imaginary parts of the matrix 

m.rect == [m.real, m.imag]  # ==> true for all matrices m
regular? -> bool

正則(regular)なら真(true)を返します。

行列が正則であるとは、正方行列であり、かつ、その逆行列が存在することです。

例: 

a1 = [ 1,  2,  3]
a2 = [10, 15, 20]
a3 = [-1, -2, 1.5]
m = Matrix[a1, a2, a3]
p m.regular? #=> true

a1 = [ 1,  2,  3]
a2 = [10, 15, 20]
a3 = [-1, -2, -3]
m = Matrix[a1, a2, a3]
p m.regular? #=> false

a1 = [ 1,  2,  3]
a2 = [10, 15, 20]
a3 = [-1, -2, 1.5]
a4 = [1, 1, 1]
m = Matrix[a1, a2, a3, a4]
p m.regular? #=> false
reject -> Enumerator
reject {|item| ... } -> [object]

各要素に対してブロックを評価し、 その値が偽であった要素を集めた新しい配列を返します。 条件を反転させた select です。

ブロックを省略した場合は、各要素に対しブロックを評価し 偽になった値の配列を返すような Enumerator を返します。

例: 

# 偶数を除外する (奇数を集める)
[1, 2, 3, 4, 5, 6].reject {|i| i % 2 == 0 }  # => [1, 3, 5]

[SEE_ALSO] Enumerable#select

reverse_each -> Enumerator
reverse_each {|element| ... } -> self

逆順に各要素に対してブロックを評価します。

内部で各要素を保持した配列を作ります。

ブロックを省略した場合は、各要素を逆順に辿る Enumerator を返します。

row(i) -> Vector
row(i) {|x| ... } -> nil

第i番目の行ベクトルを返します。

selfのi行目を行ベクトルとして返します。 ブロックが与えられたときは、各行ベクトルの要素についてブロックを繰り返します。

[PARAM] i:
行ベクトルの位置を指定します。
注意

引数iは0オリジンで指定することに注意してください。

例: 

a1 = [1, 2, 3]
a2 = [10, 15, 20]
a3 = [-1, -2, 1.5]
m = Matrix[a1, a2, a3]

p m.row(1) #=> Vector[10, 15, 20]

cnt = 0
m.row(0) { |x|
  cnt = cnt + x
}
p cnt #=> 6
row_size -> Fixnum

行の大きさを返します。

row_vectors -> Array

自分自身を行ベクトルの配列として返します。

例: 

a1 = [ 1,  2,  3]
a2 = [10, 15, 20]
a3 = [-1, -2, 1.5]
m = Matrix[a1, a2, a3]

p m.row_vectors #=> [Vector[1, 2, 3], Vector[10, 15, 20], Vector[-1, -2, 1.5]]
singular? -> bool

特異(singular)なら真(true)を返します。

行列が特異(singular)であるとは、正則でないことです。

slice_before(pattern) -> Enumerator
slice_before {|elt| bool } -> Enumerator
slice_before(initial_state) {|elt, state| bool } -> Enumerator

パターンがマッチした要素、もしくはブロックが真を返した要素から 次にマッチする手前までを チャンク化(グループ化)したものを繰り返す Enumerator を 返します。

パターンを渡した場合は各要素に対し === が呼び出され、 それが真になったところをチャンクの先頭と見なします。 ブロックを渡した場合は、各要素に対しブロックを適用し 返り値が真であった要素をチャンクの先頭と見なします。

より厳密にいうと、「先頭要素」の手前で分割していきます。 最初の要素の評価は無視されます。

各チャンクは配列として表現されます。

Enumerable#map のようなメソッドを使うこともできます。 

# 偶数要素をチャンクの先頭と見なす
[0,2,4,1,2,4,5,3,1,4,2].slice_before(&:even?).to_a
# => [[0], [2], [4, 1], [2], [4, 5, 3, 1], [4], [2]]

# 奇数要素をチャンクの先頭と見なす
[0,2,4,1,2,4,5,3,1,4,2].slice_before(&:odd?).to_a
# => [[0, 2, 4], [1, 2, 4], [5], [3], [1, 4, 2]]

# ChangeLog のエントリーを順に取る
open("ChangeLog") {|f|
  f.slice_before(/\A\S/).each {|e| pp e}
}

# 上と同じだが、パターンでなくブロックを使う
open("ChangeLog") {|f|
  f.slice_before {|line| /\A\S/ === line }.each {|e| pp e}
}

# "svn proplist -R" の結果を分割する
# これは一要素が複数行にまたがっている

IO.popen([{"LC_ALL"=>"C"}, "svn", "proplist", "-R"]) {|f|
  f.lines.slice_before(/\AProp/).each {|lines| p lines }
}
#=> ["Properties on '.':\n", "  svn:ignore\n", "  svk:merge\n"]
#   ["Properties on 'goruby.c':\n", "  svn:eol-style\n"]
#   ["Properties on 'complex.c':\n", "  svn:mime-type\n", "  svn:eol-style\n"]
#   ["Properties on 'regparse.c':\n", "  svn:eol-style\n"]
#   ...

複数要素にわたる状態遷移が必要な場合は、ローカル変数でこれを実現する ことができます。例えば、連続に増える数値が3つ以上ある場合、これを まとめる処理をするためには以下のようにします。 

a = [0,2,3,4,6,7,9]
prev = a[0]
p a.slice_before {|e|
  prev, prev2 = e, prev
  prev2 + 1 != e
}.map {|es|
  es.length <= 2 ? es.join(",") : "#{es.first}-#{es.last}"
}.join(",")
#=> "0,2-4,6,7,9"

しかし、ローカル変数を使うのが不適切な場合もあります。 その場合、引数 initial_state に状態を保持するオブジェクトを 渡すと、そのオブジェクトを Object#dup したオブジェクトを 各要素ごとのブロック呼び出しの第2引数として渡します。 

# word wrapping.
# this assumes all characters have same width.
def wordwrap(words, maxwidth)
  # if cols is a local variable, 2nd "each" may start with non-zero cols.
  words.slice_before(cols: 0) {|w, h|
    h[:cols] += 1 if h[:cols] != 0
    h[:cols] += w.length
    if maxwidth < h[:cols]
      h[:cols] = w.length
      true
    else
      false
    end
  }
end
text = (1..20).to_a.join(" ")
enum = wordwrap(text.split(/\s+/), 10)
puts "-"*10
enum.each {|ws| puts ws.join(" ") }
puts "-"*10
#=> ----------
#   1 2 3 4 5
#   6 7 8 9 10
#   11 12 13
#   14 15 16
#   17 18 19
#   20
#   ----------

以下は mbox を分割する例です。mbox 内の各メールは Unix From line で始まっています。そこで slice_before を用います。 

# parse mbox
open("mbox") {|f|
  f.slice_before {|line|
    line.start_with? "From "
  }.each {|mail|
    unix_from = mail.shift
    i = mail.index("\n")
    header = mail[0...i]
    body = mail[(i+1)..-1]
    body.pop if body.last == "\n"
    fields = header.slice_before {|line| !" \t".include?(line[0]) }.to_a
    p unix_from
    pp fields
    pp body
  }
}

# split mails in mbox (slice before Unix From line after an empty line)
open("mbox") {|f|
  f.slice_before(emp: true) {|line,h|
    prevemp = h[:emp]
    h[:emp] = line == "\n"
    prevemp && line.start_with?("From ")
  }.each {|mail|
    mail.pop if mail.last == "\n"
    pp mail
  }
}
[PARAM] initial_state:
状態を保持するオブジェクト

[SEE_ALSO] Enumerable#chunk

sort -> [object]
sort {|a, b| ... } -> [object]

全ての要素を昇順にソートした配列を生成して返します。

ブロックなしのときは <=> メソッドを要素に対して呼び、 その結果をもとにソートします。

<=> 以外でソートしたい場合は、ブロックを指定します。 この場合、ブロックの評価結果を元にソートします。 ブロックの値は、a > b のとき正、a == b のとき 0、 a < b のとき負の整数を、期待しています。 ブロックが整数以外を返したときは例外 TypeError が発生します。

Enumerable#sort は安定ではありません (unstable sort)。 安定なソートが必要な場合は Enumerable#sort_by を使って工夫する必要があります。 詳しくは Enumerable#sort_by の項目を参照してください。

※ 比較結果が同じ要素は元の順序通りに並ぶソートを 「安定なソート (stable sort)」と言います。

[SEE_ALSO] Enumerable#sort_by

sort_by -> Enumerator
sort_by {|item| ... } -> [object]

ブロックの評価結果を <=> メソッドで比較することで、self を昇 順にソートします。ソートされた配列を新たに生成して返します。

つまり、以下とほぼ同じ動作をします。 

class Array
  def sort_by
    self.map {|i| [yield(i), i] }.
       sort {|a, b| a[0] <=> b[0] }.
       map {|i| i[1]}
  end
end

Enumerable#sort と比較して sort_by が優れている点として、 比較条件が複雑な場合の速度が挙げられます。 sort_by を使わない以下の例では比較を行う度に downcase が実行されます。 従って downcase の実行速度が遅ければ sort の速度が致命的に低下します。 

p ["BAR", "FOO", "bar", "foo"].sort {|a, b| a.downcase <=> b.downcase }

一方、次のように sort_by を使うと downcase の実行回数は要素数と同じです。 つまり、その部分の実行時間は O(n) のオーダーです。 

p ["BAR", "FOO", "bar", "foo"].sort_by {|v| v.downcase }

以下の、実行回数の検証結果を参照してみてください。 

class Integer
  def count
    $n += 1
    self
  end
end

ary = []
1.upto(1000) {|v| ary << rand(v) }

$n = 0
ary.sort {|a,b| a.count <=> b.count }
p $n          # => 18200

$n = 0
ary.sort_by {|v| v.count }
p $n          # => 1000

Enumerable#sort_by は安定ではありません (unstable sort)。 ただし、sort_by を以下のように使うと安定なソートを実装できます。 

i = 0
ary.sort_by {|v| [v, i += 1] }

※ 比較結果が同じ要素は元の順序通りに並ぶソートを 「安定なソート (stable sort)」と言います。

ブロックを省略した場合は、各要素をブロックで評価した値でソートした 配列を返すような Enumerator を返します。

[SEE_ALSO] Enumerable#sort

square? -> bool

正方行列であるなら、真を返します。

transpose -> Matrix
t -> Matrix

転置行列 (transpose matrix) を返します。

self をMatrixのオブジェクトで、(m,n)型行列としたとき a(j,i) を (i,j) 要素とする (n,m) 型行列を返します。

take(n) -> Array

Enumerable オブジェクトの先頭から n 要素を配列として返します。

[PARAM] n:
要素数を指定します。 
a = [1, 2, 3, 4, 5, 0]
a.take(3)             # => [1, 2, 3]
take_while -> Enumerator
take_while {|element| ... } -> Array

Enumerable オブジェクトの要素を順に偽になるまでブロックで評価します。 最初に偽になった要素の手前の要素までを配列として返します。 

a = [1, 2, 3, 4, 5, 0]
a.take_while {|i| i < 3 }   # => [1, 2]

ブロックを省略した場合は、Enumerator オブジェクトを 返します。

to_a -> Array

自分自身をArrayに変換したものを返します。

行ベクトルを配列(Array)としたものの配列(つまり配列の配列)として返します。

例: 

a1 = [ 1,  2,  3]
a2 = [10, 15, 20]
a3 = [-1, -2, 1.5]
m = Matrix[a1, a2, a3]

p m.to_a #=> [[1, 2, 3], [10, 15, 20], [-1, -2, 1.5]]

[TODO]

[TODO]

[TODO]

to_s -> String

行列を文字列化し、その文字列を返します。

例: 

a1 = [1, 2]
a2 = [3, 4.5]
m = Matrix[a1, a2]

p m.to_s #=> "Matrix[[1, 2], [3, 4.5]]"
trace -> Fixnum | Float | Rational
tr -> Fixnum | Float | Rational

トレース (trace) を返します。

行列のトレース (trace) とは、対角要素の和です。

例: 

Matrix[[7,6], [3,9]].trace #=> 16
zip(*lists) -> [[object]]
zip(*lists) {|v1, v2, ...| ...} -> nil

self と引数に渡した配列の各要素からなる配列の配列を生成して返します。 生成される配列の要素数は self の要素数と同じです。

ブロック付きで呼び出した場合は、 self と引数に渡した配列の各要素を順番にブロックに渡します。

[PARAM] lists:
配列を指定します。配列でない場合は to_ary メソッドにより配列に変換します。 to_ary メソッドが無い場合は each を試します。

例: 

p (1..3).zip([4,5,6], [7,8,9])
    # => [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

p (1..2).zip([:a,:b,:c], [:A,:B,:C,:D])
    # => [[1, :a, :A], [2, :b, :B]]

p (1..5).zip([:a,:b,:c], [:A,:B,:C,:D])
    # => [[1, :a, :A], [2, :b, :B],
    #     [3, :c, :C], [4, nil, :D], [5, nil, nil]]

例: 

p [1,2,3].zip([4,5,6], [7,8,9]) {|ary|
  p ary
}
    # => [1, 4, 7]
    #    [2, 5, 8]
    #    [3, 6, 9]
    #    nil
class Matrix