## org.apache.mahout.math
Interface Vector

All Superinterfaces:
  Cloneable

All Known Implementing Classes:
  AbstractMatrix.TransposeViewVector, AbstractVector, Centroid, ConstantVector, DelegatingVector, DenseVector, MatrixSlice, MatrixVectorView, NamedVector, PermutedVectorView, RandomAccessSparseVector, SequentialAccessSparseVector, VectorView, WeightedVector

    public interface Vector

extends Cloneable

The basic interface including numerous convenience functions

NOTE: All implementing classes must have a constructor that takes an int for cardinality and a no-arg constructor that can be used for marshalling the Writable instance

NOTE: Implementations may choose to reuse the Vector.Element in the Iterable methods

Nested Class Summary
`static interface` `Vector.Element` A holder for information about a specific item in the Vector.

Method Summary
`double` `aggregate(DoubleDoubleFunction aggregator, DoubleFunction map)` Examples speak louder than words: aggregate(plus, pow(2)) is another way to say getLengthSquared(), aggregate(max, abs) is norm(Double.POSITIVE_INFINITY).
`double` `aggregate(Vector other, DoubleDoubleFunction aggregator, DoubleDoubleFunction combiner)` Generalized inner product - take two vectors, iterate over them both, using the combiner to combine together (and possibly map in some way) each pair of values, which are then aggregated with the previous accumulated value in the combiner.
`Iterable<Vector.Element>` `all()`
`String` `asFormatString()`
`Vector` `assign(double value)` Assign the value to all elements of the receiver
`Vector` `assign(double[] values)` Assign the values to the receiver
`Vector` `assign(DoubleDoubleFunction f, double y)` Apply the function to each element of the receiver, using the y value as the second argument of the DoubleDoubleFunction
`Vector` `assign(DoubleFunction function)` Apply the function to each element of the receiver
`Vector` `assign(Vector other)` Assign the other vector values to the receiver
`Vector` `assign(Vector other, DoubleDoubleFunction function)` Apply the function to each element of the receiver and the corresponding element of the other argument
`Vector` `clone()` Return a copy of the recipient
`Matrix` `cross(Vector other)` Return the cross product of the receiver and the other vector
`Vector` `divide(double x)` Return a new vector containing the values of the recipient divided by the argument
`double` `dot(Vector x)` Return the dot product of the recipient and the argument
`double` `get(int index)` Return the value at the given index
`double` `getDistanceSquared(Vector v)` Get the square of the distance between this vector and the other vector.
`Vector.Element` `getElement(int index)` Return an object of Vector.Element representing an element of this Vector.
`double` `getIteratorAdvanceCost()` Gets an estimate of the cost (in number of operations) it takes to advance an iterator through the nonzero elements of this vector.
`double` `getLengthSquared()` Return the sum of squares of all elements in the vector.
`double` `getLookupCost()` Gets an estimate of the cost (in number of operations) it takes to lookup a random element in this vector.
`int` `getNumNondefaultElements()` Return the number of values in the recipient which are not the default value.
`int` `getNumNonZeroElements()` Return the number of non zero elements in the vector.
`double` `getQuick(int index)` Return the value at the given index, without checking bounds
`void` `incrementQuick(int index, double increment)` Increment the value at the given index by the given value.
`boolean` `isAddConstantTime()` Return true iff adding a new (nonzero) element takes constant time for this vector.
`boolean` `isDense()`
`boolean` `isSequentialAccess()`
`Vector` `like()` Return an empty vector of the same underlying class as the receiver
`Vector` `logNormalize()` Return a new vector containing the log(1 + entry)/ L_2 norm values of the recipient
`Vector` `logNormalize(double power)` Return a new Vector with a normalized value calculated as log_power(1 + entry)/ L_power norm.
`double` `maxValue()`
`int` `maxValueIndex()`
`void` `mergeUpdates(OrderedIntDoubleMapping updates)` Merge a set of (index, value) pairs into the vector.
`Vector` `minus(Vector x)` Return a new vector containing the element by element difference of the recipient and the argument
`double` `minValue()`
`int` `minValueIndex()`
`Iterable<Vector.Element>` `nonZeroes()`
`double` `norm(double power)` Return the k-norm of the vector.
`Vector` `normalize()` Return a new vector containing the normalized (L_2 norm) values of the recipient
`Vector` `normalize(double power)` Return a new Vector containing the normalized (L_power norm) values of the recipient.
`Vector` `plus(double x)` Return a new vector containing the sum of each value of the recipient and the argument
`Vector` `plus(Vector x)` Return a new vector containing the element by element sum of the recipient and the argument
`void` `set(int index, double value)` Set the value at the given index
`void` `setQuick(int index, double value)` Set the value at the given index, without checking bounds
`int` `size()` Return the cardinality of the recipient (the maximum number of values)
`Vector` `times(double x)` Return a new vector containing the product of each value of the recipient and the argument
`Vector` `times(Vector x)` Return a new vector containing the element-wise product of the recipient and the argument
`Vector` `viewPart(int offset, int length)` Return a new vector containing the subset of the recipient
`double` `zSum()` Return the sum of all the elements of the receiver

Method Detail

### asFormatString

    String asFormatString()

  Returns:
    a formatted String suitable for output

### assign

    Vector assign(double value)

  Assign the value to all elements of the receiver

  Parameters:
    `value` - a double value
  Returns:
    the modified receiver

### assign

    Vector assign(double[] values)

  Assign the values to the receiver

  Parameters:
    `values` - a double[] of values
  Returns:
    the modified receiver
  Throws:
    `CardinalityException` - if the cardinalities differ

### assign

    Vector assign(Vector other)

  Assign the other vector values to the receiver

  Parameters:
    `other` - a Vector
  Returns:
    the modified receiver
  Throws:
    `CardinalityException` - if the cardinalities differ

### assign

    Vector assign(DoubleFunction function)

  Apply the function to each element of the receiver

  Parameters:
    `function` - a DoubleFunction to apply
  Returns:
    the modified receiver

### assign

    Vector assign(Vector other,
                  DoubleDoubleFunction function)

  Apply the function to each element of the receiver and the corresponding element of the other argument

  Parameters:
    `other` - a Vector containing the second arguments to the function
    `function` - a DoubleDoubleFunction to apply
  Returns:
    the modified receiver
  Throws:
    `CardinalityException` - if the cardinalities differ

### assign

    Vector assign(DoubleDoubleFunction f,
                  double y)

  Apply the function to each element of the receiver, using the y value as the second argument of the DoubleDoubleFunction

  Parameters:
    `f` - a DoubleDoubleFunction to be applied
    `y` - a double value to be argument to the function
  Returns:
    the modified receiver

### size

    int size()

  Return the cardinality of the recipient (the maximum number of values)

  Returns:
    an int

### isDense

    boolean isDense()

  Returns:
    true iff this implementation should be considered dense -- that it explicitly represents every value

### isSequentialAccess

    boolean isSequentialAccess()

  Returns:
    true iff this implementation should be considered to be iterable in index order in an efficient way. In particular this implies that `all()` and `nonZeroes()` ()} return elements in ascending order by index.

### clone

    Vector clone()

  Return a copy of the recipient

  Returns:
    a new Vector

### all

    Iterable<Vector.Element> all()

### nonZeroes

    Iterable<Vector.Element> nonZeroes()

### getElement

    Vector.Element getElement(int index)

  Return an object of Vector.Element representing an element of this Vector. Useful when designing new iterator types.

  Parameters:
    `index` - Index of the Vector.Element required
  Returns:
    The Vector.Element Object

### mergeUpdates

    void mergeUpdates(OrderedIntDoubleMapping updates)

  Merge a set of (index, value) pairs into the vector.

  Parameters:
    `updates` - an ordered mapping of indices to values to be merged in.

