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

class Vector

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

Abstract

require 'matrix'
require 'complex'

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

v1 = Vector[Complex(1,1),Complex(2,2),Complex(3,3)]
v2 = v1.conjugate
p v2 #=> Vector[Complex(1,-1),Complex(2,-2),Complex(3,-3)]
v3 = v1+v2
p v3 #=> Vector[Complex(1,0),Complex(2,0),Complex(3,0)]

require 'matrix'
require 'complex'

class Vector
  def abs
    r=0
    @elements.each{|e| r += e.abs2 }
    Math.sqrt(r)
  end
end

v = Vector[Complex(1,1),Complex(2,2),Complex(3,3)}
p v.abs #=> 5.291502622 # Math.sqrt(28)
p v.r   #=> 'sqrt': undefined method `Rational'

特異メソッド

self[*a] -> Vector

可変個引数を要素とするベクトルを生成します。

Vecor[a1, a2, a3, ... ]としたとき、 引数a1, a2, a3, ... を要素とするベクトルを生成します。

[PARAM] a:

ベクトルの要素

例:

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]

elements(a, copy = true) -> Vector

配列 a を要素とするベクトルを生成します。 ただし、オプション引数 copy が偽 (false) ならば、複製を行いません。

[PARAM] a:

Vectorを生成する際の要素の配列

[PARAM] copy:

引数の配列 a のコピーをするかどうかのフラグ

例:

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[1, 2, 3, 4]
a[0] = -1
p v1        #=> Vector[1, 2, 3, 4]
p v2        #=> Vector[-1, 2, 3, 4]

インスタンスメソッド

self * a -> Vector

数 a を各要素に乗じたベクトルを返します。

[PARAM] a:

乗算を行う数

例:

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]

self * m -> Matrix

自分自身を列ベクトル(行列)に変換して (実際には Matrix.column_vector(self) を適用) から、行列 m を右から乗じた行列 (Matrix クラス) を返します。

[PARAM] m:

右から乗算を行う行列

注意:

引数の行列 m は自分自身を列ベクトルとした場合に乗算が定義できる行列である必要があります。

例:

require 'matrix'

v = Vector[1, 2]
a = [4, 5, 6]
m = Matrix[a]

p v * m #=> Matrix[[4, 5, 6], [8, 10, 12]]

self + v -> Vector

ベクトル v を加えたベクトルを返します。

自分自身と引数 v の要素をそれぞれ加算し、その結果をVectorクラスのオブジェクトとして返します。

[PARAM] v:

加算をするベクトル

[EXCEPTION] ExceptionForMatrix::ErrDimensionMismatch:

自分自身と引数のベクトルの要素の数(次元)が異なっていたときに発生します。

self - v -> Vector

ベクトル v を減じたベクトルを返します。

自分自身と引数 v の要素をそれぞれ減算し、その結果をVectorクラスのオブジェクトとして返します。

[PARAM] v:

減算するベクトル

[EXCEPTION] ExceptionForMatrix::ErrDimensionMismatch:

自分自身と引数のベクトルの要素の数(次元)が異なっていたときに発生します。

self == v -> bool

eqn?(v) -> bool

自分自身と引数 v を比較し、true/false を返します。

[PARAM] v:

比較対象ベクトル

self[i] -> object | nil

element(i) -> object | nil

component(i) -> object | nil

i 番目の要素を返します。インデックスは 0 から開始します。 要素が存在しないインデックスを指定した時には nil を返します。

[PARAM] i:

取得する要素のインデックスを整数値で指定します。 インデックスは 0 から始めます。

clone() -> Vector

自分自身をコピーしたベクトルを返します。

coerce(other) -> Array

self と other が同じクラスになるよう、自分自身か other を変換し [other, self] という配列にして返します。

collect {|x| ... } -> Vector

map {|x| ... } -> Vector

ベクトルの各要素に対してブロックを評価した結果を、要素として持つベクトルを生成します。

例:

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]

collect2(v) {|x, y| ... } -> Array

ベクトルの各要素と引数 v の要素との組に対してブロックを評価し、その結果を要素として持つ配列を返します。

ベクトルの各要素と、それに対応するインデックスを持つ引数 v (ベクトル or 配列)の要素との組に対して (2引数の) ブロックを評価し、その結果を要素として持つ配列を返します。

[PARAM] v:

ブロック内で評価される(ベクトル or 配列)

[EXCEPTION] ExceptionForMatrix::ErrDimensionMismatch:

自分自身と引数のベクトルの要素の数(次元)が異なっていたときに発生します。

次の例は、２つのベクトルの要素毎の積を要素とする配列を生成します。

例:

require 'matrix'

