class Matrix

[edit]

要約

数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)といいます。インデックスは 0 から始まることに注意してください。

上から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)といいます。

目次

特異メソッド
インスタンスメソッド

継承しているメソッド

Enumerableから継承しているメソッド

特異メソッド

identity(n) -> Matrix[permalink][rdoc][edit]
unit(n) -> Matrix
I(n) -> Matrix

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

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

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

self[*rows] -> Matrix[permalink][rdoc][edit]

rows[i] を第 i 行とする行列を生成します。

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

require 'matrix'
m = Matrix[[11, 12], [21, 22]]
p m  # => Matrix[[11, 12], [21, 22]]
     #    [11, 12]
     #    [21, 22]
build(row_size, column_size = row_size) {|row, col| ... } -> Matrix[permalink][rdoc][edit]
build(row_size, column_size = row_size) -> Enumerable

row_size×column_sizeの行列をブロックの返り値から生成します。

行列の各要素の位置がブロックに渡され、それの返り値が行列の要素となります。

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

例

require 'matrix'
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
[PARAM] row_size:
行列の行数
[PARAM] column_size:
行列の列数
column_vector(column) -> Matrix[permalink][rdoc][edit]

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

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

引数 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]
combine(*matrices) {|*elements| ... } -> Matrix[permalink][rdoc][edit]
combine(*matrices) -> Enumerator

要素ごとにブロックを呼び出した結果を組み合わせた Matrix を返します。 

例

require 'matrix'
x = Matrix[[6, 6], [4, 4]]
y = Matrix[[1, 2], [3, 4]]
Matrix.combine(x, y) {|a, b| a - b} # => Matrix[[5, 4], [1, 0]]
[PARAM] matrices:
並べる行列。すべての行列の行数と列数が一致していなければならない
[EXCEPTION] ExceptionForMatrix::ErrDimensionMismatch:
行や列の要素数が一致しない時に発生します

[SEE_ALSO] Matrix#combine

diagonal(*values) -> Matrix[permalink][rdoc][edit]

対角要素が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]]]
empty(row_size=0, column_size=0) -> Matrix[permalink][rdoc][edit]

要素を持たない行列を返します。

「要素を持たない」とは、行数もしくは列数が0の行列のことです。

row_size 、 column_size のいずれか一方は0である必要があります。 

例

require 'matrix'
m = Matrix.empty(2, 0)
m == Matrix[ [], [] ]
# => true
n = Matrix.empty(0, 3)
n == Matrix.columns([ [], [], [] ])
# => true
m * n
# => Matrix[[0, 0, 0], [0, 0, 0]]
[PARAM] row_size:
行列の行数
[PARAM] column_size:
行列の列数
[EXCEPTION] ArgumentError:
row_size, column_size が両方とも0でない場合に発生します
hstack(*matrices) -> Matrix[permalink][rdoc][edit]

行列 matrices を横に並べた行列を生成します。 

例

require 'matrix'
x = Matrix[[1, 2], [3, 4]]
y = Matrix[[5, 6], [7, 8]]
Matrix.hstack(x, y) # => Matrix[[1, 2, 5, 6], [3, 4, 7, 8]]
[PARAM] matrices:
並べる行列。すべての行列の行数が一致していなければならない
[EXCEPTION] ExceptionForMatrix::ErrDimensionMismatch:
行数の異なる行列がある場合に発生します

[SEE_ALSO] Matrix.vstack, Matrix#hstack

row_vector(row) -> Matrix[permalink][rdoc][edit]

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

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

引数 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]]
[PARAM] rows:
配列の配列
[PARAM] copy:
配列を複製するかどうかを真偽値で指定
scalar(n, value) -> Matrix[permalink][rdoc][edit]

対角要素が全て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]]
vstack(*matrices) -> Matrix[permalink][rdoc][edit]

行列 matrices を縦に並べた行列を生成します。 

例

require 'matrix'
x = Matrix[[1, 2], [3, 4]]
y = Matrix[[5, 6], [7, 8]]
Matrix.vstack(x, y) # => Matrix[[1, 2], [3, 4], [5, 6], [7, 8]]
[PARAM] matrices:
並べる行列。すべての行列の列数が一致していなければならない
[EXCEPTION] ExceptionForMatrix::ErrDimensionMismatch:
列数の異なる行列がある場合に発生します