### divide

    Vector divide(double x)

  Return a new vector containing the values of the recipient divided by the argument

  Parameters:
    `x` - a double value
  Returns:
    a new Vector

### dot

    double dot(Vector x)

  Return the dot product of the recipient and the argument

  Parameters:
    `x` - a Vector
  Returns:
    a new Vector
  Throws:
    `CardinalityException` - if the cardinalities differ

### get

    double get(int index)

  Return the value at the given index

  Parameters:
    `index` - an int index
  Returns:
    the double at the index
  Throws:
    `IndexException` - if the index is out of bounds

### getQuick

    double getQuick(int index)

  Return the value at the given index, without checking bounds

  Parameters:
    `index` - an int index
  Returns:
    the double at the index

### like

    Vector like()

  Return an empty vector of the same underlying class as the receiver

  Returns:
    a Vector

### minus

    Vector minus(Vector x)

  Return a new vector containing the element by element difference of the recipient and the argument

  Parameters:
    `x` - a Vector
  Returns:
    a new Vector
  Throws:
    `CardinalityException` - if the cardinalities differ

### normalize

    Vector normalize()

  Return a new vector containing the normalized (L_2 norm) values of the recipient

  Returns:
    a new Vector

### normalize

    Vector normalize(double power)

  Return a new Vector containing the normalized (L_power norm) values of the recipient.

  See http://en.wikipedia.org/wiki/Lp_space

  Technically, when 0 < power < 1, we don't have a norm, just a metric, but we'll overload this here.

  Also supports power == 0 (number of non-zero elements) and power = `Double.POSITIVE_INFINITY` (max element). Again, see the Wikipedia page for more info

  Parameters:
    `power` - The power to use. Must be >= 0. May also be `Double.POSITIVE_INFINITY`. See the Wikipedia link for more on this.
  Returns:
    a new Vector x such that norm(x, power) == 1

### logNormalize

    Vector logNormalize()

  Return a new vector containing the log(1 + entry)/ L_2 norm values of the recipient

  Returns:
    a new Vector

### logNormalize

    Vector logNormalize(double power)

  Return a new Vector with a normalized value calculated as log_power(1 + entry)/ L_power norm.

  Parameters:
    `power` - The power to use. Must be > 1. Cannot be `Double.POSITIVE_INFINITY`.
  Returns:
    a new Vector

### norm

    double norm(double power)

  Return the k-norm of the vector.

  See http://en.wikipedia.org/wiki/Lp_space

  Technically, when 0 > power < 1, we don't have a norm, just a metric, but we'll overload this here. Also supports power == 0 (number of non-zero elements) and power = `Double.POSITIVE_INFINITY` (max element). Again, see the Wikipedia page for more info.

  Parameters:
    `power` - The power to use.
  See Also:
    `normalize(double)`

### minValue

    double minValue()

  Returns:
    The minimum value in the Vector

### minValueIndex

    int minValueIndex()

  Returns:
    The index of the minimum value

### maxValue

    double maxValue()

  Returns:
    The maximum value in the Vector

### maxValueIndex

    int maxValueIndex()

  Returns:
    The index of the maximum value

### plus

    Vector plus(double x)

  Return a new vector containing the sum of each value of the recipient and the argument

  Parameters:
    `x` - a double
  Returns:
    a new Vector

### plus

    Vector plus(Vector x)

  Return a new vector containing the element by element sum of the recipient and the argument

  Parameters:
    `x` - a Vector
  Returns:
    a new Vector
  Throws:
    `CardinalityException` - if the cardinalities differ

### set

    void set(int index,
             double value)

  Set the value at the given index

  Parameters:
    `index` - an int index into the receiver
    `value` - a double value to set
  Throws:
    `IndexException` - if the index is out of bounds

