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

class Matrix

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

Abstract

数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]

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

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]]

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]]

compare_by_row_vectors(rows) -> bool

自分自身(Matrix)を配列の配列(Array)とみなして引数rowsと比較します。

[PARAM] rows:: 比較対象の配列の配列
[RETURN]: selfを配列の配列とみなしたときに引数rowと等しい時にtrue, それ以外にはfalseを返します。

例:

a1 = [1, 2]
a2 = [-1.25, 2.2]
m = Matrix[a1, a2] # 行列
rows = Array[a1, a2] # 配列の配列
p m.compare_by_row_vectors(rows) #=> true

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があった場合には正しい値を返さないかもしれません。

elements_to_f -> Array

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

elements_to_i -> Array

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

elements_to_r -> Array

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

hash -> Fixnum

行列のHash値を返します。

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]]

minor(from_row, row_size, from_col, col_size) -> Matrix

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

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

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

開始行番号, 行の大きさ, 開始列番号, 列の大きさ
開始行番号..終了行番号, 開始列番号..終了列番号

[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]]

rank -> Fixnum

階数 (rank) を返します。

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

rank_e -> Fixnum

階数 (rank) を返します。

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

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

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)であるとは、正則でないことです。

square? -> bool

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

transpose -> Matrix

t -> Matrix

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

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

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]]

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

class Matrix

Abstract

Complex クラスとの併用

特異メソッド

インスタンスメソッド

Methods

Classes