種類
- インスタンスメソッド (76)
- 特異メソッド (11)
- クラス (5)
ライブラリ
- matrix (92)
クラス
- Matrix (44)
-
Matrix
:: EigenvalueDecomposition (10) -
Matrix
:: LUPDecomposition (10) - Vector (23)
キーワード
- * (2)
- EigenvalueDecomposition (1)
- ErrDimensionMismatch (1)
- ErrNotRegular (1)
- ErrOperationNotDefined (1)
- LUPDecomposition (1)
- [] (3)
- coerce (1)
-
cofactor
_ expansion (1) - collect (4)
- collect2 (2)
- column (2)
-
column
_ vectors (1) - columns (1)
- component (2)
- covector (1)
-
cross
_ product (1) - d (1)
- det (2)
- determinant (2)
- diagonal (1)
- eigen (1)
- eigensystem (1)
-
eigenvalue
_ matrix (1) - eigenvalues (1)
-
eigenvector
_ matrix (1) -
eigenvector
_ matrix _ inv (1) - eigenvectors (1)
- element (1)
- elements (1)
-
elements
_ to _ f (1) -
elements
_ to _ i (1) -
elements
_ to _ r (1) - empty (1)
- empty? (1)
- independent? (2)
-
inner
_ product (1) - inspect (2)
- inv (1)
- inverse (1)
- l (1)
-
laplace
_ expansion (1) - lup (1)
-
lup
_ decomposition (1) - map (4)
- map2 (1)
- minor (2)
- permutation? (1)
- pivots (1)
- regular? (1)
- row (2)
-
row
_ vectors (1) - rows (1)
- scalar (1)
- singular? (1)
- solve (1)
-
to
_ a (4) -
to
_ ary (2) -
to
_ s (2) - tr (1)
- trace (1)
- transpose (1)
- u (1)
-
upper
_ triangular? (1) - v (1)
-
v
_ inv (1) - zero (2)
検索結果
先頭5件
-
Matrix
:: LUPDecomposition # p -> Matrix (87607.0) -
LUP分解の置換行列部分を返します。
LUP分解の置換行列部分を返します。 -
Matrix
# lup -> Matrix :: LUPDecomposition (69769.0) -
行列の LUP 分解を保持したオブジェクトを返します。
行列の LUP 分解を保持したオブジェクトを返します。
Matrix::LUPDecomposition は to_ary を定義しているため、
多重代入によって3つの行列(下三角行列、上三角行列、置換行列)
を得ることができます。これを [L, U, P] と書くと、
L*U = P*self を満たします。
//emlist[例][ruby]{
require 'matrix'
a = Matrix[[1, 2], [3, 4]]
l, u, p = a.lup
l.lower_triangular? # => true
u.upper_triangular? # => true
p.... -
Matrix
# lup _ decomposition -> Matrix :: LUPDecomposition (69769.0) -
行列の LUP 分解を保持したオブジェクトを返します。
行列の LUP 分解を保持したオブジェクトを返します。
Matrix::LUPDecomposition は to_ary を定義しているため、
多重代入によって3つの行列(下三角行列、上三角行列、置換行列)
を得ることができます。これを [L, U, P] と書くと、
L*U = P*self を満たします。
//emlist[例][ruby]{
require 'matrix'
a = Matrix[[1, 2], [3, 4]]
l, u, p = a.lup
l.lower_triangular? # => true
u.upper_triangular? # => true
p.... -
Matrix
. empty(row _ size=0 , column _ size=0) -> Matrix (69712.0) -
要素を持たない行列を返します。
要素を持たない行列を返します。
「要素を持たない」とは、行数もしくは列数が0の行列のことです。
row_size 、 column_size のいずれか一方は0である必要があります。
//emlist[例][ruby]{
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]]
//}
... -
Matrix
# cofactor _ expansion(row: nil , column: nil) -> object | Integer | Rational | Float (69391.0) -
row 行、もしくは column 列に関するラプラス展開をする。
row 行、もしくは column 列に関するラプラス展開をする。
通常の行列に対してはこれは単に固有値を計算するだけです。かわりにMatrix#determinant を
利用すべきです。
変則的な形状の行列に対してはそれ以上の意味を持ちます。例えば
row行/column列が行列やベクトルである場合には
//emlist[例][ruby]{
require 'matrix'
# Matrix[[7,6], [3,9]].laplace_expansion(column: 1) # => 45
Matrix[[Vector[1, 0], Vector[0, 1]], [2, 3]].... -
Matrix
# laplace _ expansion(row: nil , column: nil) -> object | Integer | Rational | Float (69391.0) -
row 行、もしくは column 列に関するラプラス展開をする。
row 行、もしくは column 列に関するラプラス展開をする。
通常の行列に対してはこれは単に固有値を計算するだけです。かわりにMatrix#determinant を
利用すべきです。
変則的な形状の行列に対してはそれ以上の意味を持ちます。例えば
row行/column列が行列やベクトルである場合には
//emlist[例][ruby]{
require 'matrix'
# Matrix[[7,6], [3,9]].laplace_expansion(column: 1) # => 45
Matrix[[Vector[1, 0], Vector[0, 1]], [2, 3]].... -
Matrix
# inspect -> String (69373.0) -
自分自身を見やすい形式に文字列化し、その文字列を返します。
自分自身を見やすい形式に文字列化し、その文字列を返します。
//emlist[例][ruby]{
require 'matrix'
a1 = [1, 2]
a2 = [3, 4.5]
m = Matrix[a1, a2]
p m.inspect # => "Matrix[[1, 2], [3, 4.5]]"
//} -
Matrix
# empty? -> bool (69319.0) -
行列が要素を持たないならば true を返します。
行列が要素を持たないならば true を返します。
要素を持たないとは、行数か列数のいずれかが0であることを意味します。
@see Matrix.empty -
Matrix
# permutation? -> bool (69301.0) -
行列が置換行列ならば true を返します。
行列が置換行列ならば true を返します。
@raise ExceptionForMatrix::ErrDimensionMismatch 行列が正方行列でない場合に発生します -
Matrix
# upper _ triangular? -> bool (69301.0) -
行列が上三角行列ならば true を返します。
行列が上三角行列ならば true を返します。 -
Matrix
# map {|x| . . . } -> Matrix (60697.0) -
行列の各要素に対してブロックの適用を繰り返した結果を、要素として持つ行列を生成します。
行列の各要素に対してブロックの適用を繰り返した結果を、要素として持つ行列を生成します。
ブロックがない場合、 Enumerator を返します。
//emlist[例][ruby]{
require 'matrix'
m = Matrix[[1, 2], [3, 4]]
p m.map { |x| x + 100 } # => Matrix[[101, 102], [103, 104]]
//}
@see Matrix#each -
Matrix
# transpose -> Matrix (60673.0) -
転置行列 (transpose matrix) を返します。
転置行列 (transpose matrix) を返します。
self を Matrix のオブジェクトで、(m,n) 型行列としたとき a(j,i) を (i,j) 要素とする (n,m) 型行列を返します。 -
Matrix
:: EigenvalueDecomposition # eigenvector _ matrix _ inv -> Matrix (60628.0) -
左固有ベクトルを縦に並べた行列を返します。
左固有ベクトルを縦に並べた行列を返します。
これは Matrix::EigenvalueDecomposition#v の逆行列です -
Matrix
:: EigenvalueDecomposition # eigenvector _ matrix -> Matrix (60610.0) -
右固有ベクトルを横に並べた行列を返します。
右固有ベクトルを横に並べた行列を返します。 -
Matrix
# component(i , j) -> () (60409.0) -
(i,j)要素を返します。 行列の範囲外の値を指定した場合には nil を返します。
(i,j)要素を返します。
行列の範囲外の値を指定した場合には nil を返します。
@param i 要素の行成分を0オリジンで指定します。
@param j 要素の列成分を0オリジンで指定します。
//emlist[例][ruby]{
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
//} -
Matrix
# map -> Enumerator (60397.0) -
行列の各要素に対してブロックの適用を繰り返した結果を、要素として持つ行列を生成します。
行列の各要素に対してブロックの適用を繰り返した結果を、要素として持つ行列を生成します。
ブロックがない場合、 Enumerator を返します。
//emlist[例][ruby]{
require 'matrix'
m = Matrix[[1, 2], [3, 4]]
p m.map { |x| x + 100 } # => Matrix[[101, 102], [103, 104]]
//}
@see Matrix#each -
Matrix
. rows(rows , copy = true) -> Matrix (51712.0) -
引数 rows を行ベクトルの列とする行列を生成します。
引数 rows を行ベクトルの列とする行列を生成します。
引数 copy が偽(false)ならば、rows の複製を行いません。
//emlist[例][ruby]{
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]]
//... -
Matrix
# eigen -> Matrix :: EigenvalueDecomposition (51679.0) -
行列の固有値と左右の固有ベクトルを保持したオブジェクトを返します。
行列の固有値と左右の固有ベクトルを保持したオブジェクトを返します。
Matrix::EigenvalueDecomposition は to_ary を定義しているため、
多重代入によって3つの行列(右固有ベクトル、固有値行列、左固有ベクトル)
を得ることができます。
これを [V, D, W] と書くと、
(元の行列が対角化可能ならば)、
D は対角行列で、 self == V*D*W, V = W.inverse を満たします。
D のそれぞれの対角成分が行列の固有値です。
//emlist[例][ruby]{
require 'matrix'
m = Matrix[[1, 2], [... -
Matrix
# eigensystem -> Matrix :: EigenvalueDecomposition (51679.0) -
行列の固有値と左右の固有ベクトルを保持したオブジェクトを返します。
行列の固有値と左右の固有ベクトルを保持したオブジェクトを返します。
Matrix::EigenvalueDecomposition は to_ary を定義しているため、
多重代入によって3つの行列(右固有ベクトル、固有値行列、左固有ベクトル)
を得ることができます。
これを [V, D, W] と書くと、
(元の行列が対角化可能ならば)、
D は対角行列で、 self == V*D*W, V = W.inverse を満たします。
D のそれぞれの対角成分が行列の固有値です。
//emlist[例][ruby]{
require 'matrix'
m = Matrix[[1, 2], [... -
Matrix
:: EigenvalueDecomposition # eigenvalue _ matrix -> Matrix (51610.0) -
固有値を対角成分に並べた行列を返します。
固有値を対角成分に並べた行列を返します。 -
Matrix
. columns(columns) -> Matrix (51448.0) -
引数 columns を列ベクトルの集合とする行列を生成します。
引数 columns を列ベクトルの集合とする行列を生成します。
@param columns 配列の配列を渡します。
=== 注意
Matrix.rows との違いは引数として渡す配列の配列を列ベクトルの配列とみなして行列を生成します。
//emlist[例][ruby]{
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],... -
Matrix
# inv -> Matrix (51433.0) -
逆行列を返します。
逆行列を返します。
//emlist[例][ruby]{
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]]
//} -
Matrix
# inverse -> Matrix (51433.0) -
逆行列を返します。
逆行列を返します。
//emlist[例][ruby]{
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]]
//} -
Matrix
. diagonal(*values) -> Matrix (51430.0) -
対角要素がvaluesで、非対角要素が全て0であるような 正方行列を生成します。
対角要素がvaluesで、非対角要素が全て0であるような
正方行列を生成します。
@param values 行列の対角要素
=== 注意
valuesに一次元Arrayを1個指定すると、そのArrayを唯一の要素とした1×1の行列が生成されます。
//emlist[例][ruby]{
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,... -
Matrix
# collect {|x| . . . } -> Matrix (51397.0) -
行列の各要素に対してブロックの適用を繰り返した結果を、要素として持つ行列を生成します。
行列の各要素に対してブロックの適用を繰り返した結果を、要素として持つ行列を生成します。
ブロックがない場合、 Enumerator を返します。
//emlist[例][ruby]{
require 'matrix'
m = Matrix[[1, 2], [3, 4]]
p m.map { |x| x + 100 } # => Matrix[[101, 102], [103, 104]]
//}
@see Matrix#each -
Matrix
. zero(n) -> Matrix (51391.0) -
n × n の零行列(要素が全て 0 の行列)を生成して返します。
n × n の零行列(要素が全て 0 の行列)を生成して返します。
//emlist[例][ruby]{
require 'matrix'
p Matrix.zero(2) #=> Matrix[[0, 0], [0, 0]]
//}
@param n 生成する正方零行列の次数 -
Matrix
. zero(row , column) -> Matrix (51391.0) -
row × column の零行列(要素が全て 0 の行列)を生成して返します。
row × column の零行列(要素が全て 0 の行列)を生成して返します。
//emlist[例][ruby]{
require 'matrix'
p Matrix.zero(2, 3) #=> Matrix[[0, 0, 0], [0, 0, 0]]
//}
@param row 生成する行列の行数
@param column 生成する行列の列数 -
Matrix
# minor(from _ row , row _ size , from _ col , col _ size) -> Matrix (51379.0) -
selfの部分行列を返します。
selfの部分行列を返します。
自分自身の部分行列を返します。
ただし、パラメータは次の方法で指定します。
(1) 開始行番号, 行の大きさ, 開始列番号, 列の大きさ
(2) 開始行番号..終了行番号, 開始列番号..終了列番号
@param from_row 部分行列の開始行(0オリジンで指定)
@param row_size 部分行列の行サイズ
@param from_col 部分行列の開始列(0オリジンで指定)
@param col_size 部分行列の列サイズ
//emlist[例][ruby]{
require 'matrix'
a1 = [ 1, 2, 3, ... -
Matrix
# minor(from _ row . . to _ row , from _ col . . to _ col) -> Matrix (51379.0) -
selfの部分行列を返します。
selfの部分行列を返します。
自分自身の部分行列を返します。
ただし、パラメータは次の方法で指定します。
(1) 開始行番号, 行の大きさ, 開始列番号, 列の大きさ
(2) 開始行番号..終了行番号, 開始列番号..終了列番号
@param from_row 部分行列の開始行(0オリジンで指定)
@param row_size 部分行列の行サイズ
@param from_col 部分行列の開始列(0オリジンで指定)
@param col_size 部分行列の列サイズ
//emlist[例][ruby]{
require 'matrix'
a1 = [ 1, 2, 3, ... -
Matrix
. [](*rows) -> Matrix (51376.0) -
rows[i] を第 i 行とする行列を生成します。
rows[i] を第 i 行とする行列を生成します。
@param rows 行列の要素を数の配列の配列として渡します。
//emlist[例][ruby]{
require 'matrix'
m = Matrix[[11, 12], [21, 22]]
p m # => Matrix[[11, 12], [21, 22]]
# [11, 12]
# [21, 22]
//} -
Matrix
. scalar(n , value) -> Matrix (51376.0) -
対角要素が全てvalue(数)で、非対角要素が全て0であるようなn次の正方行列を生成します。
対角要素が全てvalue(数)で、非対角要素が全て0であるようなn次の正方行列を生成します。
@param n 生成する行列の次元
@param value 生成する行列の対角要素の値
//emlist[例][ruby]{
require 'matrix'
m = Matrix.scalar(3, 2.5)
p m # => Matrix[[2.5, 0, 0], [0, 2.5, 0], [0, 0, 2.5]]
//} -
Matrix
# tr -> Integer | Float | Rational | Complex (51337.0) -
トレース (trace) を返します。
トレース (trace) を返します。
行列のトレース (trace) とは、対角要素の和です。
//emlist[例][ruby]{
require 'matrix'
Matrix[[7,6], [3,9]].trace # => 16
//}
trace は正方行列でのみ定義されます。
@raise ExceptionForMatrix::ErrDimensionMismatch 行列が正方行列でない場合に発生します -
Matrix
# trace -> Integer | Float | Rational | Complex (51337.0) -
トレース (trace) を返します。
トレース (trace) を返します。
行列のトレース (trace) とは、対角要素の和です。
//emlist[例][ruby]{
require 'matrix'
Matrix[[7,6], [3,9]].trace # => 16
//}
trace は正方行列でのみ定義されます。
@raise ExceptionForMatrix::ErrDimensionMismatch 行列が正方行列でない場合に発生します -
Matrix
:: EigenvalueDecomposition # v _ inv -> Matrix (51328.0) -
左固有ベクトルを縦に並べた行列を返します。
左固有ベクトルを縦に並べた行列を返します。
これは Matrix::EigenvalueDecomposition#v の逆行列です -
Matrix
:: EigenvalueDecomposition # v -> Matrix (51310.0) -
右固有ベクトルを横に並べた行列を返します。
右固有ベクトルを横に並べた行列を返します。 -
Matrix
:: LUPDecomposition # pivots -> [Integer] (51301.0) -
ピボッティングを表す配列を返します。
ピボッティングを表す配列を返します。 -
Matrix
# regular? -> bool (51127.0) -
行列が正方で正則なら true を、特異なら false を返します。
行列が正方で正則なら true を、特異なら false を返します。
行列が正則であるとは、正方行列であり、かつ、その逆行列が存在することです。
行列式が0でないことと同値です。
正方行列でない場合には例外 ExceptionForMatrix::ErrDimensionMismatch を
発生させます。
//emlist[例][ruby]{
require 'matrix'
a1 = [ 1, 2, 3]
a2 = [10, 15, 20]
a3 = [-1, -2, 1.5]
m = Matrix[a1, a2, a3]
p m.regular? # => true
... -
Matrix
# [](i , j) -> () (51109.0) -
(i,j)要素を返します。 行列の範囲外の値を指定した場合には nil を返します。
(i,j)要素を返します。
行列の範囲外の値を指定した場合には nil を返します。
@param i 要素の行成分を0オリジンで指定します。
@param j 要素の列成分を0オリジンで指定します。
//emlist[例][ruby]{
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
//} -
Matrix
# coerce(other) -> Array (51109.0) -
他の数値オブジェクトとの変換を行います。
他の数値オブジェクトとの変換を行います。
他の数値オブジェクトをMatrix::Scalarのオブジェクトに変換し、selfとの組を配列として返します。
@param other 変換する数値オブジェクト
//emlist[例][ruby]{
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]]]... -
Matrix
# element(i , j) -> () (51109.0) -
(i,j)要素を返します。 行列の範囲外の値を指定した場合には nil を返します。
(i,j)要素を返します。
行列の範囲外の値を指定した場合には nil を返します。
@param i 要素の行成分を0オリジンで指定します。
@param j 要素の列成分を0オリジンで指定します。
//emlist[例][ruby]{
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
//} -
Matrix
# collect -> Enumerator (51097.0) -
行列の各要素に対してブロックの適用を繰り返した結果を、要素として持つ行列を生成します。
行列の各要素に対してブロックの適用を繰り返した結果を、要素として持つ行列を生成します。
ブロックがない場合、 Enumerator を返します。
//emlist[例][ruby]{
require 'matrix'
m = Matrix[[1, 2], [3, 4]]
p m.map { |x| x + 100 } # => Matrix[[101, 102], [103, 104]]
//}
@see Matrix#each -
Matrix
# det -> Numeric (51091.0) -
行列式 (determinant) の値を返します。
行列式 (determinant) の値を返します。
Float を使用すると、精度が不足するため、誤った結果が生じる可能性があることに注意してください。
代わりに、Rational や BigDecimal などの正確なオブジェクトを使用することを検討してください。
@raise ExceptionForMatrix::ErrDimensionMismatch 正方行列でない場合に発生します
//emlist[例][ruby]{
require 'matrix'
p Matrix[[2, 1], [-1, 2]].det #=> 5
p Matrix[[2.0, 1... -
Matrix
# determinant -> Numeric (51091.0) -
行列式 (determinant) の値を返します。
行列式 (determinant) の値を返します。
Float を使用すると、精度が不足するため、誤った結果が生じる可能性があることに注意してください。
代わりに、Rational や BigDecimal などの正確なオブジェクトを使用することを検討してください。
@raise ExceptionForMatrix::ErrDimensionMismatch 正方行列でない場合に発生します
//emlist[例][ruby]{
require 'matrix'
p Matrix[[2, 1], [-1, 2]].det #=> 5
p Matrix[[2.0, 1... -
Matrix
# row(i) -> Vector | nil (51091.0) -
i 番目の行を Vector オブジェクトで返します。 i 番目の行が存在しない場合は nil を返します。 ブロックが与えられた場合はその行の各要素についてブロックを繰り返します。
i 番目の行を Vector オブジェクトで返します。
i 番目の行が存在しない場合は nil を返します。
ブロックが与えられた場合はその行の各要素についてブロックを繰り返します。
Vector オブジェクトは Matrix オブジェクトとの演算の際には列ベクトルとして扱われることに注意してください。
@param i 行の位置を指定します。
先頭の行が 0 番目になります。i の値が負の時には末尾から
のインデックスと見倣します。末尾の行が -1 番目になります。
//emlist[例][ruby]{
require 'matrix'
a1 = ... -
Matrix
# row(i) {|x| . . . } -> self (51091.0) -
i 番目の行を Vector オブジェクトで返します。 i 番目の行が存在しない場合は nil を返します。 ブロックが与えられた場合はその行の各要素についてブロックを繰り返します。
i 番目の行を Vector オブジェクトで返します。
i 番目の行が存在しない場合は nil を返します。
ブロックが与えられた場合はその行の各要素についてブロックを繰り返します。
Vector オブジェクトは Matrix オブジェクトとの演算の際には列ベクトルとして扱われることに注意してください。
@param i 行の位置を指定します。
先頭の行が 0 番目になります。i の値が負の時には末尾から
のインデックスと見倣します。末尾の行が -1 番目になります。
//emlist[例][ruby]{
require 'matrix'
a1 = ... -
Matrix
# column(j) -> Vector | nil (51073.0) -
j 番目の列を Vector オブジェクトで返します。 j 番目の列が存在しない場合は nil を返します。 ブロックが与えられた場合はその列の各要素についてブロックを繰り返します。
j 番目の列を Vector オブジェクトで返します。
j 番目の列が存在しない場合は nil を返します。
ブロックが与えられた場合はその列の各要素についてブロックを繰り返します。
@param j 列の位置を指定します。
先頭の列が 0 番目になります。j の値が負の時には末尾から
のインデックスと見倣します。末尾の列が -1 番目になります。
//emlist[例][ruby]{
require 'matrix'
a1 = [ 1, 2, 3]
a2 = [10, 15, 20]
a3 = [-1, -2, 1.5]
m = Matr... -
Matrix
# column(j) {|x| . . . } -> self (51073.0) -
j 番目の列を Vector オブジェクトで返します。 j 番目の列が存在しない場合は nil を返します。 ブロックが与えられた場合はその列の各要素についてブロックを繰り返します。
j 番目の列を Vector オブジェクトで返します。
j 番目の列が存在しない場合は nil を返します。
ブロックが与えられた場合はその列の各要素についてブロックを繰り返します。
@param j 列の位置を指定します。
先頭の列が 0 番目になります。j の値が負の時には末尾から
のインデックスと見倣します。末尾の列が -1 番目になります。
//emlist[例][ruby]{
require 'matrix'
a1 = [ 1, 2, 3]
a2 = [10, 15, 20]
a3 = [-1, -2, 1.5]
m = Matr... -
Matrix
# to _ s -> String (51073.0) -
行列を文字列化し、その文字列を返します。
行列を文字列化し、その文字列を返します。
//emlist[例][ruby]{
require 'matrix'
a1 = [1, 2]
a2 = [3, 4.5]
m = Matrix[a1, a2]
p m.to_s # => "Matrix[[1, 2], [3, 4.5]]"
//} -
Matrix
# column _ vectors -> [Vector] (51055.0) -
自分自身を列ベクトルの配列として返します。
自分自身を列ベクトルの配列として返します。
//emlist[例][ruby]{
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]]
//} -
Matrix
# row _ vectors -> [Vector] (51055.0) -
自分自身を行ベクトルの配列として返します。
自分自身を行ベクトルの配列として返します。
//emlist[例][ruby]{
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]]
//} -
Matrix
# to _ a -> Array (51055.0) -
自分自身をArrayに変換したものを返します。
自分自身をArrayに変換したものを返します。
行ベクトルを配列(Array)としたものの配列(つまり配列の配列)として返します。
//emlist[例][ruby]{
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]]
//} -
Matrix
:: EigenvalueDecomposition (51019.0) -
行列の固有分解の情報を保持するクラスです。
行列の固有分解の情報を保持するクラスです。
Matrix#eigensystem の返り値のクラスです。 -
Matrix
:: LUPDecomposition (51019.0) -
行列のLUP分解の情報を保持するクラスです。
行列のLUP分解の情報を保持するクラスです。
Matrix#lup_decomposition の返り値のクラスです。 -
ExceptionForMatrix
:: ErrOperationNotDefined (51001.0) -
演算時にクラスが適切でない場合に発生する例外です。
演算時にクラスが適切でない場合に発生する例外です。 -
Matrix
:: EigenvalueDecomposition # to _ a -> [Matrix , Matrix , Matrix] (43063.0) -
Matrix::EigenvalueDecomposition#v, Matrix::EigenvalueDecomposition#d, Matrix::EigenvalueDecomposition#v_inv をこの順に並べた配列を返します。
Matrix::EigenvalueDecomposition#v,
Matrix::EigenvalueDecomposition#d,
Matrix::EigenvalueDecomposition#v_inv
をこの順に並べた配列を返します。 -
Matrix
:: EigenvalueDecomposition # to _ ary -> [Matrix , Matrix , Matrix] (43063.0) -
Matrix::EigenvalueDecomposition#v, Matrix::EigenvalueDecomposition#d, Matrix::EigenvalueDecomposition#v_inv をこの順に並べた配列を返します。
Matrix::EigenvalueDecomposition#v,
Matrix::EigenvalueDecomposition#d,
Matrix::EigenvalueDecomposition#v_inv
をこの順に並べた配列を返します。 -
Matrix
:: LUPDecomposition # to _ a -> [Matrix , Matrix , Matrix] (42919.0) -
分解した行列を [下半行列, 上半行列, 置換行列] という3要素の配列で 返します。
分解した行列を [下半行列, 上半行列, 置換行列] という3要素の配列で
返します。 -
Matrix
:: LUPDecomposition # to _ ary -> [Matrix , Matrix , Matrix] (42919.0) -
分解した行列を [下半行列, 上半行列, 置換行列] という3要素の配列で 返します。
分解した行列を [下半行列, 上半行列, 置換行列] という3要素の配列で
返します。 -
Matrix
:: LUPDecomposition # solve(b) -> Vector | Matrix (42424.0) -
self が正方行列 A の LUP 分解の時、一次方程式 Ax = b の解を返します。 b には Vector, Matrix, 数値の配列を指定出来ます。
self が正方行列 A の LUP 分解の時、一次方程式 Ax = b の解を返します。
b には Vector, Matrix, 数値の配列を指定出来ます。
それぞれベクトルのサイズ、行列の行数、配列のサイズが A の列数と一致していなければなりません。
返り値は b が行列なら行列、それ以外はベクトルになります。
@param b 一次方程式の定数項を指定します。
//emlist[][ruby]{
require 'matrix'
lup = Matrix[[2, 1], [1, 2]].lup
lup.solve([1, -1]) #=> ... -
Vector
# map2(v) {|x , y| . . . } -> Vector (42355.0) -
ベクトルの各要素と引数 v の要素との組に対してブロックを評価し、その結果を要素として持つベクトルを返します。
ベクトルの各要素と引数 v の要素との組に対してブロックを評価し、その結果を要素として持つベクトルを返します。
ベクトルの各要素と、それに対応するインデックスを持つ引数 (ベクトル or 配列) の要素との組に対して (2引数の) ブロックを評価した結果を、要素として持つベクトルを返します。
ブロックを省略した場合は Enumerator を返します。
@param v ブロック内で評価される(ベクトル or 配列)
@raise ExceptionForMatrix::ErrDimensionMismatch 自分自身と引数のベクト
ルの要素の数(次元)が異なっていた... -
Vector
# independent?(*vectors) -> bool (42319.0) -
self とベクトルの列 vectors が線形独立であれば true を返します。
self とベクトルの列 vectors が線形独立であれば true を返します。
require 'matrix'
Vector.independent?(self, *vectors)
と同じです。
@param vectors 線形独立性を判定するベクトル列 -
Matrix
:: EigenvalueDecomposition # d -> Matrix (42310.0) -
固有値を対角成分に並べた行列を返します。
固有値を対角成分に並べた行列を返します。 -
Matrix
:: LUPDecomposition # l -> Matrix (42304.0) -
LUP分解の下半行列部分を返します。
LUP分解の下半行列部分を返します。 -
Matrix
:: LUPDecomposition # u -> Matrix (42304.0) -
LUP分解の上半行列部分を返します。
LUP分解の上半行列部分を返します。 -
Vector
# inspect -> String (42301.0) -
オブジェクトの内容を文字列化します。
オブジェクトの内容を文字列化します。 -
Vector
. independent?(*vectors) -> bool (42301.0) -
ベクトルの列 vectors が線形独立であれば true を返します。
ベクトルの列 vectors が線形独立であれば true を返します。
@param vectors 線形独立性を判定するベクトル列 -
Matrix
:: LUPDecomposition # det -> Numeric (42019.0) -
元の行列の行列式の値を返します。 LUP 分解の結果を利用して計算します。
元の行列の行列式の値を返します。
LUP 分解の結果を利用して計算します。
@see Matrix#determinant -
Matrix
:: LUPDecomposition # determinant -> Numeric (42019.0) -
元の行列の行列式の値を返します。 LUP 分解の結果を利用して計算します。
元の行列の行列式の値を返します。
LUP 分解の結果を利用して計算します。
@see Matrix#determinant -
Matrix
:: LUPDecomposition # singular? -> bool (42019.0) -
元の行列が正方で特異なら true を、正則なら false を返します。 LUP 分解の結果を利用して判定します。
元の行列が正方で特異なら true を、正則なら false を返します。
LUP 分解の結果を利用して判定します。
@see Matrix#singular? -
ExceptionForMatrix
:: ErrDimensionMismatch (42001.0) -
行列/ベクトル計算時に次元が合わない場合に発生する例外です。
行列/ベクトル計算時に次元が合わない場合に発生する例外です。 -
ExceptionForMatrix
:: ErrNotRegular (42001.0) -
逆行列計算時に行列が正則でない場合に発生する例外です。
逆行列計算時に行列が正則でない場合に発生する例外です。 -
Matrix
:: EigenvalueDecomposition # eigenvalues -> [Float] (42001.0) -
固有値を配列で返します。
固有値を配列で返します。 -
Matrix
:: EigenvalueDecomposition # eigenvectors -> [Vector] (42001.0) -
右固有ベクトルを配列で返します。
右固有ベクトルを配列で返します。 -
Vector
# map -> Enumerator (33355.0) -
ベクトルの各要素に対してブロックを評価した結果を、要素として持つベクトルを生成します。
ベクトルの各要素に対してブロックを評価した結果を、要素として持つベクトルを生成します。
ブロックを省略した場合は Enumerator を返します。
//emlist[例][ruby]{
require 'matrix'
a = [1, 2, 3.5, -10]
v1 = Vector.elements(a)
p v1 # => Vector[1, 2, 3.5, -10]
v2 = v1.map{|x|
x * -1
}
p v2 # => Vector[-1, -2, -3.5, 10]
//} -
Vector
# map {|x| . . . } -> Vector (33355.0) -
ベクトルの各要素に対してブロックを評価した結果を、要素として持つベクトルを生成します。
ベクトルの各要素に対してブロックを評価した結果を、要素として持つベクトルを生成します。
ブロックを省略した場合は Enumerator を返します。
//emlist[例][ruby]{
require 'matrix'
a = [1, 2, 3.5, -10]
v1 = Vector.elements(a)
p v1 # => Vector[1, 2, 3.5, -10]
v2 = v1.map{|x|
x * -1
}
p v2 # => Vector[-1, -2, -3.5, 10]
//} -
Vector
# component(i) -> object | nil (33301.0) -
i 番目の要素を返します。インデックスは 0 から開始します。 要素が存在しないインデックスを指定した時には nil を返します。
i 番目の要素を返します。インデックスは 0 から開始します。
要素が存在しないインデックスを指定した時には nil を返します。
@param i 取得する要素のインデックスを整数値で指定します。
インデックスは 0 から始めます。 -
Vector
# cross _ product(*vs) -> Vector (33301.0) -
self とベクトル vs とのクロス積を返します。
self とベクトル vs とのクロス積を返します。
self が3次元ベクトル空間のときは
普通のクロス積です。
それ以外の場合は拡張されたクロス積で
n-1個のn次元ベクトルが張る空間と
直交するベクトルを返します。
self の次元が n であるとき、 vs は n-2 個の
n次元ベクトルでなければなりません。
@param vs クロス積を取るベクトルの集合
@raise ExceptionForMatrix::ErrOperationNotDefined self の
次元が1以下であるときに発生します。
@raise ArgumentError vs のベ... -
Vector
# inner _ product(v) -> Float (33301.0) -
ベクトル v との内積を返します。
ベクトル v との内積を返します。
@param v 内積を求めるベクトル
@raise ExceptionForMatrix::ErrDimensionMismatch 自分自身と引数のベクト
ルの要素の数(次元)が異なっていたときに発生します。 -
Vector
# *(m) -> Matrix (24481.0) -
自分自身を列ベクトル(行列)に変換して (実際には Matrix.column_vector(self) を適用) から、行列 m を右から乗じた行列 (Matrix クラス) を返します。
自分自身を列ベクトル(行列)に変換して (実際には Matrix.column_vector(self) を適用) から、行列 m を右から乗じた行列 (Matrix クラス) を返します。
@param m 右から乗算を行う行列
@raise ExceptionForMatrix::ErrDimensionMismatch 次元が合わない場合に発生します
=== 注意
引数の行列 m は自分自身を列ベクトルとした場合に乗算が定義できる行列である必要があります。
//emlist[例][ruby]{
require 'matrix'
v = Vector[1, 2]
a = [4,... -
Vector
# covector -> Matrix (24442.0) -
Matrix オブジェクトへ変換します。
Matrix オブジェクトへ変換します。
列ベクトル (行列)、すなわち、(n, 1) 型の行列に変換します。
実際には Matrix.row_vector(self) を適用します。
//emlist[例][ruby]{
require 'matrix'
v = Vector[2, 3, 5]
p v # => Vector[2, 3, 5]
m = v.covector
p m # => Matrix[[2, 3, 5]]
//} -
Vector
. elements(a , copy = true) -> Vector (24391.0) -
配列 a を要素とするベクトルを生成します。 ただし、オプション引数 copy が偽 (false) ならば、複製を行いません。
配列 a を要素とするベクトルを生成します。
ただし、オプション引数 copy が偽 (false) ならば、複製を行いません。
@param a Vectorを生成する際の要素の配列
@param copy 引数の配列 a のコピーをするかどうかのフラグ
//emlist[例][ruby]{
require 'matrix'
a = [1, 2, 3, 4]
v1 = Vector.elements(a, true)
v2 = Vector.elements(a, false)
p v1 # => Vector[1, 2, 3, 4]
p v2 #... -
Vector
# *(other) -> Vector (24076.0) -
self の各要素に数 other を乗じたベクトルを返します。
self の各要素に数 other を乗じたベクトルを返します。
@param other self の各要素に掛ける Numeric オブジェクトを指定します。
//emlist[例][ruby]{
require 'matrix'
a = [1, 2, 3.5, 100]
v1 = Vector.elements(a)
p v1.*(2) # => Vector[2, 4, 7.0, 200]
p v1.*(-1.5) # => Vector[-1.5, -3.0, -5.25, -150.0]
//} -
Vector
# collect -> Enumerator (24055.0) -
ベクトルの各要素に対してブロックを評価した結果を、要素として持つベクトルを生成します。
ベクトルの各要素に対してブロックを評価した結果を、要素として持つベクトルを生成します。
ブロックを省略した場合は Enumerator を返します。
//emlist[例][ruby]{
require 'matrix'
a = [1, 2, 3.5, -10]
v1 = Vector.elements(a)
p v1 # => Vector[1, 2, 3.5, -10]
v2 = v1.map{|x|
x * -1
}
p v2 # => Vector[-1, -2, -3.5, 10]
//} -
Vector
# collect {|x| . . . } -> Vector (24055.0) -
ベクトルの各要素に対してブロックを評価した結果を、要素として持つベクトルを生成します。
ベクトルの各要素に対してブロックを評価した結果を、要素として持つベクトルを生成します。
ブロックを省略した場合は Enumerator を返します。
//emlist[例][ruby]{
require 'matrix'
a = [1, 2, 3.5, -10]
v1 = Vector.elements(a)
p v1 # => Vector[1, 2, 3.5, -10]
v2 = v1.map{|x|
x * -1
}
p v2 # => Vector[-1, -2, -3.5, 10]
//} -
Vector
# collect2(v) -> Enumerator (24055.0) -
ベクトルの各要素と引数 v の要素との組に対してブロックを評価し、その結果を要素として持つ配列を返します。
ベクトルの各要素と引数 v の要素との組に対してブロックを評価し、その結果を要素として持つ配列を返します。
ベクトルの各要素と、それに対応するインデックスを持つ引数 v (ベクトル or 配列)の要素との組に対して (2引数の) ブロックを評価し、その結果を要素として持つ配列を返します。
ブロックを省略した場合は Enumerator を返します。
@param v ブロック内で評価される(ベクトル or 配列)
@raise ExceptionForMatrix::ErrDimensionMismatch 自分自身と引数のベクト
ルの要素の数(次元)が異なっていたとき... -
Vector
# collect2(v) {|x , y| . . . } -> Array (24055.0) -
ベクトルの各要素と引数 v の要素との組に対してブロックを評価し、その結果を要素として持つ配列を返します。
ベクトルの各要素と引数 v の要素との組に対してブロックを評価し、その結果を要素として持つ配列を返します。
ベクトルの各要素と、それに対応するインデックスを持つ引数 v (ベクトル or 配列)の要素との組に対して (2引数の) ブロックを評価し、その結果を要素として持つ配列を返します。
ブロックを省略した場合は Enumerator を返します。
@param v ブロック内で評価される(ベクトル or 配列)
@raise ExceptionForMatrix::ErrDimensionMismatch 自分自身と引数のベクト
ルの要素の数(次元)が異なっていたとき... -
Vector
. [](*a) -> Vector (24055.0) -
可変個引数を要素とするベクトルを生成します。
可変個引数を要素とするベクトルを生成します。
Vector[a1, a2, a3, ... ]としたとき、 引数a1, a2, a3, ... を要素とするベクトルを生成します。
@param a ベクトルの要素
//emlist[例][ruby]{
require 'matrix'
v1 = Vector[1, 3, 5, 7]
v2 = Vector[5.25, 10.5]
p v1 # => Vector[1, 3, 5, 7]
p v2 # => Vector[5.25, 10.5]
//} -
Vector
# elements _ to _ f -> Vector (24037.0) -
ベクトルの各成分をFloatに変換したベクトルを返します。
ベクトルの各成分をFloatに変換したベクトルを返します。
このメソッドは deprecated です。 map(&:to_f) を使ってください。
//emlist[例][ruby]{
require 'matrix'
v = Vector.elements([2, 3, 5, 7, 9])
p v.elements_to_f
# => Vector[2.0, 3.0, 5.0, 7.0, 9.0]
//} -
Vector
# elements _ to _ i -> Vector (24037.0) -
ベクトルの各成分をIntegerに変換したベクトルを返します。
ベクトルの各成分をIntegerに変換したベクトルを返します。
このメソッドは deprecated です。 map(&:to_i) を使ってください。
//emlist[例][ruby]{
require 'matrix'
v = Vector.elements([2.5, 3.0, 5.01, 7])
p v.elements_to_i
# => Vector[2, 3, 5, 7]
//} -
Vector
# elements _ to _ r -> Vector (24037.0) -
ベクトルの各成分をRationalに変換したベクトルを返します。
ベクトルの各成分をRationalに変換したベクトルを返します。
このメソッドは deprecated です。 map(&:to_r) を使ってください。
//emlist[例][ruby]{
require 'matrix'
v = Vector.elements([2.5, 3.0, 5.75, 7])
p v.elements_to_r
# => Vector[(5/2), (3/1), (23/4), (7/1)]
//} -
Vector
# to _ a -> Array (24037.0) -
ベクトル(Vector)から配列 (Array) に変換します。
ベクトル(Vector)から配列 (Array) に変換します。
//emlist[例][ruby]{
require 'matrix'
v = Vector[2, 3, 5, 7, 9]
p v.to_a
# => [2, 3, 5, 7, 9]
//} -
Vector
# to _ s -> String (24037.0) -
ベクトル(Vector)から文字列 (String) に変換します。
ベクトル(Vector)から文字列 (String) に変換します。
//emlist[例][ruby]{
require 'matrix'
v = Vector[2, 3, 5, 7, 9]
p v.to_s
# => "Vector[2, 3, 5, 7, 9]"
//}