Class: Vector

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

Constant Summary

Constants included from Exception2MessageMapper

Exception2MessageMapper::E2MM

Instance Attribute Summary (collapse)

Class Method Summary (collapse)

Instance Method Summary (collapse)

Methods included from Matrix::ConversionHelper

convert_to_array

Methods included from Matrix::CoercionHelper

#apply_through_coercion, coerce_to, coerce_to_int

Methods included from Enumerable

#to_set

Methods included from Exception2MessageMapper

#Fail, #Raise, Raise, #bind, #def_e2message, def_e2message, #def_exception, def_exception, e2mm_message, extend_object, #fail

Constructor Details

- (Vector) initialize(array)

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

Instance Attribute Details

- (Object) elements (readonly, protected)

Returns the value of attribute elements



1549
1550
1551
# File 'lib/matrix.rb', line 1549

def elements
  @elements
end

Class Method Details

+ (Object) [](*array)

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

+ (Object) elements(array, copy = true)

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

- (Object) *(x)

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

- (Object) +(v)

Vector addition.



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

- (Object) -(v)

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

- (Object) /(x)

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

- (Object) ==(other)

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

- (Object) [](i) Also 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

- (Object) []=(i, v) (private) Also known as: set_element, set_component



1587
1588
1589
# File 'lib/matrix.rb', line 1587

def []=(i, v)
  @elements[i]= v
end

- (Object) clone

Return a copy of the vector.



1660
1661
1662
# File 'lib/matrix.rb', line 1660

def clone
  self.class.elements(@elements)
end

- (Object) coerce(other)

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

- (Object) collect(&block) Also 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

- (Object) collect2(v)

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

- (Object) covector

Creates a single-row matrix from this vector.



1822
1823
1824
# File 'lib/matrix.rb', line 1822

def covector
  Matrix.row_vector(self)
end

- (Object) cross_product(v)

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[1]*@elements[2] - v[2]*@elements[1],
          v[2]*@elements[0] - v[0]*@elements[2],
          v[0]*@elements[1] - v[1]*@elements[0] ]
end

- (Object) each(&block)

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

- (Object) each2(v)

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

- (Object) elements_to_f



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

- (Object) elements_to_i



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

- (Object) elements_to_r



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

- (Boolean) eql?(other)

Returns:

  • (Boolean)


1652
1653
1654
1655
# File 'lib/matrix.rb', line 1652

def eql?(other)
  return false unless Vector === other
  @elements.eql? other.elements
end

- (Object) hash

Return a hash-code for the vector.



1667
1668
1669
# File 'lib/matrix.rb', line 1667

def hash
  @elements.hash
end

- (Object) inner_product(v)

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

- (Object) inspect

Overrides Object#inspect



1878
1879
1880
# File 'lib/matrix.rb', line 1878

def inspect
  "Vector" + @elements.inspect
end

- (Object) magnitude Also 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

- (Object) map2(v, &block)

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

- (Object) normalize

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

- (Object) size

Returns the number of elements in the vector.



1597
1598
1599
# File 'lib/matrix.rb', line 1597

def size
  @elements.size
end

- (Object) to_a

Returns the elements of the vector in an array.



1829
1830
1831
# File 'lib/matrix.rb', line 1829

def to_a
  @elements.dup
end

- (Object) to_s

Overrides Object#to_s



1871
1872
1873
# File 'lib/matrix.rb', line 1871

def to_s
  "Vector[" + @elements.join(", ") + "]"
end

Commenting is here to help enhance the documentation. For example, sample code, 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.

blog comments powered by Disqus