|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||
java.lang.Objectorg.apache.mahout.math.DelegatingVector
public class DelegatingVector
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 Class Summary |
|---|
| Nested classes/interfaces inherited from interface org.apache.mahout.math.Vector |
|---|
Vector.Element |
| Field Summary | |
|---|---|
protected Vector |
delegate
|
| Constructor Summary | |
|---|---|
protected |
DelegatingVector()
|
|
DelegatingVector(Vector v)
|
| 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 |
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. |
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 |
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. |
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 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 |
| Methods inherited from class java.lang.Object |
|---|
finalize, getClass, notify, notifyAll, wait, wait, wait |
| Field Detail |
|---|
protected Vector delegate
| Constructor Detail |
|---|
public DelegatingVector(Vector v)
protected DelegatingVector()
| Method Detail |
|---|
public Vector getVector()
public double aggregate(DoubleDoubleFunction aggregator,
DoubleFunction map)
Vector
aggregate in interface Vectoraggregator - 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)
VectorGeneralized 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 Vectorother - a vector to aggregate in combination withaggregator - function we're aggregating with; facombiner - function we're combining with; fc
public Vector viewPart(int offset,
int length)
Vector
viewPart in interface Vectoroffset - an int offset into the receiverlength - the cardinality of the desired result
public Vector clone()
Vector
clone in interface Vectorclone in class Objectpublic Iterable<Vector.Element> all()
all in interface Vectorpublic Iterable<Vector.Element> nonZeroes()
nonZeroes in interface Vectorpublic Vector divide(double x)
Vector
divide in interface Vectorx - a double value
public double dot(Vector x)
Vector
dot in interface Vectorx - a Vector
public double get(int index)
Vector
get in interface Vectorindex - an int index
public Vector.Element getElement(int index)
Vector
getElement in interface Vectorindex - Index of the Vector.Element required
public void mergeUpdates(OrderedIntDoubleMapping updates)
mergeUpdates in interface Vectorupdates - an ordered mapping of indices to values to be merged in.public Vector minus(Vector that)
Vector
minus in interface Vectorthat - a Vector
public Vector normalize()
Vector
normalize in interface Vectorpublic Vector normalize(double power)
VectorDouble.POSITIVE_INFINITY (max element). Again, see the Wikipedia page for more info
normalize in interface Vectorpower - 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 Vectorpublic Vector logNormalize(double power)
Vector
logNormalize in interface Vectorpower - The power to use. Must be > 1. Cannot be Double.POSITIVE_INFINITY.
public double norm(double power)
VectorDouble.POSITIVE_INFINITY (max element). Again, see the Wikipedia page for
more info.
norm in interface Vectorpower - The power to use.Vector.normalize(double)public double getLengthSquared()
Vector
getLengthSquared in interface Vectorpublic void invalidateCachedLength()
public double getDistanceSquared(Vector v)
Vector
getDistanceSquared in interface Vectorpublic double getLookupCost()
Vector
getLookupCost in interface Vectorpublic double getIteratorAdvanceCost()
Vector
getIteratorAdvanceCost in interface Vectorpublic boolean isAddConstantTime()
Vector
isAddConstantTime in interface Vectorpublic double maxValue()
maxValue in interface Vectorpublic int maxValueIndex()
maxValueIndex in interface Vectorpublic double minValue()
minValue in interface Vectorpublic int minValueIndex()
minValueIndex in interface Vectorpublic Vector plus(double x)
Vector
plus in interface Vectorx - a double
public Vector plus(Vector x)
Vector
plus in interface Vectorx - a Vector
public void set(int index,
double value)
Vector
set in interface Vectorindex - an int index into the receivervalue - a double value to setpublic Vector times(double x)
Vector
times in interface Vectorx - a double argument
public Vector times(Vector x)
Vector
times in interface Vectorx - a Vector argument
public double zSum()
Vector
zSum in interface Vectorpublic Vector assign(double value)
Vector
assign in interface Vectorvalue - a double value
public Vector assign(double[] values)
Vector
assign in interface Vectorvalues - a double[] of values
public Vector assign(Vector other)
Vector
assign in interface Vectorother - a Vector
public Vector assign(DoubleDoubleFunction f,
double y)
Vector
assign in interface Vectorf - a DoubleDoubleFunction to be appliedy - a double value to be argument to the function
public Vector assign(DoubleFunction function)
Vector
assign in interface Vectorfunction - a DoubleFunction to apply
public Vector assign(Vector other,
DoubleDoubleFunction function)
Vector
assign in interface Vectorother - a Vector containing the second arguments to the functionfunction - a DoubleDoubleFunction to apply
public Matrix cross(Vector other)
Vector
cross in interface Vectorother - another Vector
public int size()
Vector
size in interface Vectorpublic String asFormatString()
asFormatString in interface Vectorpublic int hashCode()
hashCode in class Objectpublic boolean equals(Object o)
equals in class Objectpublic String toString()
toString in class Objectpublic boolean isDense()
isDense in interface Vectorpublic boolean isSequentialAccess()
isSequentialAccess in interface VectorVector.all() and Vector.nonZeroes() ()} return elements
in ascending order by index.public double getQuick(int index)
Vector
getQuick in interface Vectorindex - an int index
public Vector like()
Vector
like in interface Vector
public void setQuick(int index,
double value)
Vector
setQuick in interface Vectorindex - an int index into the receivervalue - a double value to set
public void incrementQuick(int index,
double increment)
Vector
incrementQuick in interface Vectorindex - an int index into the receiverincrement - sets the value at the given index to value + increment;public int getNumNondefaultElements()
Vector
getNumNondefaultElements in interface Vectorpublic int getNumNonZeroElements()
Vector
getNumNonZeroElements in interface Vector
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||