NamedVector (Mahout Math 0.11.0 API)

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

Constructors
Constructor and Description

NamedVector()

NamedVector(NamedVector other)

NamedVector(Vector delegate, String name)

Constructors
Constructor and Description
`NamedVector()`
`NamedVector(NamedVector other)`
`NamedVector(Vector delegate, String name)`

Method Summary

Methods
Modifier and Type	Method and Description
`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`	`like(int cardinality)` Return a new empty vector of the same underlying class as the receiver with given cardinality
`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 Vectors, 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
  - like
```
public Vector like(int cardinality)
```
    Description copied from interface: Vector
    
    Return a new empty vector of the same underlying class as the receiver with given cardinality
    
    Specified by:
    
    like in interface Vector
    
    Returns:
  - 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

Class NamedVector

Nested Class Summary

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

NamedVector

NamedVector

NamedVector

Method Detail

getName

getDelegate

hashCode

equals

clone

all

nonZeroes

asFormatString

toString

assign

assign

assign

assign

assign

assign

size

isDense

isSequentialAccess

getElement

mergeUpdates

divide

dot

get

getQuick

like

like

minus

normalize

normalize

logNormalize

logNormalize

norm

maxValue

maxValueIndex

minValue

minValueIndex

plus

plus

set

setQuick

incrementQuick

getNumNonZeroElements

getNumNondefaultElements

times

times

viewPart

zSum

cross

aggregate

aggregate

getLengthSquared

getDistanceSquared

getLookupCost

getIteratorAdvanceCost

isAddConstantTime