v1 = Vector[2, 3, 5]
v2 = Vector[7, 9, 11]
a = Array[7, 9, 11]

z = v1.collect2(v2){|x, y| x * y }
p z #=> [14, 27, 55]

z = v1.collect2(a) {|x, y| x * y } # ArrayでもOK
p z #=> [14, 27, 55]

compare_by(elements) -> bool

自分自身と引数 elements を配列として比較します。

[PARAM] elements:

比較する配列。

[RETURN]

比較結果が(配列として)同じものあったときは true をそれ以外は false を返します。

covector -> Matrix

Matrix オブジェクトへ変換します。

列ベクトル (行列)、すなわち、(n, 1) 型の行列に変換します。 実際には Matrix.row_vector(self) を適用します。

例:

require 'matrix'

v = Vector[2, 3, 5]
p v #=> Vector[2, 3, 5]
m = v.covector
p m #=> Matrix[[2, 3, 5]]

each2(v) {|x, y| ... }

ベクトルの各要素と、それに対応するインデックスを持つ引数 v の要素との組に対して (2引数の) ブロックを繰返し評価します。`v' は size メソッドと [] メソッドを持つオブジェクトです。

elements_to_f -> Vector

ベクトルの各成分をFloatに変換したベクトルを返します。

例:

require 'matrix'

v = Vector.elements([2, 3, 5, 7, 9])
vf = v.elements_to_f
p vf #=> "Vector[2.0, 3.0, 5.0, 7.0, 9.0]"

elements_to_i -> Vector

ベクトルの各成分をIntegerに変換したベクトルを返します。

例:

require 'matrix'

v = Vector.elements([2.5, 3.0, 5.01, 7])
vi = v.elements_to_i
p vi #=> "Vector[2, 3, 5, 7]"

elements_to_r -> Vector

ベクトルの各成分をRationalに変換したベクトルを返します。

例:

require 'matrix'

v = Vector.elements([2.5, 3.0, 5.75, 7])
vr = v.elements_to_r
p vr #=> "Vector[Rational(5, 2), Rational(3, 1), Rational(23, 4), Rational(7, 1)]"

hash() -> Fixnum

自分自身のハッシュ値を返します。

init_elements(array, copy) -> Array

ベクトルの要素を引数 array で初期化します。

[PARAM] array:

ベクトルとして初期化する Array を指定します。

[PARAM] copy:

引数array で渡された配列をコピーするかをtrue/falseで指定します。 true の場合はコピーします。

注意:

本メソッドは[[c:Vector]]クラス内部用です。

inner_product(v) -> Float

ベクトル v との内積を返します。

[PARAM] v:

内積を求めるベクトル

[EXCEPTION] ExceptionForMatrix::ErrDimensionMismatch:

自分自身と引数のベクトルの要素の数(次元)が異なっていたときに発生します。

inspect() -> String

オブジェクトの内容を文字列化します。

map2(v) {|x, y| ... } -> Vector

ベクトルの各要素と引数 v の要素との組に対してブロックを評価し、その結果を要素として持つベクトルを返します。

ベクトルの各要素と、それに対応するインデックスを持つ引数 (ベクトル or 配列) の要素との組に対して (2引数の) ブロックを評価した結果を、要素として持つベクトルを返します。

[PARAM] v:

ブロック内で評価される(ベクトル or 配列)

[EXCEPTION] ExceptionForMatrix::ErrDimensionMismatch:

自分自身と引数のベクトルの要素の数(次元)が異なっていたときに発生します。

次の例は、２つのベクトルの要素毎の積を要素として持つベクトルを生成します。

例:

require 'matrix'

v1 = Vector[2, 3, 5]
v2 = Vector[7, 9, 11]
a = Array[7, 9, 11]

z = v1.map2(v2) {|x, y| x * y }
p z #=> Vector[14, 27, 55]

z = v1.map2(a) {|x, y| x * y } # ArrayでもOK
p z #=> Vector[14, 27, 55]

r -> Float

ベクトルの絶対値を返します。 ベクトルの絶対値は、各要素の２乗の和の正の平方根を返します。

size() -> Fixnum

ベクトルの要素数(次元)を返します。

to_a -> Array

ベクトル(Vector)から配列 (Array) に変換します。

例:

require 'matrix'

v = Vector[2, 3, 5, 7, 9]
a = v.to_a
p a #=> [2, 3, 5, 7, 9]

to_s -> String

ベクトル(Vector)から文字列 (String) に変換します。

例:

require 'matrix'

v = Vector[2, 3, 5, 7, 9]
s = v.to_s
p s #=> "Vector[2, 3, 5, 7, 9]"