• matrix.rb

Quicksearch

# Vector

The `Vector` class represents a mathematical vector, which is useful in its own right, and also constitutes a row or column of a Matrix.

## Method Catalogue¶ ↑

To create a Vector:

• ` Vector.[](*array) `

• ` Vector.elements(array, copy = true) `

To access elements:

• ` [](i) `

To enumerate the elements:

• ` #each2(v) `

• ` #collect2(v) `

Vector arithmetic:

• ` *(x) "is matrix or number" `

• ` +(v) `

• ` -(v) `

Vector functions:

• ` #inner_product(v) `

• ` #collect `

• ` #map `

• ` #map2(v) `

• ` #r `

• ` #size `

Conversion to other data types:

• ` #covector `

• ` #to_a `

• ` #coerce(other) `

String representations:

• ` #to_s `

• ` #inspect `

### Public Class Methods

[](*array) click to toggle source

Creates a Vector from a list of elements.

`Vector[7, 4, ...]`
```
# File matrix.rb, line 1090
def Vector.[](*array)
new(:init_elements, array, copy = false)
end
```
elements(array, copy = true) click to toggle source

Creates a vector from an Array. The optional second argument specifies whether the array itself or a copy is used internally.

```
# File matrix.rb, line 1098
def Vector.elements(array, copy = true)
new(:init_elements, array, copy)
end
```
new(method, array, copy) click to toggle source

For internal use.

```
# File matrix.rb, line 1105
def initialize(method, array, copy)
self.send(method, array, copy)
end
```

### Public Instance Methods

*(x) click to toggle source

Multiplies the vector by `x`, where `x` is a number or another vector.

```
# File matrix.rb, line 1216
def *(x)
case x
when Numeric
els = @elements.collect{|e| e * x}
Vector.elements(els, false)
when Matrix
Matrix.column_vector(self) * x
else
s, x = x.coerce(self)
s * x
end
end
```
+(v) click to toggle source

```
# File matrix.rb, line 1232
def +(v)
case v
when Vector
Vector.Raise ErrDimensionMismatch if size != v.size
els = collect2(v) {|v1, v2|
v1 + v2
}
Vector.elements(els, false)
when Matrix
Matrix.column_vector(self) + v
else
s, x = v.coerce(self)
s + x
end
end
```
-(v) click to toggle source

Vector subtraction.

```
# File matrix.rb, line 1251
def -(v)
case v
when Vector
Vector.Raise ErrDimensionMismatch if size != v.size
els = collect2(v) {|v1, v2|
v1 - v2
}
Vector.elements(els, false)
when Matrix
Matrix.column_vector(self) - v
else
s, x = v.coerce(self)
s - x
end
end
```
==(other) click to toggle source

Returns `true` iff the two vectors have the same elements in the same order.

```
# File matrix.rb, line 1177
def ==(other)
return false unless Vector === other

other.compare_by(@elements)
end
```
[](i) click to toggle source

Returns element number `i` (starting at zero) of the vector.

```
# File matrix.rb, line 1125
def [](i)
@elements[i]
end
```
Also aliased as: element, component
clone() click to toggle source

Return a copy of the vector.

```
# File matrix.rb, line 1198
def clone
Vector.elements(@elements)
end
```
coerce(other) click to toggle source

FIXME: describe #coerce.

```
# File matrix.rb, line 1351
def coerce(other)
case other
when Numeric
return Matrix::Scalar.new(other), self
else
raise TypeError, "#{self.class} can't be coerced into #{other.class}"
end
end
```
collect() click to toggle source

Like Array#collect.

```
# File matrix.rb, line 1288
def collect # :yield: e
els = @elements.collect {|v|
yield v
}
Vector.elements(els, false)
end
```
Also aliased as: map
collect2(v) click to toggle source

Collects (as in Enumerable#collect) over the elements of this vector and `v` in conjunction.

```
# File matrix.rb, line 1163
def collect2(v) # :yield: e1, e2
Vector.Raise ErrDimensionMismatch if size != v.size
(0 .. size - 1).collect do |i|
yield @elements[i], v[i]
end
end
```
compare_by(elements, comparison = :==) click to toggle source

For internal use.

```
# File matrix.rb, line 1191
def compare_by(elements, comparison = :==)
@elements.send(comparison, elements)
end
```
component(i) click to toggle source
Alias for: []
covector() click to toggle source

Creates a single-row matrix from this vector.

```
# File matrix.rb, line 1325
def covector
Matrix.row_vector(self)
end
```
each2(v) click to toggle source

Iterate over the elements of this vector and `v` in conjunction.

```
# File matrix.rb, line 1152
def each2(v) # :yield: e1, e2
Vector.Raise ErrDimensionMismatch if size != v.size
0.upto(size - 1) do |i|
yield @elements[i], v[i]
end
end
```
element(i) click to toggle source
Alias for: []
elements_to_f() click to toggle source
```
# File matrix.rb, line 1336
def elements_to_f
collect{|e| e.to_f}
end
```
elements_to_i() click to toggle source
```
# File matrix.rb, line 1340
def elements_to_i
collect{|e| e.to_i}
end
```
elements_to_r() click to toggle source
```
# File matrix.rb, line 1344
def elements_to_r
collect{|e| e.to_r}
end
```
eql?(other) click to toggle source
```
# File matrix.rb, line 1182
def eql?(other)
return false unless Vector === other

other.compare_by(@elements, :eql?)
end
```
hash() click to toggle source

Return a hash-code for the vector.

```
# File matrix.rb, line 1205
def hash
@elements.hash
end
```
init_elements(array, copy) click to toggle source

For internal use.

```
# File matrix.rb, line 1112
def init_elements(array, copy)
if copy
@elements = array.dup
else
@elements = array
end
end
```
inner_product(v) click to toggle source

Returns the inner product of this vector with the other.

```Vector[4,7].inner_product Vector[10,1]  => 47
```
```
# File matrix.rb, line 1275
def inner_product(v)
Vector.Raise ErrDimensionMismatch if size != v.size

p = 0
each2(v) {|v1, v2|
p += v1 * v2
}
p
end
```
inspect() click to toggle source

Overrides Object#inspect

```
# File matrix.rb, line 1374
def inspect
str = "Vector"+@elements.inspect
end
```
map() click to toggle source
Alias for: collect
map2(v) click to toggle source

Like #collect2, but returns a Vector instead of an Array.

```
# File matrix.rb, line 1299
def map2(v) # :yield: e1, e2
els = collect2(v) {|v1, v2|
yield v1, v2
}
Vector.elements(els, false)
end
```
r() click to toggle source

Returns the modulus (Pythagorean distance) of the vector.

`Vector[5,8,2].r => 9.643650761`
```
# File matrix.rb, line 1310
def r
v = 0
for e in @elements
v += e*e
end
return Math.sqrt(v)
end
```
size() click to toggle source

Returns the number of elements in the vector.

```
# File matrix.rb, line 1141
def size
@elements.size
end
```
to_a() click to toggle source

Returns the elements of the vector in an array.

```
# File matrix.rb, line 1332
def to_a
@elements.dup
end
```
to_s() click to toggle source

Overrides Object#to_s

```
# File matrix.rb, line 1367
def to_s
"Vector[" + @elements.join(", ") + "]"
end
```

Commenting is here to help enhance the documentation. For example, code samples, or clarification of the documentation.

If you have questions about Ruby or the documentation, please post to one of the Ruby mailing lists. You will get better, faster, help that way.

If you wish to post a correction of the docs, please do so, but also file bug report so that it can be corrected for the next release. Thank you.

If you want to help improve the Ruby documentation, please visit Documenting-ruby.org.