|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use Vector | |
---|---|
org.apache.mahout.math | Core base classes; Operations on primitive arrays such as sorting, partitioning and permuting. |
org.apache.mahout.math.decomposer | |
org.apache.mahout.math.decomposer.hebbian | |
org.apache.mahout.math.decomposer.lanczos |
Uses of Vector in org.apache.mahout.math |
---|
Classes in org.apache.mahout.math that implement Vector | |
---|---|
protected class |
AbstractMatrix.TransposeViewVector
|
class |
AbstractVector
Implementations of generic capabilities like sum of elements and dot products |
class |
DenseVector
Implements vector as an array of doubles |
class |
RandomAccessSparseVector
Implements vector that only stores non-zero doubles |
class |
SequentialAccessSparseVector
Implements vector that only stores non-zero doubles as a pair of parallel arrays (OrderedIntDoubleMapping), one int[], one double[]. |
class |
VectorView
Implements subset view of a Vector |
Methods in org.apache.mahout.math that return Vector | |
---|---|
Vector |
Vector.assign(BinaryFunction f,
double y)
Apply the function to each element of the receiver, using the y value as the second argument of the BinaryFunction |
Vector |
AbstractVector.assign(BinaryFunction f,
double y)
|
Vector |
Vector.assign(double value)
Assign the value to all elements of the receiver |
Vector |
DenseVector.assign(double value)
|
Vector |
AbstractVector.assign(double value)
|
Vector |
Vector.assign(double[] values)
Assign the values to the receiver |
Vector |
AbstractVector.assign(double[] values)
|
Vector |
Vector.assign(UnaryFunction function)
Apply the function to each element of the receiver |
Vector |
AbstractVector.assign(UnaryFunction function)
|
Vector |
Vector.assign(Vector other)
Assign the other matrix values to the receiver |
Vector |
RandomAccessSparseVector.assign(Vector other)
|
Vector |
AbstractVector.assign(Vector other)
|
Vector |
Vector.assign(Vector other,
BinaryFunction function)
Apply the function to each element of the receiver and the corresponding element of the other argument |
Vector |
DenseVector.assign(Vector other,
BinaryFunction function)
|
Vector |
AbstractVector.assign(Vector other,
BinaryFunction function)
|
Vector |
VectorView.clone()
|
Vector |
Vector.clone()
Return a copy of the recipient |
Vector |
AbstractVector.clone()
|
Vector |
AbstractMatrix.TransposeViewVector.clone()
|
static Vector |
AbstractVector.decodeVector(java.lang.String formattedString)
Decodes a point from its string representation. |
Vector |
JsonVectorAdapter.deserialize(com.google.gson.JsonElement json,
java.lang.reflect.Type typeOfT,
com.google.gson.JsonDeserializationContext context)
|
Vector |
Vector.divide(double x)
Return a new matrix containing the values of the recipient divided by the argument |
Vector |
AbstractVector.divide(double x)
|
Vector |
SparseRowMatrix.getColumn(int column)
|
Vector |
SparseMatrix.getColumn(int column)
|
Vector |
SparseColumnMatrix.getColumn(int column)
|
Vector |
MatrixView.getColumn(int column)
|
Vector |
Matrix.getColumn(int column)
Return the column at the given index |
Vector |
DenseMatrix.getColumn(int column)
|
Vector |
SparseRowMatrix.getRow(int row)
|
Vector |
SparseMatrix.getRow(int row)
|
Vector |
SparseColumnMatrix.getRow(int row)
|
Vector |
MatrixView.getRow(int row)
|
Vector |
Matrix.getRow(int row)
Return the row at the given index |
Vector |
DenseMatrix.getRow(int row)
|
Vector |
VectorView.like()
|
Vector |
Vector.like()
Return an empty matrix of the same underlying class as the receiver |
Vector |
AbstractMatrix.TransposeViewVector.like()
|
Vector |
VectorView.like(int cardinality)
|
Vector |
Vector.like(int cardinality)
Return an empty matrix of the same underlying class as the receiver and of the given cardinality |
Vector |
SequentialAccessSparseVector.like(int newCardinality)
|
Vector |
RandomAccessSparseVector.like(int newCardinality)
|
Vector |
DenseVector.like(int cardinality)
|
Vector |
AbstractMatrix.TransposeViewVector.like(int cardinality)
|
Vector |
Vector.minus(Vector x)
Return a new matrix containing the element by element difference of the recipient and the argument |
Vector |
AbstractVector.minus(Vector x)
|
protected Vector |
AbstractMatrix.TransposeViewVector.newVector(int cardinality)
|
Vector |
Vector.normalize()
Return a new matrix containing the normalized (L_2 norm) values of the recipient |
Vector |
AbstractVector.normalize()
|
Vector |
Vector.normalize(double power)
Return a new Vector containing the normalized (L_power norm) values of the recipient. |
Vector |
AbstractVector.normalize(double power)
|
Vector |
Vector.plus(double x)
Return a new matrix containing the sum of each value of the recipient and the argument |
Vector |
AbstractVector.plus(double x)
|
Vector |
Vector.plus(Vector x)
Return a new matrix containing the element by element sum of the recipient and the argument |
Vector |
AbstractVector.plus(Vector x)
|
protected Vector |
SparseColumnMatrix.slice(int index)
Iterate over columns. |
protected Vector |
AbstractMatrix.slice(int index)
Abstracted out for iterating over either rows or columns (default is rows). |
Vector |
Vector.times(double x)
Return a new matrix containing the product of each value of the recipient and the argument |
Vector |
AbstractVector.times(double x)
|
Vector |
VectorIterable.times(Vector v)
Return a new vector with cardinality equal to getNumRows() of this matrix which is the matrix product of the recipient and the argument |
Vector |
Vector.times(Vector x)
Return a new matrix containing the element-wise product of the recipient and the argument |
Vector |
AbstractVector.times(Vector x)
|
Vector |
AbstractMatrix.times(Vector v)
|
Vector |
VectorIterable.timesSquared(Vector v)
Convenience method for producing this.transpose().times(this.times(v)), which can be implemented with only one pass over the matrix, without making the transpose() call (which can be expensive if the matrix is sparse) |
Vector |
AbstractMatrix.timesSquared(Vector v)
|
Vector |
MatrixSlice.vector()
|
Vector |
VectorView.viewPart(int offset,
int length)
|
Vector |
Vector.viewPart(int offset,
int length)
Return a new matrix containing the subset of the recipient |
Vector |
DenseVector.viewPart(int offset,
int length)
|
Vector |
AbstractVector.viewPart(int offset,
int length)
|
Methods in org.apache.mahout.math with parameters of type Vector | |
---|---|
void |
DenseVector.addAll(Vector v)
|
void |
VectorView.addTo(Vector v)
|
void |
Vector.addTo(Vector v)
Add the elements to the other vector and results are stored in that vector. |
void |
RandomAccessSparseVector.addTo(Vector v)
|
void |
DenseVector.addTo(Vector v)
|
void |
AbstractVector.addTo(Vector v)
|
double |
Vector.aggregate(Vector other,
BinaryFunction aggregator,
BinaryFunction 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. |
double |
AbstractVector.aggregate(Vector other,
BinaryFunction aggregator,
BinaryFunction combiner)
|
Vector |
Vector.assign(Vector other)
Assign the other matrix values to the receiver |
Vector |
RandomAccessSparseVector.assign(Vector other)
|
Vector |
AbstractVector.assign(Vector other)
|
Vector |
Vector.assign(Vector other,
BinaryFunction function)
Apply the function to each element of the receiver and the corresponding element of the other argument |
Vector |
DenseVector.assign(Vector other,
BinaryFunction function)
|
Vector |
AbstractVector.assign(Vector other,
BinaryFunction function)
|
Matrix |
SparseRowMatrix.assignColumn(int column,
Vector other)
|
Matrix |
SparseMatrix.assignColumn(int column,
Vector other)
|
Matrix |
SparseColumnMatrix.assignColumn(int column,
Vector other)
|
Matrix |
MatrixView.assignColumn(int column,
Vector other)
|
Matrix |
Matrix.assignColumn(int column,
Vector other)
Assign the other vector values to the column of the receiver |
Matrix |
DenseMatrix.assignColumn(int column,
Vector other)
|
Matrix |
SparseRowMatrix.assignRow(int row,
Vector other)
|
Matrix |
SparseMatrix.assignRow(int row,
Vector other)
|
Matrix |
SparseColumnMatrix.assignRow(int row,
Vector other)
|
Matrix |
MatrixView.assignRow(int row,
Vector other)
|
Matrix |
Matrix.assignRow(int row,
Vector other)
Assign the other vector values to the row of the receiver |
Matrix |
DenseMatrix.assignRow(int row,
Vector other)
|
Matrix |
Vector.cross(Vector other)
Return the cross product of the receiver and the other vector |
Matrix |
AbstractVector.cross(Vector other)
|
double |
VectorView.dot(Vector x)
|
double |
Vector.dot(Vector x)
Return the dot product of the recipient and the argument |
double |
SequentialAccessSparseVector.dot(Vector x)
|
double |
RandomAccessSparseVector.dot(Vector x)
|
double |
DenseVector.dot(Vector x)
|
double |
AbstractVector.dot(Vector x)
|
static boolean |
AbstractVector.equivalent(Vector left,
Vector right)
Compare whether two Vector implementations have the same elements, regardless of the implementation and name. |
double |
VectorView.getDistanceSquared(Vector v)
|
double |
Vector.getDistanceSquared(Vector v)
Get the square of the distance between this vector and the other vector. |
double |
AbstractVector.getDistanceSquared(Vector v)
|
Vector |
Vector.minus(Vector x)
Return a new matrix containing the element by element difference of the recipient and the argument |
Vector |
AbstractVector.minus(Vector x)
|
Vector |
Vector.plus(Vector x)
Return a new matrix containing the element by element sum of the recipient and the argument |
Vector |
AbstractVector.plus(Vector x)
|
com.google.gson.JsonElement |
JsonVectorAdapter.serialize(Vector src,
java.lang.reflect.Type typeOfSrc,
com.google.gson.JsonSerializationContext context)
|
static boolean |
AbstractVector.strictEquivalence(Vector left,
Vector right)
Compare whether two Vector implementations are the same, including the underlying implementation. |
Vector |
VectorIterable.times(Vector v)
Return a new vector with cardinality equal to getNumRows() of this matrix which is the matrix product of the recipient and the argument |
Vector |
Vector.times(Vector x)
Return a new matrix containing the element-wise product of the recipient and the argument |
Vector |
AbstractVector.times(Vector x)
|
Vector |
AbstractMatrix.times(Vector v)
|
Vector |
VectorIterable.timesSquared(Vector v)
Convenience method for producing this.transpose().times(this.times(v)), which can be implemented with only one pass over the matrix, without making the transpose() call (which can be expensive if the matrix is sparse) |
Vector |
AbstractMatrix.timesSquared(Vector v)
|
Constructors in org.apache.mahout.math with parameters of type Vector | |
---|---|
DenseVector(Vector vector)
Copy-constructor (for use in turning a sparse vector into a dense one, for example) |
|
MatrixSlice(Vector v,
int index)
|
|
RandomAccessSparseVector(Vector other)
|
|
SequentialAccessSparseVector(Vector other)
|
|
SparseRowMatrix(int[] cardinality,
Vector[] rows)
Construct a matrix of the given cardinality with the given rows |
|
SparseRowMatrix(int[] cardinality,
Vector[] rows,
boolean shallowCopy,
boolean randomAccess)
|
|
VectorView(Vector vector,
int offset,
int cardinality)
|
Uses of Vector in org.apache.mahout.math.decomposer |
---|
Methods in org.apache.mahout.math.decomposer with parameters of type Vector | |
---|---|
protected EigenStatus |
AsyncEigenVerifier.innerVerify(VectorIterable corpus,
Vector vector)
|
EigenStatus |
SingularVectorVerifier.verify(VectorIterable eigenMatrix,
Vector vector)
|
EigenStatus |
SimpleEigenVerifier.verify(VectorIterable corpus,
Vector vector)
|
EigenStatus |
AsyncEigenVerifier.verify(VectorIterable corpus,
Vector vector)
|
Uses of Vector in org.apache.mahout.math.decomposer.hebbian |
---|
Methods in org.apache.mahout.math.decomposer.hebbian that return Vector | |
---|---|
Vector |
TrainingState.currentTrainingProjection()
|
Vector |
TrainingState.getHelperVector()
|
Vector |
TrainingState.mostRecentEigen()
|
Methods in org.apache.mahout.math.decomposer.hebbian with parameters of type Vector | |
---|---|
protected boolean |
HebbianSolver.hasNotConverged(Vector currentPseudoEigen,
Matrix corpus,
TrainingState state)
Uses the SingularVectorVerifier to check for convergence |
void |
TrainingState.setHelperVector(Vector helperVector)
|
void |
HebbianUpdater.update(Vector pseudoEigen,
Vector trainingVector,
TrainingState currentState)
|
void |
EigenUpdater.update(Vector pseudoEigen,
Vector trainingVector,
TrainingState currentState)
|
protected EigenStatus |
HebbianSolver.verify(Matrix corpus,
Vector currentPseudoEigen)
|
Uses of Vector in org.apache.mahout.math.decomposer.lanczos |
---|
Methods in org.apache.mahout.math.decomposer.lanczos that return Vector | |
---|---|
protected Vector |
LanczosSolver.getInitialVector(VectorIterable corpus)
|
Methods in org.apache.mahout.math.decomposer.lanczos with parameters of type Vector | |
---|---|
protected void |
LanczosSolver.calculateScaleFactor(Vector nextVector)
|
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |