• 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:

To access elements:

To enumerate the elements:

Vector arithmetic:

• #*(x) “is matrix or number”

• #+(v)

• #-(v)

Vector functions:

Conversion to other data types:

String representations:

### Attributes

elements[R]

INSTANCE CREATION

### Public Class Methods

[](*array) click to toggle source

Creates a Vector from a list of elements.

`Vector[7, 4, ...]`
```
# File matrix.rb, line 1555
def Vector.[](*array)
new convert_to_array(array, 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 1563
def Vector.elements(array, copy = true)
new convert_to_array(array, copy)
end
```
new(array) click to toggle source

::new is private; use Vector[] or ::elements to create.

```
# File matrix.rb, line 1570
def initialize(array)
# No checking is done at this point.
@elements = array
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 1677
def *(x)
case x
when Numeric
els = @elements.collect{|e| e * x}
self.class.elements(els, false)
when Matrix
Matrix.column_vector(self) * x
when Vector
Vector.Raise ErrOperationNotDefined, "*", self.class, x.class
else
apply_through_coercion(x, __method__)
end
end
```
+(v) click to toggle source

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

Vector subtraction.

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

Vector division.

```
# File matrix.rb, line 1730
def /(x)
case x
when Numeric
els = @elements.collect{|e| e / x}
self.class.elements(els, false)
when Matrix, Vector
Vector.Raise ErrOperationNotDefined, "/", self.class, x.class
else
apply_through_coercion(x, __method__)
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 1646
def ==(other)
return false unless Vector === other
@elements == other.elements
end
```
[](i) click to toggle source

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

```
# File matrix.rb, line 1580
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 1659
def clone
self.class.elements(@elements)
end
```
coerce(other) click to toggle source

The coerce method provides support for Ruby type coercion. This coercion mechanism is used by Ruby to handle mixed-type numeric operations: it is intended to find a compatible common type between the two operands of the operator. See also Numeric#coerce.

```
# File matrix.rb, line 1854
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 1774
def collect(&block) # :yield: e
els = @elements.collect(&block)
self.class.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 1630
def collect2(v) # :yield: e1, e2
raise TypeError, "Integer is not like Vector" if v.kind_of?(Integer)
Vector.Raise ErrDimensionMismatch if size != v.size
Array.new(size) do |i|
yield @elements[i], v[i]
end
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 1821
def covector
Matrix.row_vector(self)
end
```
cross_product(v) click to toggle source

Returns the cross product of this vector with the other.

```Vector[1, 0, 0].cross_product Vector[0, 1, 0]   => Vector[0, 0, 1]
```
```
# File matrix.rb, line 1764
def cross_product(v)
Vector.Raise ErrDimensionMismatch unless size == v.size && v.size == 3
Vector[ v[1]*@elements[2] - v[2]*@elements[1],
v[2]*@elements[0] - v[0]*@elements[2],
v[0]*@elements[1] - v[1]*@elements[0] ]
end
```
each(&block) click to toggle source

Iterate over the elements of this vector

```
# File matrix.rb, line 1607
def each(&block)
@elements.each(&block)
self
end
```
each2(v) click to toggle source

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

```
# File matrix.rb, line 1616
def each2(v) # :yield: e1, e2
raise TypeError, "Integer is not like Vector" if v.kind_of?(Integer)
Vector.Raise ErrDimensionMismatch if size != v.size
size.times do |i|
yield @elements[i], v[i]
end
self
end
```
element(i) click to toggle source
Alias for: []
elements_to_f() click to toggle source
```
# File matrix.rb, line 1832
def elements_to_f
warn "#{caller(1)[0]}: warning: Vector#elements_to_f is deprecated"
map(&:to_f)
end
```
elements_to_i() click to toggle source
```
# File matrix.rb, line 1837
def elements_to_i
warn "#{caller(1)[0]}: warning: Vector#elements_to_i is deprecated"
map(&:to_i)
end
```
elements_to_r() click to toggle source
```
# File matrix.rb, line 1842
def elements_to_r
warn "#{caller(1)[0]}: warning: Vector#elements_to_r is deprecated"
map(&:to_r)
end
```
eql?(other) click to toggle source
```
# File matrix.rb, line 1651
def eql?(other)
return false unless Vector === other
@elements.eql? other.elements
end
```
hash() click to toggle source

Return a hash-code for the vector.

```
# File matrix.rb, line 1666
def hash
@elements.hash
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 1750
def inner_product(v)
Vector.Raise ErrDimensionMismatch if size != v.size

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

Overrides Object#inspect

```
# File matrix.rb, line 1877
def inspect
"Vector" + @elements.inspect
end
```
magnitude() click to toggle source

Returns the modulus (Pythagorean distance) of the vector.

`Vector[5,8,2].r => 9.643650761`
```
# File matrix.rb, line 1785
def magnitude
Math.sqrt(@elements.inject(0) {|v, e| v + e.abs2})
end
```
Also aliased as: r, norm
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 1794
def map2(v, &block) # :yield: e1, e2
els = collect2(v, &block)
self.class.elements(els, false)
end
```
norm() click to toggle source
Alias for: magnitude
normalize() click to toggle source

Returns a new vector with the same direction but with norm 1.

```v = Vector[5,8,2].normalize
# => Vector[0.5184758473652127, 0.8295613557843402, 0.20739033894608505]
v.norm => 1.0```
```
# File matrix.rb, line 1808
def normalize
n = magnitude
raise ZeroVectorError, "Zero vectors can not be normalized" if n == 0
self / n
end
```
r() click to toggle source
Alias for: magnitude
size() click to toggle source

Returns the number of elements in the vector.

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

Returns the elements of the vector in an array.

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

Overrides Object#to_s

```
# File matrix.rb, line 1870
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.