org.apache.mahout.math

## Class DelegatingVector

• All Implemented Interfaces:
Cloneable, Vector
Direct Known Subclasses:
MatrixSlice, WeightedVector

public class DelegatingVector
extends Object
implements Vector
A delegating vector provides an easy way to decorate vectors with weights or id's and such while keeping all of the Vector functionality. This vector implements LengthCachingVector because almost all delegates cache the length and the cost of false positives is very low.

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

Vector.Element
• ### Field Summary

Fields
Modifier and Type Field and Description
protected Vector delegate
• ### 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
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
boolean equals(Object o)
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.
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
Vector getVector()
int hashCode()
void incrementQuick(int index, double increment)
Increment the value at the given index by the given value.
void invalidateCachedLength()
Invalidates the length cache.
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()
Merge a set of (index, value) pairs into the vector.
Vector minus(Vector that)
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
• ### Field Detail

• #### delegate

protected Vector delegate
• ### Constructor Detail

• #### DelegatingVector

public DelegatingVector(Vector v)
• #### DelegatingVector

protected DelegatingVector()
• ### Method Detail

• #### getVector

public Vector getVector()
• #### 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
• #### 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
• #### clone

public Vector 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
• #### 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
• #### 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

Merge a set of (index, value) pairs into the vector.
Specified by:
Parameters:
updates - an ordered mapping of indices to values to be merged in.
• #### minus

public Vector minus(Vector that)
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:
that - 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.
Vector.normalize(double)
• #### 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
Returns:
The sum of the squares of all elements in the vector.
• #### invalidateCachedLength

public void invalidateCachedLength()
Invalidates the length cache. This should be called by all mutators of the 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

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:

Description copied from interface: Vector
Return true iff adding a new (nonzero) element takes constant time for this vector.
Specified by:
• #### 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
• #### 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
• #### 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
• #### 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:
• #### 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:
• #### 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:
• #### 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:
• #### 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:
• #### 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:
• #### 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
• #### 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
• #### asFormatString

public String asFormatString()
Specified by:
asFormatString in interface Vector
Returns:
a formatted String suitable for output
• #### hashCode

public int hashCode()
Overrides:
hashCode in class Object
• #### equals

public boolean equals(Object o)
Overrides:
equals in class Object
• #### 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.
• #### 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 Vector 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
• #### 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;
• #### 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
• #### 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