# Vector (Class)

In: | matrix.rb
Parent: | Object

## 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 1047
      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 1055
      def Vector.elements(array, copy = true)
        new(:init_elements, array, copy)
      end

new(method, array, copy)

For internal use.

[Source]

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

## Public Instance methods

init_elements(array, copy)

For internal use.

[Source]

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

[](i)

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

[Source]

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

size()

Returns the number of elements in the vector.

[Source]

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

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

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

[Source]

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

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

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

[Source]

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

==(other)

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

[Source]

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

        other.compare_by(@elements)
      end

eqn?(other)

Alias for #==

compare_by(elements)

For internal use.

[Source]

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

clone()

Return a copy of the vector.

[Source]

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

hash()

Return a hash-code for the vector.

[Source]

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

*(x)

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

[Source]

    # File matrix.rb, line 1162
      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 1178
      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 1198
      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

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 1223
      def inner_product(v)
        Vector.Raise ErrDimensionMismatch if size != v.size

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

collect() {|e| ...}

Like Array#collect.

[Source]

    # File matrix.rb, line 1237
      def collect # :yield: e

        els = @elements.collect {
          |v|
          yield v
        }
        Vector.elements(els, false)
      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 1249
      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 1261
      def r
        v = 0
        for e in @elements
          v += e*e
        end
        return Math.sqrt(v)
      end

covector()

Creates a single-row matrix from this vector.

[Source]

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

to_a()

Returns the elements of the vector in an array.

[Source]

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

coerce(other)

FIXME: describe Vector#coerce.

[Source]

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

to_s()

Overrides Object#to_s

[Source]

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

inspect()

Overrides Object#inspect

[Source]

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

[Validate]