|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectorg.apache.mahout.math.AbstractVector
public abstract class AbstractVector
Implementations of generic capabilities like sum of elements and dot products
Nested Class Summary | |
---|---|
protected class |
AbstractVector.LocalElement
|
Nested classes/interfaces inherited from interface org.apache.mahout.math.Vector |
---|
Vector.Element |
Field Summary | |
---|---|
protected double |
lengthSquared
|
Constructor Summary | |
---|---|
protected |
AbstractVector(int size)
|
Method Summary | |
---|---|
double |
aggregate(DoubleDoubleFunction aggregator,
DoubleFunction map)
Aggregates a vector by applying a mapping function fm(x) to every component and aggregating the results with an aggregating function fa(x, y). |
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 f)
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 |
protected Vector |
createOptimizedCopy()
Copy the current vector in the most optimum fashion. |
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 |
protected double |
dotSelf()
|
boolean |
equals(Object o)
Determines whether this Vector represents the same logical vector as another
object. |
double |
get(int index)
Return the value at the given index |
double |
getDistanceSquared(Vector that)
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 |
getLengthSquared()
Return the sum of squares of all elements in the vector. |
int |
getNumNonZeroElements()
Return the number of non zero elements in the vector. |
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. |
protected abstract Iterator<Vector.Element> |
iterateNonZero()
Iterates over all non-zero elements. |
protected abstract Iterator<Vector.Element> |
iterator()
Iterates over all elements * NOTE: Implementations may choose to reuse the Element returned for performance reasons, so if you need a copy of it, you should call getElement(int) for the given index |
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. |
Vector |
logNormalize(double power,
double normLength)
|
protected abstract Matrix |
matrixLike(int rows,
int columns)
Subclasses must override to return an appropriately sparse or dense result |
double |
maxValue()
|
int |
maxValueIndex()
|
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 that)
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 |
int |
size()
Return the cardinality of the recipient (the maximum number of values) |
String |
sparseVectorToString()
toString() implementation for sparse vectors via nonZeroes() method |
Vector |
times(double x)
Return a new vector containing the product of each value of the recipient and the argument |
Vector |
times(Vector that)
Return a new vector containing the element-wise product of the recipient and the argument |
String |
toString()
|
String |
toString(String[] dictionary)
|
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 |
Methods inherited from interface org.apache.mahout.math.Vector |
---|
getIteratorAdvanceCost, getLookupCost, getNumNondefaultElements, getQuick, isAddConstantTime, isDense, isSequentialAccess, like, mergeUpdates, setQuick |
Field Detail |
---|
protected double lengthSquared
Constructor Detail |
---|
protected AbstractVector(int size)
Method Detail |
---|
public Iterable<Vector.Element> all()
all
in interface Vector
public Iterable<Vector.Element> nonZeroes()
nonZeroes
in interface Vector
protected abstract Iterator<Vector.Element> iterator()
getElement(int)
for the given index
Iterator
over all elementsprotected abstract Iterator<Vector.Element> iterateNonZero()
getElement(int)
for the given index
Iterator
over all non-zero elementspublic double aggregate(DoubleDoubleFunction aggregator, DoubleFunction map)
aggregate
in interface Vector
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
public double aggregate(Vector other, DoubleDoubleFunction aggregator, DoubleDoubleFunction combiner)
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.
aggregate
in interface Vector
other
- a vector to aggregate in combination withaggregator
- function we're aggregating with; facombiner
- function we're combining with; fc
protected abstract Matrix matrixLike(int rows, int columns)
rows
- the row cardinalitycolumns
- the column cardinality
public Vector viewPart(int offset, int length)
Vector
viewPart
in interface Vector
offset
- an int offset into the receiverlength
- the cardinality of the desired result
public Vector clone()
Vector
clone
in interface Vector
clone
in class Object
public Vector divide(double x)
Vector
divide
in interface Vector
x
- a double value
public double dot(Vector x)
Vector
dot
in interface Vector
x
- a Vector
protected double dotSelf()
public double get(int index)
Vector
get
in interface Vector
index
- an int index
public Vector.Element getElement(int index)
Vector
getElement
in interface Vector
index
- Index of the Vector.Element required
public Vector normalize()
Vector
normalize
in interface Vector
public Vector normalize(double power)
Vector
Double.POSITIVE_INFINITY
(max element). Again, see the Wikipedia page for more info
normalize
in interface Vector
power
- The power to use. Must be >= 0. May also be Double.POSITIVE_INFINITY
. See the Wikipedia link
for more on this.
public Vector logNormalize()
Vector
logNormalize
in interface Vector
public Vector logNormalize(double power)
Vector
logNormalize
in interface Vector
power
- The power to use. Must be > 1. Cannot be Double.POSITIVE_INFINITY
.
public Vector logNormalize(double power, double normLength)
public double norm(double power)
Vector
Double.POSITIVE_INFINITY
(max element). Again, see the Wikipedia page for
more info.
norm
in interface Vector
power
- The power to use.Vector.normalize(double)
public double getLengthSquared()
Vector
getLengthSquared
in interface Vector
public void invalidateCachedLength()
public double getDistanceSquared(Vector that)
Vector
getDistanceSquared
in interface Vector
public double maxValue()
maxValue
in interface Vector
public int maxValueIndex()
maxValueIndex
in interface Vector
public double minValue()
minValue
in interface Vector
public int minValueIndex()
minValueIndex
in interface Vector
public Vector plus(double x)
Vector
plus
in interface Vector
x
- a double
public Vector plus(Vector that)
Vector
plus
in interface Vector
that
- a Vector
public Vector minus(Vector that)
Vector
minus
in interface Vector
that
- a Vector
public void set(int index, double value)
Vector
set
in interface Vector
index
- an int index into the receivervalue
- a double value to setpublic void incrementQuick(int index, double increment)
Vector
incrementQuick
in interface Vector
index
- an int index into the receiverincrement
- sets the value at the given index to value + increment;public Vector times(double x)
Vector
times
in interface Vector
x
- a double argument
protected Vector createOptimizedCopy()
public Vector times(Vector that)
Vector
times
in interface Vector
that
- a Vector argument
public double zSum()
Vector
zSum
in interface Vector
public int getNumNonZeroElements()
Vector
getNumNonZeroElements
in interface Vector
public Vector assign(double value)
Vector
assign
in interface Vector
value
- a double value
public Vector assign(double[] values)
Vector
assign
in interface Vector
values
- a double[] of values
public Vector assign(Vector other)
Vector
assign
in interface Vector
other
- a Vector
public Vector assign(DoubleDoubleFunction f, double y)
Vector
assign
in interface Vector
f
- a DoubleDoubleFunction to be appliedy
- a double value to be argument to the function
public Vector assign(DoubleFunction f)
Vector
assign
in interface Vector
f
- a DoubleFunction to apply
public Vector assign(Vector other, DoubleDoubleFunction function)
Vector
assign
in interface Vector
other
- a Vector containing the second arguments to the functionfunction
- a DoubleDoubleFunction to apply
public Matrix cross(Vector other)
Vector
cross
in interface Vector
other
- another Vector
public final int size()
Vector
size
in interface Vector
public String asFormatString()
asFormatString
in interface Vector
public int hashCode()
hashCode
in class Object
public boolean equals(Object o)
Vector
represents the same logical vector as another
object. Two Vector
s are equal (regardless of implementation) if the value at
each index is the same, and the cardinalities are the same.
equals
in class Object
public String toString()
toString
in class Object
public String toString(String[] dictionary)
public String sparseVectorToString()
nonZeroes()
method
|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |