# Class: Vector

Inherits:
Object
• Object
show all
Extended by:
Matrix::ConversionHelper
Includes:
Enumerable, ExceptionForMatrix, Matrix::CoercionHelper
Defined in:
lib/matrix.rb

## Overview

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)

• #cross_product(v)

• #collect

• #magnitude

• #map

• #map2(v)

• #norm

• #normalize

• #r

• #size

Conversion to other data types:

• #covector

• #to_a

• #coerce(other)

String representations:

• #to_s

• #inspect

## Defined Under Namespace

Classes: ZeroVectorError

## Class Method Summary collapse

• Creates a Vector from a list of elements.

• Creates a vector from an Array.

## Instance Method Summary collapse

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

• Vector subtraction.

• Vector division.

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

• #[](i) ⇒ Object (also: #element, #component)

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

• Return a copy of the vector.

• The coerce method provides support for Ruby type coercion.

• #collect(&block) ⇒ Object (also: #map)

Like Array#collect.

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

• Creates a single-row matrix from this vector.

• Returns the cross product of this vector with the other.

• Iterate over the elements of this vector.

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

• Return a hash-code for the vector.

• constructor

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

• Returns the inner product of this vector with the other.

• Overrides Object#inspect.

• #magnitude ⇒ Object (also: #r, #norm)

Returns the modulus (Pythagorean distance) of the vector.

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

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

• Returns the number of elements in the vector.

• Returns the elements of the vector in an array.

• Overrides Object#to_s.

## Constructor Details

### #initialize(array) ⇒ Vector

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

 ``` 1571 1572 1573 1574``` ```# File 'lib/matrix.rb', line 1571 def initialize(array) # No checking is done at this point. @elements = array end ```

## Class Method Details

### .[](*array) ⇒ Object

Creates a Vector from a list of elements.

``````Vector[7, 4, ...]
``````
 ``` 1556 1557 1558``` ```# File 'lib/matrix.rb', line 1556 def Vector.[](*array) new convert_to_array(array, false) end ```

### .elements(array, copy = true) ⇒ Object

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

 ``` 1564 1565 1566``` ```# File 'lib/matrix.rb', line 1564 def Vector.elements(array, copy = true) new convert_to_array(array, copy) end ```

## Instance Method Details

### #*(x) ⇒ Object

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

 ``` 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690``` ```# File 'lib/matrix.rb', line 1678 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) ⇒ Object

 ``` 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708``` ```# File 'lib/matrix.rb', line 1695 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) ⇒ Object

Vector subtraction.

 ``` 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726``` ```# File 'lib/matrix.rb', line 1713 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) ⇒ Object

Vector division.

 ``` 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741``` ```# File 'lib/matrix.rb', line 1731 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) ⇒ Object

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

 ``` 1647 1648 1649 1650``` ```# File 'lib/matrix.rb', line 1647 def ==(other) return false unless Vector === other @elements == other.elements end ```

### #[](i) ⇒ ObjectAlso known as: element, component

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

 ``` 1581 1582 1583``` ```# File 'lib/matrix.rb', line 1581 def [](i) @elements[i] end ```

### #clone ⇒ Object

Return a copy of the vector.

 ``` 1660 1661 1662``` ```# File 'lib/matrix.rb', line 1660 def clone self.class.elements(@elements) end ```

### #coerce(other) ⇒ Object

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.

 ``` 1855 1856 1857 1858 1859 1860 1861 1862``` ```# File 'lib/matrix.rb', line 1855 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(&block) ⇒ ObjectAlso known as: map

Like Array#collect.

 ``` 1775 1776 1777 1778 1779``` ```# File 'lib/matrix.rb', line 1775 def collect(&block) # :yield: e return to_enum(:collect) unless block_given? els = @elements.collect(&block) self.class.elements(els, false) end ```

### #collect2(v) ⇒ Object

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

Raises:

• (TypeError)
 ``` 1631 1632 1633 1634 1635 1636 1637 1638``` ```# File 'lib/matrix.rb', line 1631 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 return to_enum(:collect2, v) unless block_given? Array.new(size) do |i| yield @elements[i], v[i] end end ```

### #covector ⇒ Object

Creates a single-row matrix from this vector.

 ``` 1822 1823 1824``` ```# File 'lib/matrix.rb', line 1822 def covector Matrix.row_vector(self) end ```

### #cross_product(v) ⇒ Object

Returns the cross product of this vector with the other.