[SEE_ALSO] Matrix.hstack, Matrix#vstack

zero(n) -> Matrix[permalink][rdoc][edit]

n × n の零行列（要素が全て 0 の行列）を生成して返します。 

例

require 'matrix'
p Matrix.zero(2) #=> Matrix[[0, 0], [0, 0]]
[PARAM] n:
生成する正方零行列の次数
zero(row, column) -> Matrix[permalink][rdoc][edit]

row × column の零行列（要素が全て 0 の行列）を生成して返します。 

例

require 'matrix'
p Matrix.zero(2, 3) #=> Matrix[[0, 0, 0], [0, 0, 0]]
[PARAM] row:
生成する行列の行数
[PARAM] column:
生成する行列の列数

インスタンスメソッド

self * m -> Matrix | Vector[permalink][rdoc][edit]

self に行列またはベクトル m を右から乗じた行列を返します。

m が Vector オブジェクトなら返り値も Vector オブジェクトになります。

[PARAM] m:
右からの乗算が定義可能な行列やベクトルを指定します。
[EXCEPTION] ExceptionForMatrix::ErrDimensionMismatch:
次元が合わない場合に発生します
self * other -> Matrix[permalink][rdoc][edit]

self の各成分に数 other を掛けた行列を返します。

[PARAM] other:
self の各成分に掛ける Numeric オブジェクトを指定します。
self ** n -> Matrix[permalink][rdoc][edit]

self の n 乗を返します。

[PARAM] n:
べき数の指定
[EXCEPTION] ExceptionForMatrix::ErrNotRegular:
n が 0 以下で、行列が正則でない場合に発生します
self + m -> Matrix[permalink][rdoc][edit]

self に行列 m を加算した行列を返します。 self の column_size が 1 なら Vector オブジェクトも指定出来ます。

[PARAM] m:
加算する行列。加算可能な行列やベクトルを指定します。
[EXCEPTION] ExceptionForMatrix::ErrDimensionMismatch:
次元が合わない場合に発生します
+ self -> self[permalink][rdoc][edit]

単項 +。self を返します。

self - m -> Matrix[permalink][rdoc][edit]

self から行列mを減算した行列を返します。 self の column_size が 1 なら Vector オブジェクトも指定出来ます。

[PARAM] m:
減算する行列。減算可能な行列やベクトルを指定します。
[EXCEPTION] ExceptionForMatrix::ErrDimensionMismatch:
次元が合わない場合に発生します
- self -> Matrix[permalink][rdoc][edit]

単項 -。各要素の符号を反転させた行列を返します。

self / m -> Matrix[permalink][rdoc][edit]

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

[PARAM] m:
逆行列を右から乗算する行列。可逆行列でselfと乗算可能な行列を指定します。
[EXCEPTION] ExceptionForMatrix::ErrDimensionMismatch:
次元が合わない場合に発生します
[EXCEPTION] ExceptionForMatrix::ErrNotRegular:
m が正則でない場合に発生します
self / other -> Matrix[permalink][rdoc][edit]

self の各成分を数 other で割った行列を返します。

[PARAM] other:
self の各成分を割る Numeric オブジェクトを指定します。
self == other -> bool[permalink][rdoc][edit]
eql?(other) -> bool

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

[PARAM] other:
比較対象のオブジェクト
self[i, j] -> ()[permalink][rdoc][edit]
element(i, j) -> ()
component(i, j) -> ()

(i,j)要素を返します。行列の範囲外の値を指定した場合には nil を返します。

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

require 'matrix'

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
self[row, col] = v[permalink][rdoc][edit]

行が row、列が col である範囲を v に変更する。

[PARAM] row:
self の変更する行の範囲を Integer か Range で指定します。
[PARAM] col:
self の変更する列の範囲を Integer か Range で指定します。
[PARAM] v:
セットする要素を指定します。 v が Vector のとき、変更の対象範囲は Integer と Range で指定し、サイズが同じである必要があります。 v が Matrix のとき、変更の対象範囲と行数・列数が同じである必要があります。 v が上記以外のとき、変更の対象範囲の全ての要素を v に変更します。 

require 'matrix'

m = Matrix[[0, 0], [0, 0]]
m[0, 1] = 6
m[-1, -1] = 9
p m  # => Matrix[[0, 6], [0, 9]]

m = Matrix[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
m[0, 0..-1] = 5
m[1, 0..1] = Vector[2, 4]
m[2, 0..2] = Matrix[[3, 6, 9]]
p m #=> Matrix[[5, 5, 5], [2, 4, 0], [3, 6, 9]]

m = Matrix[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
m[0..2, 0..1] = 9
p m  # => Matrix[[9, 9, 0], [9, 9, 0], [9, 9, 0]]
m[1..-1, 0..1] = Matrix[[1, 2], [3, 4]]
p m  # => Matrix[[9, 9, 0], [1, 2, 0], [3, 4, 0]]
adjugate -> Matrix[permalink][rdoc][edit]

余因子行列を返します。 

例

require 'matrix'
Matrix[[7,6],[3,9]].adjugate # => Matrix[[9, -6], [-3, 7]]
[EXCEPTION] ExceptionForMatrix::ErrDimensionMismatch:
行列が正方でない場合に発生します。

[SEE_ALSO] Matrix#cofactor

antisymmetric? -> bool[permalink][rdoc][edit]
skew_symmetric? -> bool

行列が反対称行列 (交代行列、歪〔わい〕対称行列とも) ならば true を返します。

[EXCEPTION] ExceptionForMatrix::ErrDimensionMismatch:
行列が正方行列でない場合に発生します 

require 'matrix'

Matrix[[0, -2, Complex(1, 3)], [2, 0, 5], [-Complex(1, 3), -5, 0]].antisymmetric? # => true
Matrix.empty.antisymmetric? # => true

Matrix[[1, 2, 3], [4, 5, 6], [7, 8, 9]].antisymmetric? # => false
# 対角要素が違う
Matrix[[1, -2, 3], [2, 0, 6], [-3, -6, 0]].antisymmetric? # => false
# 符号が違う
Matrix[[0, 2, -3], [2, 0, 6], [-3, 6, 0]].antisymmetric? # => false
coerce(other) -> Array[permalink][rdoc][edit]

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

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

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

require 'matrix'
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]]]
cofactor(row, column) -> Integer | Rational | Float[permalink][rdoc][edit]

(row, column)-余因子を返します。

各要素の型によって返り値が変わります。

[PARAM] row:
行
[PARAM] column:
列
[EXCEPTION] ExceptionForMatrix::ErrDimensionMismatch:
行列が正方でない場合に発生します。

[SEE_ALSO] Matrix#adjugate

cofactor_expansion(row: nil, column: nil) -> object | Integer | Rational | Float[permalink][rdoc][edit]
laplace_expansion(row: nil, column: nil) -> object | Integer | Rational | Float

row 行、もしくは column 列に関するラプラス展開をする。

通常の行列に対してはこれは単に固有値を計算するだけです。かわりにMatrix#determinant を利用すべきです。

変則的な形状の行列に対してはそれ以上の意味を持ちます。例えば row行/column列が行列やベクトルである場合には 

例

require 'matrix'
# Matrix[[7,6], [3,9]].laplace_expansion(column: 1) # => 45
Matrix[[Vector[1, 0], Vector[0, 1]], [2, 3]].laplace_expansion(row: 0) # => Vector[3, -2]
[PARAM] row:
行
[PARAM] column:
列
[EXCEPTION] ArgumentError:
row と column を両方指定した、もしくは両方とも指定していない、場合に発生します
[EXCEPTION] ExceptionForMatrix::ErrDimensionMismatch:
行列が正方でない場合に発生します

[SEE_ALSO] Matrix#cofactor

map(which = :all) {|x| ... } -> Matrix[permalink][rdoc][edit]
collect(which = :all) {|x| ... } -> Matrix
map(which = :all) -> Enumerator
collect(which = :all) -> Enumerator

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

ブロックがない場合、 Enumerator を返します。

[PARAM] which:
which に以下の Symbol を指定することで、引数として使われる要素を限定できます。デフォルトは、:all (全ての要素)です。指定できる Symbol の詳細は、 Matrix#each の項目を参照して下さい。 
例

require 'matrix'

m = Matrix[[1, 2], [3, 4]]
p m.map { |x| x + 100 } # => Matrix[[101, 102], [103, 104]]
p m.map(:diagonal) { |x| x * 10 } # => Matrix[[10, 2], [3, 40]]

[SEE_ALSO] Matrix#each, Matrix#map!

map!(which = :all) {|element| ... } -> self[permalink][rdoc][edit]
collect!(which = :all) {|element| ... } -> self
map!(which = :all) -> Enumerator
collect!(which = :all) -> Enumerator

行列の各要素に対してブロックの適用を繰り返した結果で要素を置き換えます。

ブロックのない場合は、自身と map! から生成した Enumerator オブジェクトを返します。

[PARAM] which:
which に以下の Symbol を指定することで、引数として使われる要素を限定できます。デフォルトは、:all (全ての要素)です。指定できる Symbol の詳細は、 Matrix#each の項目を参照して下さい。 
例

require 'matrix'

m = Matrix[[1, 2], [3, 4]]

p m.map! { |element| element * 10 } #=> Matrix[[10, 20], [30, 40]]
p m                                 #=> Matrix[[10, 20], [30, 40]]

[SEE_ALSO] Matrix#each, Matrix#map

column(j) -> Vector | nil[permalink][rdoc][edit]
column(j) {|x| ... } -> self

j 番目の列を Vector オブジェクトで返します。 j 番目の列が存在しない場合は nil を返します。ブロックが与えられた場合はその列の各要素についてブロックを繰り返します。

[PARAM] j:
列の位置を指定します。先頭の列が 0 番目になります。j の値が負の時には末尾からのインデックスと見倣します。末尾の列が -1 番目になります。 
例

require 'matrix'

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(-1) { |x|
  cnt = cnt + x
}
p cnt # => 24.5
column_size -> Integer[permalink][rdoc][edit]
column_count -> Integer

行列の列数を返します。

column_vectors -> [Vector][permalink][rdoc][edit]

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

例

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

p m.column_vectors # => [Vector[1, 10, -1], Vector[2, 15, -2], Vector[3, 20, 1.5]]
combine(*matrices) {|*elements| ... } -> Matrix[permalink][rdoc][edit]

要素ごとにブロックを呼び出した結果を組み合わせた Matrix を返します。

Matrix.combine(self, *matrices) { ... } と同じです。

[SEE_ALSO] Matrix.combine

conjugate -> Matrix[permalink][rdoc][edit]
conj -> Matrix

複素共役を取った行列を返します。 

例

require '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
determinant -> Numeric[permalink][rdoc][edit]
det -> Numeric

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

Float を使用すると、精度が不足するため、誤った結果が生じる可能性があることに注意してください。代わりに、Rational や BigDecimal などの正確なオブジェクトを使用することを検討してください。

[EXCEPTION] ExceptionForMatrix::ErrDimensionMismatch:
正方行列でない場合に発生します 
例

require 'matrix'

p Matrix[[2, 1], [-1, 2]].det         #=> 5
p Matrix[[2.0, 1.0], [-1.0, 2.0]].det #=> 5.0
determinant_e -> Rational | Float[permalink][rdoc][edit]
det_e -> Rational | Float

このメソッドは deprecated です。 Matrix#determinant を代わりに使ってください。

diagonal? -> bool[permalink][rdoc][edit]

行列が対角行列ならば true を返します。

[EXCEPTION] ExceptionForMatrix::ErrDimensionMismatch:
行列が正方行列でない場合に発生します
each(which = :all) {|e| ... } -> self[permalink][rdoc][edit]
each(which = :all) -> Enumerator

行列の各要素を引数としてブロックを呼び出します。

0行目、1行目、…という順番で処理します。 which に以下の Symbol を指定することで引数として使われる要素を限定することができます。

  • :all - すべての要素(デフォルト)
  • :diagonal - 対角要素
  • :off_diagonal 対角要素以外
  • :lower 対角成分とそれより下側の部分
  • :upper対角成分とそれより上側の部分
  • :strict_lower 対角成分の下側
  • :strict_upper 対角成分の上側

ブロックを省略した場合、 Enumerator を返します。 

例

require 'matrix'
Matrix[ [1,2], [3,4] ].each { |e| puts e }
# => prints the numbers 1 to 4
Matrix[ [1,2], [3,4] ].each(:strict_lower).to_a # => [3]
[PARAM] which:
どの要素に対してブロックを呼び出すのかを Symbol で指定します

[SEE_ALSO] Matrix#each_with_index, Matrix#map

each_with_index(which = :all) {|e, row, col| ... } -> self[permalink][rdoc][edit]
each_with_index(which = :all) -> Enumerator

行列の各要素をその位置とともに引数としてブロックを呼び出します。

which で処理する要素の範囲を指定することができます。 Matrix#each と同じなのでそちらを参照してください。

ブロックを省略した場合、 Enumerator を返します。 

例

require 'matrix'
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
[PARAM] which:
どの要素に対してブロックを呼び出すのかを Symbol で指定します

[SEE_ALSO] Matrix#each

eigen -> Matrix::EigenvalueDecomposition[permalink][rdoc][edit]
eigensystem -> Matrix::EigenvalueDecomposition

行列の固有値と左右の固有ベクトルを保持したオブジェクトを返します。

Matrix::EigenvalueDecomposition は to_ary を定義しているため、多重代入によって3つの行列(右固有ベクトル、固有値行列、左固有ベクトル) を得ることができます。これを [V, D, W] と書くと、 (元の行列が対角化可能ならば)、 D は対角行列で、 self == V*D*W, V = W.inverse を満たします。 D のそれぞれの対角成分が行列の固有値です。 

例

require 'matrix'
m = Matrix[[1, 2], [3, 4]]
v, d, v_inv = m.eigensystem
d.diagonal? # => true
v.inv == v_inv # => true
(v * d * v_inv).round(5) == m # => true
[EXCEPTION] ExceptionForMatrix::ErrDimensionMismatch:
行列が正方行列でない場合に発生します

[SEE_ALSO] Matrix::EigenvalueDecomposition

elements_to_f -> Matrix[permalink][rdoc][edit]

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

このメソッドは deprecated です。 map(&:to_f) を使ってください。

elements_to_i -> Matrix[permalink][rdoc][edit]

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

このメソッドは deprecated です。 map(&:to_i) を使ってください。

elements_to_r -> Matrix[permalink][rdoc][edit]

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

このメソッドは deprecated です。 map(&:to_r) を使ってください。

empty? -> bool[permalink][rdoc][edit]

行列が要素を持たないならば true を返します。

要素を持たないとは、行数か列数のいずれかが0であることを意味します。

[SEE_ALSO] Matrix.empty

hadamard_product(m) -> Matrix[permalink][rdoc][edit]
entrywise_product(m) -> Matrix

アダマール積(要素ごとの積)を返します。

[EXCEPTION] ExceptionForMatrix::ErrDimensionMismatch:
行や列の要素数が一致しない時に発生します。 
例

require 'matrix'

Matrix[[1,2], [3,4]].hadamard_product(Matrix[[1,2], [3,2]]) # => Matrix[[1, 4], [9, 8]]
index(value, selector = :all) -> [Integer, Integer] | nil[permalink][rdoc][edit]
index(selector = :all) {|e| ... } -> [Integer, Integer] | nil
index(selector = :all) -> Enumerator
find_index(value, selector = :all) -> [Integer, Integer] | nil
find_index(selector = :all) {|e| ... } -> [Integer, Integer] | nil
find_index(selector = :all) -> Enumerator

指定した値と一致する要素の位置を [row, column] という配列で返します。ブロックを与えた場合は各要素を引数としてブロックを呼び出し、返り値が真であった要素の位置を返します。

複数の位置で値が一致する/ブロックが真を返す、場合は最初に見つかった要素の位置を返します。

selector で行列のどの部分を探すかを指定します。この引数の意味は Matrix#each を参照してください。 

例

require 'matrix'
Matrix[ [1,2], [3,4] ].index(&:even?) # => [0, 1]
Matrix[ [1,1], [1,1] ].index(1, :strict_lower) # => [1, 0]

value を指定せず、さらにブロックを省略した場合、 Enumerator を返します。

[PARAM] value:
探索する値
[PARAM] selector:
探索範囲
first_minor(row, column) -> Matrix[permalink][rdoc][edit]

self から第 row 行と第 column 列を取り除いた行列を返します。

[PARAM] row:
行
[PARAM] column:
列
[EXCEPTION] ArgumentError:
row, column が行列の行数/列数を越えている場合に発生します。
hash -> Integer[permalink][rdoc][edit]

行列のHash値を返します。