### setQuick

    void setQuick(int index,
                  double value)

  Set the value at the given index, without checking bounds

  Parameters:
    `index` - an int index into the receiver
    `value` - a double value to set

### incrementQuick

    void incrementQuick(int index,
                        double increment)

  Increment the value at the given index by the given value.

  Parameters:
    `index` - an int index into the receiver
    `increment` - sets the value at the given index to value + increment;

### getNumNondefaultElements

    int getNumNondefaultElements()

  Return the number of values in the recipient which are not the default value. For instance, for a sparse vector, this would be the number of non-zero values.

  Returns:
    an int

### getNumNonZeroElements

    int getNumNonZeroElements()

  Return the number of non zero elements in the vector.

  Returns:
    an int

### times

    Vector times(double x)

  Return a new vector containing the product of each value of the recipient and the argument

  Parameters:
    `x` - a double argument
  Returns:
    a new Vector

### times

    Vector times(Vector x)

  Return a new vector containing the element-wise product of the recipient and the argument

  Parameters:
    `x` - a Vector argument
  Returns:
    a new Vector
  Throws:
    `CardinalityException` - if the cardinalities differ

### viewPart

    Vector viewPart(int offset,
                    int length)

  Return a new vector containing the subset of the recipient

  Parameters:
    `offset` - an int offset into the receiver
    `length` - the cardinality of the desired result
  Returns:
    a new Vector
  Throws:
    `CardinalityException` - if the length is greater than the cardinality of the receiver
    `IndexException` - if the offset is negative or the offset+length is outside of the receiver

### zSum

    double zSum()

  Return the sum of all the elements of the receiver

  Returns:
    a double

### cross

    Matrix cross(Vector other)

  Return the cross product of the receiver and the other vector

  Parameters:
    `other` - another Vector
  Returns:
    a Matrix

### aggregate

    double aggregate(DoubleDoubleFunction aggregator,
                     DoubleFunction map)

  Examples speak louder than words: aggregate(plus, pow(2)) is another way to say getLengthSquared(), aggregate(max, abs) is norm(Double.POSITIVE_INFINITY). To sum all of the positive values, aggregate(plus, max(0)).

  Parameters:
    `aggregator` - used to combine the current value of the aggregation with the result of map.apply(nextValue)
    `map` - a function to apply to each element of the vector in turn before passing to the aggregator
  Returns:
    the final aggregation

### aggregate

    double aggregate(Vector other,
                     DoubleDoubleFunction aggregator,
                     DoubleDoubleFunction combiner)

  Generalized inner product - take two vectors, iterate over them both, using the combiner to combine together (and possibly map in some way) each pair of values, which are then aggregated with the previous accumulated value in the combiner.

  Example: dot(other) could be expressed as aggregate(other, Plus, Times), and kernelized inner products (which are symmetric on the indices) work similarly.

  Parameters:
    `other` - a vector to aggregate in combination with
    `aggregator` - function we're aggregating with; fa
    `combiner` - function we're combining with; fc
  Returns:
    the final aggregation; if r0 = fc(this[0], other[0]), ri = fa(r_{i-1}, fc(this[i], other[i])) for all i > 0

### getLengthSquared

    double getLengthSquared()

  Return the sum of squares of all elements in the vector. Square root of this value is the length of the vector.

### getDistanceSquared

    double getDistanceSquared(Vector v)

  Get the square of the distance between this vector and the other vector.

### getLookupCost

    double getLookupCost()

  Gets an estimate of the cost (in number of operations) it takes to lookup a random element in this vector.

### getIteratorAdvanceCost

    double getIteratorAdvanceCost()

  Gets an estimate of the cost (in number of operations) it takes to advance an iterator through the nonzero elements of this vector.

### isAddConstantTime

    boolean isAddConstantTime()

  Return true iff adding a new (nonzero) element takes constant time for this vector.

Copyright © 2008–2014 The Apache Software Foundation. All rights reserved.