``````Vector[1, 0, 0].cross_product Vector[0, 1, 0]   => Vector[0, 0, 1]
``````
 ``` 1765 1766 1767 1768 1769 1770``` ```# File 'lib/matrix.rb', line 1765 def cross_product(v) Vector.Raise ErrDimensionMismatch unless size == v.size && v.size == 3 Vector[ v[2]*@elements[1] - v[1]*@elements[2], v[0]*@elements[2] - v[2]*@elements[0], v[1]*@elements[0] - v[0]*@elements[1] ] end ```

### #each(&block) ⇒ Object

Iterate over the elements of this vector

 ``` 1608 1609 1610 1611 1612``` ```# File 'lib/matrix.rb', line 1608 def each(&block) return to_enum(:each) unless block_given? @elements.each(&block) self end ```

### #each2(v) ⇒ Object

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

Raises:

• (TypeError)
 ``` 1617 1618 1619 1620 1621 1622 1623 1624 1625``` ```# File 'lib/matrix.rb', line 1617 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 return to_enum(:each2, v) unless block_given? size.times do |i| yield @elements[i], v[i] end self end ```

### #elements_to_f ⇒ Object

 ``` 1833 1834 1835 1836``` ```# File 'lib/matrix.rb', line 1833 def elements_to_f warn "#{caller(1)[0]}: warning: Vector#elements_to_f is deprecated" map(&:to_f) end ```

### #elements_to_i ⇒ Object

 ``` 1838 1839 1840 1841``` ```# File 'lib/matrix.rb', line 1838 def elements_to_i warn "#{caller(1)[0]}: warning: Vector#elements_to_i is deprecated" map(&:to_i) end ```

### #elements_to_r ⇒ Object

 ``` 1843 1844 1845 1846``` ```# File 'lib/matrix.rb', line 1843 def elements_to_r warn "#{caller(1)[0]}: warning: Vector#elements_to_r is deprecated" map(&:to_r) end ```

### #eql?(other) ⇒ Boolean

 ``` 1652 1653 1654 1655``` ```# File 'lib/matrix.rb', line 1652 def eql?(other) return false unless Vector === other @elements.eql? other.elements end ```

### #hash ⇒ Object

Return a hash-code for the vector.

 ``` 1667 1668 1669``` ```# File 'lib/matrix.rb', line 1667 def hash @elements.hash end ```

### #inner_product(v) ⇒ Object

Returns the inner product of this vector with the other.

``````Vector[4,7].inner_product Vector[10,1]  => 47
``````
 ``` 1751 1752 1753 1754 1755 1756 1757 1758 1759``` ```# File 'lib/matrix.rb', line 1751 def inner_product(v) Vector.Raise ErrDimensionMismatch if size != v.size p = 0 each2(v) {|v1, v2| p += v1 * v2.conj } p end ```

### #inspect ⇒ Object

Overrides Object#inspect

 ``` 1878 1879 1880``` ```# File 'lib/matrix.rb', line 1878 def inspect "Vector" + @elements.inspect end ```

### #magnitude ⇒ ObjectAlso known as: r, norm

Returns the modulus (Pythagorean distance) of the vector.

``````Vector[5,8,2].r => 9.643650761
``````
 ``` 1786 1787 1788``` ```# File 'lib/matrix.rb', line 1786 def magnitude Math.sqrt(@elements.inject(0) {|v, e| v + e.abs2}) end ```

### #map2(v, &block) ⇒ Object

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

 ``` 1795 1796 1797 1798 1799``` ```# File 'lib/matrix.rb', line 1795 def map2(v, &block) # :yield: e1, e2 return to_enum(:map2, v) unless block_given? els = collect2(v, &block) self.class.elements(els, false) end ```

### #normalize ⇒ Object

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

Raises:

 ``` 1809 1810 1811 1812 1813``` ```# File 'lib/matrix.rb', line 1809 def normalize n = magnitude raise ZeroVectorError, "Zero vectors can not be normalized" if n == 0 self / n end ```

### #size ⇒ Object

Returns the number of elements in the vector.

 ``` 1597 1598 1599``` ```# File 'lib/matrix.rb', line 1597 def size @elements.size end ```

### #to_a ⇒ Object

Returns the elements of the vector in an array.

 ``` 1829 1830 1831``` ```# File 'lib/matrix.rb', line 1829 def to_a @elements.dup end ```

### #to_s ⇒ Object

Overrides Object#to_s

 ``` 1871 1872 1873``` ```# File 'lib/matrix.rb', line 1871 def to_s "Vector[" + @elements.join(", ") + "]" end ```