## org.apache.mahout.math
Class NamedVector

    java.lang.Object
      org.apache.mahout.math.NamedVector

All Implemented Interfaces:
  Cloneable, Vector

    public class NamedVector

extends Object
implements Vector

Nested Class Summary

Nested classes/interfaces inherited from interface org.apache.mahout.math.Vector
`Vector.Element`

Constructor Summary
`NamedVector()`
`NamedVector(NamedVector other)`
`NamedVector(Vector delegate, String name)`

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
`NamedVector` `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
`boolean` `equals(Object other)` To not break transitivity with other `Vector`s, this does not compare name.
`double` `get(int index)` Return the value at the given index
`Vector` `getDelegate()`
`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.
`String` `getName()`
`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
`int` `hashCode()`
`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()`
`NamedVector` `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
`String` `toString()`
`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

Methods inherited from class java.lang.Object
`finalize, getClass, notify, notifyAll, wait, wait, wait`

Constructor Detail

### NamedVector

    public NamedVector()

### NamedVector

    public NamedVector(NamedVector other)

### NamedVector

    public NamedVector(Vector delegate,
                       String name)

Method Detail

### getName

    public String getName()

### getDelegate

    public Vector getDelegate()

### hashCode

    public int hashCode()

  Overrides:
    `hashCode` in class `Object`

### equals

    public boolean equals(Object other)

  To not break transitivity with other `Vector`s, this does not compare name.

  Overrides:
    `equals` in class `Object`

### clone

    public NamedVector clone()

  Description copied from interface: `Vector`
  Return a copy of the recipient

  Specified by:
    `clone` in interface `Vector`
  Overrides:
    `clone` in class `Object`
  Returns:
    a new Vector

### all

    public Iterable<Vector.Element> all()

  Specified by:
    `all` in interface `Vector`

### nonZeroes

    public Iterable<Vector.Element> nonZeroes()

  Specified by:
    `nonZeroes` in interface `Vector`

### asFormatString

    public String asFormatString()

  Specified by:
    `asFormatString` in interface `Vector`
  Returns:
    a formatted String suitable for output

### toString

    public String toString()

  Overrides:
    `toString` in class `Object`

### assign

    public Vector assign(double value)

  Description copied from interface: `Vector`
  Assign the value to all elements of the receiver

  Specified by:
    `assign` in interface `Vector`
  Parameters:
    `value` - a double value
  Returns:
    the modified receiver

### assign

    public Vector assign(double[] values)

  Description copied from interface: `Vector`
  Assign the values to the receiver

  Specified by:
    `assign` in interface `Vector`
  Parameters:
    `values` - a double[] of values
  Returns:
    the modified receiver

### assign

    public Vector assign(Vector other)

  Description copied from interface: `Vector`
  Assign the other vector values to the receiver

  Specified by:
    `assign` in interface `Vector`
  Parameters:
    `other` - a Vector
  Returns:
    the modified receiver

### assign

    public Vector assign(DoubleFunction function)

  Description copied from interface: `Vector`
  Apply the function to each element of the receiver

  Specified by:
    `assign` in interface `Vector`
  Parameters:
    `function` - a DoubleFunction to apply
  Returns:
    the modified receiver

### assign

    public Vector assign(Vector other,
                         DoubleDoubleFunction function)

  Description copied from interface: `Vector`
  Apply the function to each element of the receiver and the corresponding element of the other argument

  Specified by:
    `assign` in interface `Vector`
  Parameters:
    `other` - a Vector containing the second arguments to the function
    `function` - a DoubleDoubleFunction to apply
  Returns:
    the modified receiver

### assign

    public Vector assign(DoubleDoubleFunction f,
                         double y)

  Description copied from interface: `Vector`
  Apply the function to each element of the receiver, using the y value as the second argument of the DoubleDoubleFunction

  Specified by:
    `assign` in interface `Vector`
  Parameters:
    `f` - a DoubleDoubleFunction to be applied
    `y` - a double value to be argument to the function
  Returns:
    the modified receiver

### size

    public int size()

  Description copied from interface: `Vector`
  Return the cardinality of the recipient (the maximum number of values)

  Specified by:
    `size` in interface `Vector`
  Returns:
    an int

### isDense

    public boolean isDense()

  Specified by:
    `isDense` in interface `Vector`
  Returns:
    true iff this implementation should be considered dense -- that it explicitly represents every value

### isSequentialAccess

    public boolean isSequentialAccess()

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

### getElement

    public Vector.Element getElement(int index)

  Description copied from interface: `Vector`
  Return an object of Vector.Element representing an element of this Vector. Useful when designing new iterator types.

  Specified by:
    `getElement` in interface `Vector`
  Parameters:
    `index` - Index of the Vector.Element required
  Returns:
    The Vector.Element Object

### mergeUpdates

    public void mergeUpdates(OrderedIntDoubleMapping updates)

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

  Specified by:
    `mergeUpdates` in interface `Vector`
  Parameters:
    `updates` - an ordered mapping of indices to values to be merged in.

### divide

    public Vector divide(double x)

  Description copied from interface: `Vector`
  Return a new vector containing the values of the recipient divided by the argument

  Specified by:
    `divide` in interface `Vector`
  Parameters:
    `x` - a double value
  Returns:
    a new Vector

### dot

    public double dot(Vector x)

  Description copied from interface: `Vector`
  Return the dot product of the recipient and the argument

  Specified by:
    `dot` in interface `Vector`
  Parameters:
    `x` - a Vector
  Returns:
    a new Vector

### get

    public double get(int index)

  Description copied from interface: `Vector`
  Return the value at the given index

  Specified by:
    `get` in interface `Vector`
  Parameters:
    `index` - an int index
  Returns:
    the double at the index

### getQuick

    public double getQuick(int index)

  Description copied from interface: `Vector`
  Return the value at the given index, without checking bounds

  Specified by:
    `getQuick` in interface `Vector`
  Parameters:
    `index` - an int index
  Returns:
    the double at the index

### like

    public NamedVector like()

  Description copied from interface: `Vector`
  Return an empty vector of the same underlying class as the receiver

  Specified by:
    `like` in interface `Vector`
  Returns:
    a Vector

### minus

    public Vector minus(Vector x)

  Description copied from interface: `Vector`
  Return a new vector containing the element by element difference of the recipient and the argument

  Specified by:
    `minus` in interface `Vector`
  Parameters:
    `x` - a Vector
  Returns:
    a new Vector

### normalize

    public Vector normalize()

  Description copied from interface: `Vector`
  Return a new vector containing the normalized (L_2 norm) values of the recipient

  Specified by:
    `normalize` in interface `Vector`
  Returns:
    a new Vector

### normalize

    public Vector normalize(double power)

  Description copied from interface: `Vector`
  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

  Specified by:
    `normalize` in interface `Vector`
  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

    public Vector logNormalize()

  Description copied from interface: `Vector`
  Return a new vector containing the log(1 + entry)/ L_2 norm values of the recipient

  Specified by:
    `logNormalize` in interface `Vector`
  Returns:
    a new Vector

### logNormalize

    public Vector logNormalize(double power)

  Description copied from interface: `Vector`
  Return a new Vector with a normalized value calculated as log_power(1 + entry)/ L_power norm.

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

### norm

    public double norm(double power)

  Description copied from interface: `Vector`
  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.

  Specified by:
    `norm` in interface `Vector`
  Parameters:
    `power` - The power to use.
  See Also:
    `Vector.normalize(double)`

### maxValue

    public double maxValue()

  Specified by:
    `maxValue` in interface `Vector`
  Returns:
    The maximum value in the Vector

### maxValueIndex

    public int maxValueIndex()

  Specified by:
    `maxValueIndex` in interface `Vector`
  Returns:
    The index of the maximum value

### minValue

    public double minValue()

  Specified by:
    `minValue` in interface `Vector`
  Returns:
    The minimum value in the Vector

### minValueIndex

    public int minValueIndex()

  Specified by:
    `minValueIndex` in interface `Vector`
  Returns:
    The index of the minimum value

### plus

    public Vector plus(double x)

  Description copied from interface: `Vector`
  Return a new vector containing the sum of each value of the recipient and the argument

  Specified by:
    `plus` in interface `Vector`
  Parameters:
    `x` - a double
  Returns:
    a new Vector

### plus

    public Vector plus(Vector x)

  Description copied from interface: `Vector`
  Return a new vector containing the element by element sum of the recipient and the argument

  Specified by:
    `plus` in interface `Vector`
  Parameters:
    `x` - a Vector
  Returns:
    a new Vector

### set

    public void set(int index,
                    double value)

  Description copied from interface: `Vector`
  Set the value at the given index

  Specified by:
    `set` in interface `Vector`
  Parameters:
    `index` - an int index into the receiver
    `value` - a double value to set

### setQuick

    public void setQuick(int index,
                         double value)

  Description copied from interface: `Vector`
  Set the value at the given index, without checking bounds

  Specified by:
    `setQuick` in interface `Vector`
  Parameters:
    `index` - an int index into the receiver
    `value` - a double value to set

### incrementQuick

    public void incrementQuick(int index,
                               double increment)

  Description copied from interface: `Vector`
  Increment the value at the given index by the given value.

  Specified by:
    `incrementQuick` in interface `Vector`
  Parameters:
    `index` - an int index into the receiver
    `increment` - sets the value at the given index to value + increment;

### getNumNonZeroElements

    public int getNumNonZeroElements()

  Description copied from interface: `Vector`
  Return the number of non zero elements in the vector.

  Specified by:
    `getNumNonZeroElements` in interface `Vector`
  Returns:
    an int

### getNumNondefaultElements

    public int getNumNondefaultElements()

  Description copied from interface: `Vector`
  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.

  Specified by:
    `getNumNondefaultElements` in interface `Vector`
  Returns:
    an int

### times

    public Vector times(double x)

  Description copied from interface: `Vector`
  Return a new vector containing the product of each value of the recipient and the argument

  Specified by:
    `times` in interface `Vector`
  Parameters:
    `x` - a double argument
  Returns:
    a new Vector

### times

    public Vector times(Vector x)

  Description copied from interface: `Vector`
  Return a new vector containing the element-wise product of the recipient and the argument

  Specified by:
    `times` in interface `Vector`
  Parameters:
    `x` - a Vector argument
  Returns:
    a new Vector

### viewPart

    public Vector viewPart(int offset,
                           int length)

  Description copied from interface: `Vector`
  Return a new vector containing the subset of the recipient

  Specified by:
    `viewPart` in interface `Vector`
  Parameters:
    `offset` - an int offset into the receiver
    `length` - the cardinality of the desired result
  Returns:
    a new Vector

### zSum

    public double zSum()

  Description copied from interface: `Vector`
  Return the sum of all the elements of the receiver

  Specified by:
    `zSum` in interface `Vector`
  Returns:
    a double

### cross

    public Matrix cross(Vector other)

  Description copied from interface: `Vector`
  Return the cross product of the receiver and the other vector

  Specified by:
    `cross` in interface `Vector`
  Parameters:
    `other` - another Vector
  Returns:
    a Matrix

### aggregate

    public double aggregate(DoubleDoubleFunction aggregator,
                            DoubleFunction map)

  Description copied from interface: `Vector`
  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)).

  Specified by:
    `aggregate` in interface `Vector`
  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

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

  Description copied from interface: `Vector`

  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.

  Specified by:
    `aggregate` in interface `Vector`
  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

    public double getLengthSquared()

  Description copied from interface: `Vector`
  Return the sum of squares of all elements in the vector. Square root of this value is the length of the vector.

  Specified by:
    `getLengthSquared` in interface `Vector`

### getDistanceSquared

    public double getDistanceSquared(Vector v)

  Description copied from interface: `Vector`
  Get the square of the distance between this vector and the other vector.

  Specified by:
    `getDistanceSquared` in interface `Vector`

### getLookupCost

    public double getLookupCost()

  Description copied from interface: `Vector`
  Gets an estimate of the cost (in number of operations) it takes to lookup a random element in this vector.

  Specified by:
    `getLookupCost` in interface `Vector`

### getIteratorAdvanceCost

    public double getIteratorAdvanceCost()

  Description copied from interface: `Vector`
  Gets an estimate of the cost (in number of operations) it takes to advance an iterator through the nonzero elements of this vector.

  Specified by:
    `getIteratorAdvanceCost` in interface `Vector`

### isAddConstantTime

    public boolean isAddConstantTime()

  Description copied from interface: `Vector`
  Return true iff adding a new (nonzero) element takes constant time for this vector.

  Specified by:
    `isAddConstantTime` in interface `Vector`

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