hermitian? -> bool[permalink][rdoc][edit]

行列がエルミートならば true を返します。

[EXCEPTION] ExceptionForMatrix::ErrDimensionMismatch:
行列が正方行列でない場合に発生します
hstack(*matrices) -> Matrix[permalink][rdoc][edit]

行列 self と matrices を横に並べた行列を生成します。

Matrix.hstack(self, *matrices) と同じです。 

例

require 'matrix'
x = Matrix[[1, 2], [3, 4]]
y = Matrix[[5, 6], [7, 8]]
x.hstack(y) # => Matrix[[1, 2, 5, 6], [3, 4, 7, 8]]
[PARAM] matrices:
並べる行列。すべての行列の行数がselfの行数と一致していなければならない
[EXCEPTION] ExceptionForMatrix::ErrDimensionMismatch:
行数の異なる行列がある場合に発生します

[SEE_ALSO] Matrix.hstack, Matrix#vstack

imaginary -> Matrix[permalink][rdoc][edit]
imag -> Matrix

行列の虚部を返します。 

例

require '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
inspect -> String[permalink][rdoc][edit]

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

例

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

p m.inspect # => "Matrix[[1, 2], [3, 4.5]]"
inverse -> Matrix[permalink][rdoc][edit]
inv -> Matrix

逆行列を返します。 

例

require 'matrix'

p Matrix[[2, 1], [3, 2]].inv         #=> Matrix[[(2/1), (-1/1)], [(-3/1), (2/1)]]

p Matrix[[2.0, 1.0], [3.0, 2.0]].inv #=> Matrix[[2.0000000000000004, -1.0000000000000002], [-3.000000000000001, 2.0000000000000004]]
lower_triangular? -> bool[permalink][rdoc][edit]

行列が下三角行列ならば true を返します。

lup -> Matrix::LUPDecomposition[permalink][rdoc][edit]
lup_decomposition -> Matrix::LUPDecomposition

行列の LUP 分解を保持したオブジェクトを返します。

Matrix::LUPDecomposition は to_ary を定義しているため、多重代入によって3つの行列(下三角行列、上三角行列、置換行列) を得ることができます。これを [L, U, P] と書くと、 L*U = P*self を満たします。 

例

require 'matrix'
a = Matrix[[1, 2], [3, 4]]
l, u, p = a.lup
l.lower_triangular? # => true
u.upper_triangular? # => true
p.permutation?      # => true
l * u == p * a      # => true
a.lup.solve([2, 5]) # => Vector[(1/1), (1/2)]

[SEE_ALSO] Matrix::LUPDecomposition

minor(from_row, row_size, from_col, col_size) -> Matrix[permalink][rdoc][edit]
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:
部分行列の列サイズ 
例

require 'matrix'
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]]
normal? -> bool[permalink][rdoc][edit]

行列が正規行列ならば true を返します。

[EXCEPTION] ExceptionForMatrix::ErrDimensionMismatch:
行列が正方行列でない場合に発生します
orthogonal? -> bool[permalink][rdoc][edit]

行列が直交行列ならば true を返します。

[EXCEPTION] ExceptionForMatrix::ErrDimensionMismatch:
行列が正方行列でない場合に発生します
permutation? -> bool[permalink][rdoc][edit]

行列が置換行列ならば true を返します。

[EXCEPTION] ExceptionForMatrix::ErrDimensionMismatch:
行列が正方行列でない場合に発生します
rank -> Integer[permalink][rdoc][edit]

階数 (rank) を返します。

Float を使用すると、精度が不足するため、誤った結果が生じる可能性があることに注意してください。代わりに、Rational や BigDecimal などの正確なオブジェクトを使用することを検討してください。 


require 'matrix'
m = Matrix[[2, 6], [1, 3]]
m.rank  # => 1
rank_e -> Integer[permalink][rdoc][edit]

階数 (rank) を返します。

このメソッドは deprecated です。代わりに Matrix#rank を使ってください。

real -> Matrix[permalink][rdoc][edit]

行列の実部を返します。 

例

require '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[permalink][rdoc][edit]

行列の全要素が実(Numeric#real?)であれば true を返します。

Complexオブジェクトを要素に持つ場合は虚部が0でも偽を返します。 

例

require 'matrix'
Matrix[[1, 0], [0, 1]].real? # => true
Matrix[[Complex(0, 1), 0], [0, 1]].real? # => false
# 要素が実数であっても Complex オブジェクトなら偽を返す。
Matrix[[Complex(1, 0), 0], [0, 1]].real? # => false
rectangular -> [Matrix, Matrix][permalink][rdoc][edit]
rect -> [Matrix, Matrix]

行列を実部と虚部に分解したものを返します。 

例

m.rect == [m.real, m.imag]  # ==> true for all matrices m

[SEE_ALSO] Matrix#imaginary, Matrix#real

regular? -> bool[permalink][rdoc][edit]

行列が正方で正則なら true を、特異なら false を返します。

行列が正則であるとは、正方行列であり、かつ、その逆行列が存在することです。行列式が0でないことと同値です。

正方行列でない場合には例外 ExceptionForMatrix::ErrDimensionMismatch を発生させます。 

例

require 'matrix'

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? # => raise ExceptionForMatrix::ErrDimensionMismatch
[EXCEPTION] ExceptionForMatrix::ErrDimensionMismatch:
行列が正方行列でない場合に発生します
round(ndigits = 0) -> Matrix[permalink][rdoc][edit]

行列の各要素を指定した桁数で丸めた行列を返します。

[SEE_ALSO] Float#round

row(i) -> Vector | nil[permalink][rdoc][edit]
row(i) {|x| ... } -> self

i 番目の行を Vector オブジェクトで返します。 i 番目の行が存在しない場合は nil を返します。ブロックが与えられた場合はその行の各要素についてブロックを繰り返します。

Vector オブジェクトは Matrix オブジェクトとの演算の際には列ベクトルとして扱われることに注意してください。

[PARAM] i:
行の位置を指定します。先頭の行が 0 番目になります。i の値が負の時には末尾からのインデックスと見倣します。末尾の行が -1 番目になります。 
例

require 'matrix'
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 -> Integer[permalink][rdoc][edit]
row_count -> Integer

行列の行数を返します。

row_vectors -> [Vector][permalink][rdoc][edit]

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

例

require 'matrix'
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[permalink][rdoc][edit]

行列が正方で特異なら true を、正則なら false を返します。

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

正方行列でない場合には例外 ExceptionForMatrix::ErrDimensionMismatch を発生させます。

[EXCEPTION] ExceptionForMatrix::ErrDimensionMismatch:
行列が正方行列でない場合に発生します
square? -> bool[permalink][rdoc][edit]

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

symmetric? -> bool[permalink][rdoc][edit]

行列が対称ならば true を返します。

[EXCEPTION] ExceptionForMatrix::ErrDimensionMismatch:
行列が正方行列でない場合に発生します
transpose -> Matrix[permalink][rdoc][edit]
t -> Matrix

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

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

to_a -> Array[permalink][rdoc][edit]

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

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

例

require 'matrix'
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]]
to_s -> String[permalink][rdoc][edit]

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

例

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

p m.to_s # => "Matrix[[1, 2], [3, 4.5]]"
trace -> Integer | Float | Rational | Complex[permalink][rdoc][edit]
tr -> Integer | Float | Rational | Complex

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

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

例

require 'matrix'
Matrix[[7,6], [3,9]].trace # => 16

trace は正方行列でのみ定義されます。

[EXCEPTION] ExceptionForMatrix::ErrDimensionMismatch:
行列が正方行列でない場合に発生します
unitary? -> bool[permalink][rdoc][edit]

行列がユニタリならば true を返します。

[EXCEPTION] ExceptionForMatrix::ErrDimensionMismatch:
行列が正方行列でない場合に発生します
upper_triangular? -> bool[permalink][rdoc][edit]

行列が上三角行列ならば true を返します。

vstack -> Matrix[permalink][rdoc][edit]

行列 self と matrices を縦に並べた行列を生成します。

Matrix.vstack(self, *matrices) と同じです。 

例

require 'matrix'
x = Matrix[[1, 2], [3, 4]]
y = Matrix[[5, 6], [7, 8]]
x.vstack(y) # => Matrix[[1, 2], [3, 4], [5, 6], [7, 8]]

[SEE_ALSO] Matrix.vstack, Matrix#hstack

zero? -> bool[permalink][rdoc][edit]

行列が零行列ならば true を返します。