Class | Vector
In: | matrix.rb
Parent: | Object

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`

### Methods

* + - == [] [] clone coerce collect collect2 compare_by covector each2 elements eqn? hash init_elements inner_product inspect map map2 new r size to_a to_s

### Included Modules

ExceptionForMatrix

### Public Class methods

[](*array)

Creates a Vector from a list of elements.

      Vector[7, 4, ...]

[Source]

    # File matrix.rb, line 999
      def Vector.[](*array)
        new(:init_elements, array, copy = false)
      end

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.

[Source]

    # File matrix.rb, line 1007
      def Vector.elements(array, copy = true)
        new(:init_elements, array, copy)
      end

new(method, array, copy)

For internal use.

[Source]

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

### Public Instance methods

*(x)

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

[Source]

    # File matrix.rb, line 1114
      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)

Vector addition.

[Source]

    # File matrix.rb, line 1130
      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)

Vector subtraction.

[Source]

    # File matrix.rb, line 1150
      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)

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

[Source]

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

        other.compare_by(@elements)
      end

[](i)

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

[Source]

    # File matrix.rb, line 1034
      def [](i)
        @elements[i]
      end

clone()

Return a copy of the vector.

[Source]

    # File matrix.rb, line 1096
      def clone
        Vector.elements(@elements)
      end

coerce(other)

FIXME: describe Vector#coerce.

[Source]

    # File matrix.rb, line 1242
      def coerce(other)
        case other
        when Numeric
          return Scalar.new(other), self
        else
          raise TypeError, "#{self.class} can't be coerced into #{other.class}"
        end
      end

collect( {|e| ...}

Like Array#collect.

[Source]

    # File matrix.rb, line 1189
      def collect # :yield: e
        els = @elements.collect {
          |v|
          yield v
        }
        Vector.elements(els, false)
      end

collect2(v) {|e1, e2| ...}

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

[Source]

    # File matrix.rb, line 1064
      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)

For internal use.

[Source]

    # File matrix.rb, line 1089
      def compare_by(elements)
        @elements == elements
      end

covector()

Creates a single-row matrix from this vector.

[Source]

    # File matrix.rb, line 1228
      def covector
        Matrix.row_vector(self)
      end

each2(v) {|e1, e2| ...}

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

[Source]

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

eqn?(other)

Alias for #==

hash()

Return a hash-code for the vector.

[Source]

    # File matrix.rb, line 1103
      def hash
        @elements.hash
      end

init_elements(array, copy)

For internal use.

[Source]

    # File matrix.rb, line 1021
      def init_elements(array, copy)
        if copy
          @elements = array.dup
        else
          @elements = array
        end
      end

inner_product(v)

Returns the inner product of this vector with the other.

      Vector[4,7].inner_product Vector[10,1]  => 47

[Source]

    # File matrix.rb, line 1175
      def inner_product(v)
        Vector.Raise ErrDimensionMismatch if size != v.size

        p = 0
        each2(v) {
          |v1, v2|
          p += v1 * v2
        }
        p
      end

inspect()

Overrides Object#inspect

[Source]

    # File matrix.rb, line 1265
      def inspect
        str = "Vector"+@elements.inspect
      end

map(

Alias for collect

map2(v) {|e1, e2| ...}

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

[Source]

    # File matrix.rb, line 1201
      def map2(v) # :yield: e1, e2
        els = collect2(v) {
          |v1, v2|
          yield v1, v2
        }
        Vector.elements(els, false)
      end

r()

Returns the modulus (Pythagorean distance) of the vector.

      Vector[5,8,2].r => 9.643650761

[Source]

    # File matrix.rb, line 1213
      def r
        v = 0
        for e in @elements
          v += e*e
        end
        return Math.sqrt(v)
      end

size()

Returns the number of elements in the vector.

[Source]

    # File matrix.rb, line 1041
      def size
        @elements.size
      end

to_a()

Returns the elements of the vector in an array.

[Source]

    # File matrix.rb, line 1235
      def to_a
        @elements.dup
      end

to_s()

Overrides Object#to_s

[Source]

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

[Validate]