Package | Description |
---|---|
org.apache.mahout.math |
Core base classes; Operations on primitive arrays such as sorting, partitioning and permuting.
|
org.apache.mahout.math.als | |
org.apache.mahout.math.decomposer | |
org.apache.mahout.math.decomposer.hebbian | |
org.apache.mahout.math.decomposer.lanczos | |
org.apache.mahout.math.function |
Core interfaces for functions, comparisons and procedures on objects and primitive data types.
|
org.apache.mahout.math.random | |
org.apache.mahout.math.solver | |
org.apache.mahout.math.ssvd |
Modifier and Type | Class and Description |
---|---|
protected static class |
AbstractMatrix.TransposeViewVector |
class |
AbstractVector
Implementations of generic capabilities like sum of elements and dot products
|
class |
Centroid
A centroid is a weighted vector.
|
class |
ConstantVector
Implements a vector with all the same values.
|
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.
|
class |
DenseVector
Implements vector as an array of doubles
|
class |
DiagonalMatrix.SingleElementVector
Special class to implement views of rows and columns of a diagonal matrix.
|
class |
MatrixSlice |
class |
MatrixVectorView
Provides a virtual vector that is really a row or column or diagonal of a matrix.
|
class |
NamedVector |
class |
PermutedVectorView
Provides a permuted view of a vector.
|
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
|
class |
WeightedVector
Decorates a vector with a floating point weight and an index.
|
Modifier and Type | Field and Description |
---|---|
protected Vector |
DelegatingVector.delegate |
protected Vector |
VectorView.vector |
Modifier and Type | Method and Description |
---|---|
Vector |
Matrix.aggregateColumns(VectorFunction f)
Collects the results of a function applied to each column of a matrix.
|
Vector |
AbstractMatrix.aggregateColumns(VectorFunction f)
Collects the results of a function applied to each column of a matrix.
|
Vector |
Matrix.aggregateRows(VectorFunction f)
Collects the results of a function applied to each row of a matrix.
|
Vector |
AbstractMatrix.aggregateRows(VectorFunction f)
Collects the results of a function applied to each row of a matrix.
|
Vector |
DenseVector.assign(DenseVector vector) |
Vector |
NamedVector.assign(double value) |
Vector |
Vector.assign(double value)
Assign the value to all elements of the receiver
|
Vector |
DenseVector.assign(double value) |
Vector |
DelegatingVector.assign(double value) |
Vector |
AbstractVector.assign(double value) |
Vector |
NamedVector.assign(double[] values) |
Vector |
Vector.assign(double[] values)
Assign the values to the receiver
|
Vector |
DelegatingVector.assign(double[] values) |
Vector |
AbstractVector.assign(double[] values) |
Vector |
NamedVector.assign(DoubleDoubleFunction f,
double y) |
Vector |
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 |
DelegatingVector.assign(DoubleDoubleFunction f,
double y) |
Vector |
AbstractVector.assign(DoubleDoubleFunction f,
double y) |
Vector |
NamedVector.assign(DoubleFunction function) |
Vector |
Vector.assign(DoubleFunction function)
Apply the function to each element of the receiver
|
Vector |
DelegatingVector.assign(DoubleFunction function) |
Vector |
AbstractVector.assign(DoubleFunction f) |
Vector |
NamedVector.assign(Vector other) |
Vector |
RandomAccessSparseVector.assign(Vector other) |
Vector |
Vector.assign(Vector other)
Assign the other vector values to the receiver
|
Vector |
DelegatingVector.assign(Vector other) |
Vector |
AbstractVector.assign(Vector other) |
Vector |
NamedVector.assign(Vector other,
DoubleDoubleFunction function) |
Vector |
Vector.assign(Vector other,
DoubleDoubleFunction function)
Apply the function to each element of the receiver and the corresponding element of the other argument
|
Vector |
DelegatingVector.assign(Vector other,
DoubleDoubleFunction function) |
Vector |
AbstractVector.assign(Vector other,
DoubleDoubleFunction function) |
abstract Vector |
VectorBinaryAssign.assign(Vector x,
Vector y,
DoubleDoubleFunction f)
Main method that applies f to x and y component-wise assigning the results to x.
|
Vector |
VectorBinaryAssign.AssignNonzerosIterateThisLookupThat.assign(Vector x,
Vector y,
DoubleDoubleFunction f) |
Vector |
VectorBinaryAssign.AssignNonzerosIterateThatLookupThisInplaceUpdates.assign(Vector x,
Vector y,
DoubleDoubleFunction f) |
Vector |
VectorBinaryAssign.AssignNonzerosIterateThatLookupThisMergeUpdates.assign(Vector x,
Vector y,
DoubleDoubleFunction f) |
Vector |
VectorBinaryAssign.AssignIterateIntersection.assign(Vector x,
Vector y,
DoubleDoubleFunction f) |
Vector |
VectorBinaryAssign.AssignIterateUnionSequentialMergeUpdates.assign(Vector x,
Vector y,
DoubleDoubleFunction f) |
Vector |
VectorBinaryAssign.AssignIterateUnionSequentialInplaceUpdates.assign(Vector x,
Vector y,
DoubleDoubleFunction f) |
Vector |
VectorBinaryAssign.AssignIterateUnionRandomMergeUpdates.assign(Vector x,
Vector y,
DoubleDoubleFunction f) |
Vector |
VectorBinaryAssign.AssignIterateUnionRandomInplaceUpdates.assign(Vector x,
Vector y,
DoubleDoubleFunction f) |
Vector |
VectorBinaryAssign.AssignAllIterateSequentialMergeUpdates.assign(Vector x,
Vector y,
DoubleDoubleFunction f) |
Vector |
VectorBinaryAssign.AssignAllIterateSequentialInplaceUpdates.assign(Vector x,
Vector y,
DoubleDoubleFunction f) |
Vector |
VectorBinaryAssign.AssignAllIterateThisLookupThatMergeUpdates.assign(Vector x,
Vector y,
DoubleDoubleFunction f) |
Vector |
VectorBinaryAssign.AssignAllIterateThisLookupThatInplaceUpdates.assign(Vector x,
Vector y,
DoubleDoubleFunction f) |
Vector |
VectorBinaryAssign.AssignAllIterateThatLookupThisMergeUpdates.assign(Vector x,
Vector y,
DoubleDoubleFunction f) |
Vector |
VectorBinaryAssign.AssignAllIterateThatLookupThisInplaceUpdates.assign(Vector x,
Vector y,
DoubleDoubleFunction f) |
Vector |
VectorBinaryAssign.AssignAllLoopMergeUpdates.assign(Vector x,
Vector y,
DoubleDoubleFunction f) |
Vector |
VectorBinaryAssign.AssignAllLoopInplaceUpdates.assign(Vector x,
Vector y,
DoubleDoubleFunction f) |
static Vector |
VectorBinaryAssign.assignBest(Vector x,
Vector y,
DoubleDoubleFunction f)
This is the method that should be used when assigning.
|
Vector |
VectorView.clone() |
Vector |
Vector.clone()
Return a copy of the recipient
|
Vector |
AbstractMatrix.TransposeViewVector.clone() |
Vector |
DelegatingVector.clone() |
Vector |
MatrixVectorView.clone() |
Vector |
AbstractVector.clone() |
protected Vector |
AbstractVector.createOptimizedCopy()
Copy the current vector in the most optimum fashion.
|
Vector |
NamedVector.divide(double x) |
Vector |
Vector.divide(double x)
Return a new vector containing the values of the recipient divided by the argument
|
Vector |
DelegatingVector.divide(double x) |
Vector |
AbstractVector.divide(double x) |
Vector |
NamedVector.getDelegate() |
Vector |
DelegatingVector.getVector() |
Vector |
Vector.like()
Return an empty vector of the same underlying class as the receiver
|
Vector |
PermutedVectorView.like()
Return an empty vector of the same underlying class as the receiver
|
Vector |
DiagonalMatrix.SingleElementVector.like() |
Vector |
ConstantVector.like()
Return an empty vector of the same underlying class as the receiver
|
Vector |
AbstractMatrix.TransposeViewVector.like() |
Vector |
DelegatingVector.like() |
Vector |
WeightedVector.like() |
Vector |
MatrixVectorView.like()
Return an empty vector of the same underlying class as the receiver
|
Vector |
NamedVector.like(int cardinality) |
Vector |
RandomAccessSparseVector.like(int cardinality) |
Vector |
VectorView.like(int cardinality) |
Vector |
Vector.like(int cardinality)
Return a new empty vector of the same underlying class as the receiver with given cardinality
|
Vector |
PermutedVectorView.like(int cardinality) |
Vector |
DenseVector.like(int cardinality) |
Vector |
DiagonalMatrix.SingleElementVector.like(int cardinality) |
Vector |
ConstantVector.like(int cardinality) |
Vector |
AbstractMatrix.TransposeViewVector.like(int cardinality) |
Vector |
DelegatingVector.like(int cardinality) |
Vector |
SequentialAccessSparseVector.like(int cardinality) |
Vector |
MatrixVectorView.like(int cardinality) |
Vector |
NamedVector.logNormalize() |
Vector |
Vector.logNormalize()
Return a new vector containing the log(1 + entry)/ L_2 norm values of the recipient
|
Vector |
DelegatingVector.logNormalize() |
Vector |
AbstractVector.logNormalize() |
Vector |
NamedVector.logNormalize(double power) |
Vector |
Vector.logNormalize(double power)
Return a new Vector with a normalized value calculated as log_power(1 + entry)/ L_power norm.
|
Vector |
DelegatingVector.logNormalize(double power) |
Vector |
AbstractVector.logNormalize(double power) |
Vector |
AbstractVector.logNormalize(double power,
double normLength) |
Vector |
NamedVector.minus(Vector x) |
Vector |
Vector.minus(Vector x)
Return a new vector containing the element by element difference of the recipient and the argument
|
Vector |
DelegatingVector.minus(Vector that) |
Vector |
AbstractVector.minus(Vector that) |
static Vector |
Algebra.mult(Matrix m,
Vector v) |
protected Vector |
AbstractMatrix.TransposeViewVector.newVector(int cardinality) |
Vector |
NamedVector.normalize() |
Vector |
Vector.normalize()
Return a new vector containing the normalized (L_2 norm) values of the recipient
|
Vector |
DelegatingVector.normalize() |
Vector |
AbstractVector.normalize() |
Vector |
NamedVector.normalize(double power) |
Vector |
Vector.normalize(double power)
Return a new Vector containing the normalized (L_power norm) values of the recipient.
|
Vector |
DelegatingVector.normalize(double power) |
Vector |
AbstractVector.normalize(double power) |
Vector |
NamedVector.plus(double x) |
Vector |
Vector.plus(double x)
Return a new vector containing the sum of each value of the recipient and the argument
|
Vector |
DelegatingVector.plus(double x) |
Vector |
AbstractVector.plus(double x) |
Vector |
NamedVector.plus(Vector x) |
Vector |
Vector.plus(Vector x)
Return a new vector containing the element by element sum of the recipient and the argument
|
Vector |
DelegatingVector.plus(Vector x) |
Vector |
AbstractVector.plus(Vector that) |
Vector |
NamedVector.times(double x) |
Vector |
Vector.times(double x)
Return a new vector containing the product of each value of the recipient and the argument
|
Vector |
DelegatingVector.times(double x) |
Vector |
AbstractVector.times(double x) |
Vector |
NamedVector.times(Vector x) |
Vector |
Vector.times(Vector x)
Return a new vector containing the element-wise product of the recipient and the argument
|
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 |
AbstractMatrix.times(Vector v) |
Vector |
DelegatingVector.times(Vector x) |
Vector |
AbstractVector.times(Vector that) |
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 |
TransposedMatrixView.viewColumn(int column) |
Vector |
Matrix.viewColumn(int column)
Return a reference to a column.
|
Vector |
PivotedMatrix.viewColumn(int column)
Return the column at the given index
|
Vector |
MatrixView.viewColumn(int column) |
Vector |
DiagonalMatrix.viewColumn(int row) |
Vector |
AbstractMatrix.viewColumn(int column)
Returns a view of a row.
|
Vector |
SparseColumnMatrix.viewColumn(int column)
Deprecated.
|
Vector |
Matrix.viewDiagonal()
Returns a reference to the diagonal of a matrix.
|
Vector |
DiagonalMatrix.viewDiagonal()
Provides a view of the diagonal of a matrix.
|
Vector |
AbstractMatrix.viewDiagonal()
Provides a view of the diagonal of a matrix.
|
Vector |
NamedVector.viewPart(int offset,
int length) |
Vector |
VectorView.viewPart(int offset,
int length) |
Vector |
Vector.viewPart(int offset,
int length)
Return a new vector containing the subset of the recipient
|
Vector |
DenseVector.viewPart(int offset,
int length) |
Vector |
DelegatingVector.viewPart(int offset,
int length) |
Vector |
AbstractVector.viewPart(int offset,
int length) |
Vector |
SparseMatrix.viewRow(int row) |
Vector |
TransposedMatrixView.viewRow(int row) |
Vector |
SparseRowMatrix.viewRow(int row) |
Vector |
Matrix.viewRow(int row)
Return a reference to a row.
|
Vector |
PivotedMatrix.viewRow(int row)
Return the row at the given index
|
Vector |
MatrixView.viewRow(int row) |
Vector |
DiagonalMatrix.viewRow(int row) |
Vector |
DenseMatrix.viewRow(int row) |
Vector |
FileBasedSparseBinaryMatrix.viewRow(int rowIndex)
Returns a view of a row.
|
Vector |
AbstractMatrix.viewRow(int row)
Returns a view of a row.
|
Modifier and Type | Method and Description |
---|---|
void |
DenseVector.addAll(Vector v) |
double |
NamedVector.aggregate(Vector other,
DoubleDoubleFunction aggregator,
DoubleDoubleFunction combiner) |
double |
Vector.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.
|
double |
DelegatingVector.aggregate(Vector other,
DoubleDoubleFunction aggregator,
DoubleDoubleFunction combiner) |
double |
AbstractVector.aggregate(Vector other,
DoubleDoubleFunction aggregator,
DoubleDoubleFunction combiner) |
abstract double |
VectorBinaryAggregate.aggregate(Vector x,
Vector y,
DoubleDoubleFunction fa,
DoubleDoubleFunction fc)
Main method that applies fc to x and y component-wise aggregating the results with fa.
|
double |
VectorBinaryAggregate.AggregateNonzerosIterateThisLookupThat.aggregate(Vector x,
Vector y,
DoubleDoubleFunction fa,
DoubleDoubleFunction fc) |
double |
VectorBinaryAggregate.AggregateNonzerosIterateThatLookupThis.aggregate(Vector x,
Vector y,
DoubleDoubleFunction fa,
DoubleDoubleFunction fc) |
double |
VectorBinaryAggregate.AggregateIterateIntersection.aggregate(Vector x,
Vector y,
DoubleDoubleFunction fa,
DoubleDoubleFunction fc) |
double |
VectorBinaryAggregate.AggregateIterateUnionSequential.aggregate(Vector x,
Vector y,
DoubleDoubleFunction fa,
DoubleDoubleFunction fc) |
double |
VectorBinaryAggregate.AggregateIterateUnionRandom.aggregate(Vector x,
Vector y,
DoubleDoubleFunction fa,
DoubleDoubleFunction fc) |
double |
VectorBinaryAggregate.AggregateAllIterateSequential.aggregate(Vector x,
Vector y,
DoubleDoubleFunction fa,
DoubleDoubleFunction fc) |
double |
VectorBinaryAggregate.AggregateAllIterateThisLookupThat.aggregate(Vector x,
Vector y,
DoubleDoubleFunction fa,
DoubleDoubleFunction fc) |
double |
VectorBinaryAggregate.AggregateAllIterateThatLookupThis.aggregate(Vector x,
Vector y,
DoubleDoubleFunction fa,
DoubleDoubleFunction fc) |
double |
VectorBinaryAggregate.AggregateAllLoop.aggregate(Vector x,
Vector y,
DoubleDoubleFunction fa,
DoubleDoubleFunction fc) |
static double |
VectorBinaryAggregate.aggregateBest(Vector x,
Vector y,
DoubleDoubleFunction fa,
DoubleDoubleFunction fc)
This is the method that should be used when aggregating.
|
Vector |
NamedVector.assign(Vector other) |
Vector |
RandomAccessSparseVector.assign(Vector other) |
Vector |
Vector.assign(Vector other)
Assign the other vector values to the receiver
|
Vector |
DelegatingVector.assign(Vector other) |
Vector |
AbstractVector.assign(Vector other) |
Vector |
NamedVector.assign(Vector other,
DoubleDoubleFunction function) |
Vector |
Vector.assign(Vector other,
DoubleDoubleFunction function)
Apply the function to each element of the receiver and the corresponding element of the other argument
|
Vector |
DelegatingVector.assign(Vector other,
DoubleDoubleFunction function) |
Vector |
AbstractVector.assign(Vector other,
DoubleDoubleFunction function) |
abstract Vector |
VectorBinaryAssign.assign(Vector x,
Vector y,
DoubleDoubleFunction f)
Main method that applies f to x and y component-wise assigning the results to x.
|
Vector |
VectorBinaryAssign.AssignNonzerosIterateThisLookupThat.assign(Vector x,
Vector y,
DoubleDoubleFunction f) |
Vector |
VectorBinaryAssign.AssignNonzerosIterateThatLookupThisInplaceUpdates.assign(Vector x,
Vector y,
DoubleDoubleFunction f) |
Vector |
VectorBinaryAssign.AssignNonzerosIterateThatLookupThisMergeUpdates.assign(Vector x,
Vector y,
DoubleDoubleFunction f) |
Vector |
VectorBinaryAssign.AssignIterateIntersection.assign(Vector x,
Vector y,
DoubleDoubleFunction f) |
Vector |
VectorBinaryAssign.AssignIterateUnionSequentialMergeUpdates.assign(Vector x,
Vector y,
DoubleDoubleFunction f) |
Vector |
VectorBinaryAssign.AssignIterateUnionSequentialInplaceUpdates.assign(Vector x,
Vector y,
DoubleDoubleFunction f) |
Vector |
VectorBinaryAssign.AssignIterateUnionRandomMergeUpdates.assign(Vector x,
Vector y,
DoubleDoubleFunction f) |
Vector |
VectorBinaryAssign.AssignIterateUnionRandomInplaceUpdates.assign(Vector x,
Vector y,
DoubleDoubleFunction f) |
Vector |
VectorBinaryAssign.AssignAllIterateSequentialMergeUpdates.assign(Vector x,
Vector y,
DoubleDoubleFunction f) |
Vector |
VectorBinaryAssign.AssignAllIterateSequentialInplaceUpdates.assign(Vector x,
Vector y,
DoubleDoubleFunction f) |
Vector |
VectorBinaryAssign.AssignAllIterateThisLookupThatMergeUpdates.assign(Vector x,
Vector y,
DoubleDoubleFunction f) |
Vector |
VectorBinaryAssign.AssignAllIterateThisLookupThatInplaceUpdates.assign(Vector x,
Vector y,
DoubleDoubleFunction f) |
Vector |
VectorBinaryAssign.AssignAllIterateThatLookupThisMergeUpdates.assign(Vector x,
Vector y,
DoubleDoubleFunction f) |
Vector |
VectorBinaryAssign.AssignAllIterateThatLookupThisInplaceUpdates.assign(Vector x,
Vector y,
DoubleDoubleFunction f) |
Vector |
VectorBinaryAssign.AssignAllLoopMergeUpdates.assign(Vector x,
Vector y,
DoubleDoubleFunction f) |
Vector |
VectorBinaryAssign.AssignAllLoopInplaceUpdates.assign(Vector x,
Vector y,
DoubleDoubleFunction f) |
static Vector |
VectorBinaryAssign.assignBest(Vector x,
Vector y,
DoubleDoubleFunction f)
This is the method that should be used when assigning.
|
Matrix |
SparseMatrix.assignColumn(int column,
Vector other) |
Matrix |
TransposedMatrixView.assignColumn(int column,
Vector other) |
Matrix |
SparseRowMatrix.assignColumn(int column,
Vector other) |
Matrix |
RandomTrinaryMatrix.assignColumn(int column,
Vector other) |
Matrix |
Matrix.assignColumn(int column,
Vector other)
Assign the other vector values to the column of the receiver
|
Matrix |
PivotedMatrix.assignColumn(int column,
Vector other)
Assign the other vector values to the column of the receiver
|
Matrix |
MatrixView.assignColumn(int column,
Vector other) |
Matrix |
UpperTriangular.assignColumn(int column,
Vector other) |
Matrix |
DiagonalMatrix.assignColumn(int column,
Vector other) |
Matrix |
DenseMatrix.assignColumn(int column,
Vector other) |
Matrix |
FileBasedSparseBinaryMatrix.assignColumn(int column,
Vector other)
Assign the other vector values to the column of the receiver
|
Matrix |
FileBasedMatrix.assignColumn(int column,
Vector other)
Assign the other vector values to the column of the receiver
|
Matrix |
SparseColumnMatrix.assignColumn(int column,
Vector other)
Deprecated.
|
Matrix |
SparseMatrix.assignRow(int row,
Vector other) |
Matrix |
TransposedMatrixView.assignRow(int row,
Vector other) |
Matrix |
SparseRowMatrix.assignRow(int row,
Vector other) |
Matrix |
RandomTrinaryMatrix.assignRow(int row,
Vector other) |
Matrix |
Matrix.assignRow(int row,
Vector other)
Assign the other vector values to the row of the receiver
|
Matrix |
PivotedMatrix.assignRow(int row,
Vector other)
Assign the other vector values to the row of the receiver
|
Matrix |
MatrixView.assignRow(int row,
Vector other) |
Matrix |
UpperTriangular.assignRow(int row,
Vector other) |
Matrix |
DiagonalMatrix.assignRow(int row,
Vector other)
Assign the other vector values to the row of the receiver
|
Matrix |
DenseMatrix.assignRow(int row,
Vector other) |
Matrix |
FileBasedSparseBinaryMatrix.assignRow(int row,
Vector other)
Assign the other vector values to the row of the receiver
|
Matrix |
FileBasedMatrix.assignRow(int row,
Vector other)
Assign the other vector values to the row of the receiver
|
Matrix |
SparseColumnMatrix.assignRow(int row,
Vector other)
Deprecated.
|
static Centroid |
Centroid.create(int key,
Vector initialValue) |
Matrix |
NamedVector.cross(Vector other) |
Matrix |
Vector.cross(Vector other)
Return the cross product of the receiver and the other vector
|
Matrix |
DelegatingVector.cross(Vector other) |
Matrix |
AbstractVector.cross(Vector other) |
double |
NamedVector.dot(Vector x) |
double |
Vector.dot(Vector x)
Return the dot product of the recipient and the argument
|
double |
DenseVector.dot(Vector x) |
double |
DelegatingVector.dot(Vector x) |
double |
AbstractVector.dot(Vector x) |
abstract double |
VectorBinaryAssign.estimateCost(Vector x,
Vector y,
DoubleDoubleFunction f)
Estimates the cost of using this algorithm to compute the assignment.
|
double |
VectorBinaryAssign.AssignNonzerosIterateThisLookupThat.estimateCost(Vector x,
Vector y,
DoubleDoubleFunction f) |
double |
VectorBinaryAssign.AssignNonzerosIterateThatLookupThisInplaceUpdates.estimateCost(Vector x,
Vector y,
DoubleDoubleFunction f) |
double |
VectorBinaryAssign.AssignNonzerosIterateThatLookupThisMergeUpdates.estimateCost(Vector x,
Vector y,
DoubleDoubleFunction f) |
double |
VectorBinaryAssign.AssignIterateIntersection.estimateCost(Vector x,
Vector y,
DoubleDoubleFunction f) |
double |
VectorBinaryAssign.AssignIterateUnionSequentialMergeUpdates.estimateCost(Vector x,
Vector y,
DoubleDoubleFunction f) |
double |
VectorBinaryAssign.AssignIterateUnionSequentialInplaceUpdates.estimateCost(Vector x,
Vector y,
DoubleDoubleFunction f) |
double |
VectorBinaryAssign.AssignIterateUnionRandomMergeUpdates.estimateCost(Vector x,
Vector y,
DoubleDoubleFunction f) |
double |
VectorBinaryAssign.AssignIterateUnionRandomInplaceUpdates.estimateCost(Vector x,
Vector y,
DoubleDoubleFunction f) |
double |
VectorBinaryAssign.AssignAllIterateSequentialMergeUpdates.estimateCost(Vector x,
Vector y,
DoubleDoubleFunction f) |
double |
VectorBinaryAssign.AssignAllIterateSequentialInplaceUpdates.estimateCost(Vector x,
Vector y,
DoubleDoubleFunction f) |
double |
VectorBinaryAssign.AssignAllIterateThisLookupThatMergeUpdates.estimateCost(Vector x,
Vector y,
DoubleDoubleFunction f) |
double |
VectorBinaryAssign.AssignAllIterateThisLookupThatInplaceUpdates.estimateCost(Vector x,
Vector y,
DoubleDoubleFunction f) |
double |
VectorBinaryAssign.AssignAllIterateThatLookupThisMergeUpdates.estimateCost(Vector x,
Vector y,
DoubleDoubleFunction f) |
double |
VectorBinaryAssign.AssignAllIterateThatLookupThisInplaceUpdates.estimateCost(Vector x,
Vector y,
DoubleDoubleFunction f) |
double |
VectorBinaryAssign.AssignAllLoopMergeUpdates.estimateCost(Vector x,
Vector y,
DoubleDoubleFunction f) |
double |
VectorBinaryAssign.AssignAllLoopInplaceUpdates.estimateCost(Vector x,
Vector y,
DoubleDoubleFunction f) |
abstract double |
VectorBinaryAggregate.estimateCost(Vector x,
Vector y,
DoubleDoubleFunction fa,
DoubleDoubleFunction fc)
Estimates the cost of using this algorithm to compute the aggregation.
|
double |
VectorBinaryAggregate.AggregateNonzerosIterateThisLookupThat.estimateCost(Vector x,
Vector y,
DoubleDoubleFunction fa,
DoubleDoubleFunction fc) |
double |
VectorBinaryAggregate.AggregateNonzerosIterateThatLookupThis.estimateCost(Vector x,
Vector y,
DoubleDoubleFunction fa,
DoubleDoubleFunction fc) |
double |
VectorBinaryAggregate.AggregateIterateIntersection.estimateCost(Vector x,
Vector y,
DoubleDoubleFunction fa,
DoubleDoubleFunction fc) |
double |
VectorBinaryAggregate.AggregateIterateUnionSequential.estimateCost(Vector x,
Vector y,
DoubleDoubleFunction fa,
DoubleDoubleFunction fc) |
double |
VectorBinaryAggregate.AggregateIterateUnionRandom.estimateCost(Vector x,
Vector y,
DoubleDoubleFunction fa,
DoubleDoubleFunction fc) |
double |
VectorBinaryAggregate.AggregateAllIterateSequential.estimateCost(Vector x,
Vector y,
DoubleDoubleFunction fa,
DoubleDoubleFunction fc) |
double |
VectorBinaryAggregate.AggregateAllIterateThisLookupThat.estimateCost(Vector x,
Vector y,
DoubleDoubleFunction fa,
DoubleDoubleFunction fc) |
double |
VectorBinaryAggregate.AggregateAllIterateThatLookupThis.estimateCost(Vector x,
Vector y,
DoubleDoubleFunction fa,
DoubleDoubleFunction fc) |
double |
VectorBinaryAggregate.AggregateAllLoop.estimateCost(Vector x,
Vector y,
DoubleDoubleFunction fa,
DoubleDoubleFunction fc) |
static VectorBinaryAssign |
VectorBinaryAssign.getBestOperation(Vector x,
Vector y,
DoubleDoubleFunction f)
The best operation is the least expensive valid one.
|
static VectorBinaryAggregate |
VectorBinaryAggregate.getBestOperation(Vector x,
Vector y,
DoubleDoubleFunction fa,
DoubleDoubleFunction fc)
The best operation is the least expensive valid one.
|
double |
NamedVector.getDistanceSquared(Vector v) |
double |
VectorView.getDistanceSquared(Vector v) |
double |
Vector.getDistanceSquared(Vector v)
Get the square of the distance between this vector and the other vector.
|
double |
DelegatingVector.getDistanceSquared(Vector v) |
double |
AbstractVector.getDistanceSquared(Vector that) |
abstract boolean |
VectorBinaryAssign.isValid(Vector x,
Vector y,
DoubleDoubleFunction f)
Returns true iff we can use this algorithm to apply f to x and y component-wise and assign the result to x.
|
boolean |
VectorBinaryAssign.AssignNonzerosIterateThisLookupThat.isValid(Vector x,
Vector y,
DoubleDoubleFunction f) |
boolean |
VectorBinaryAssign.AssignNonzerosIterateThatLookupThisInplaceUpdates.isValid(Vector x,
Vector y,
DoubleDoubleFunction f) |
boolean |
VectorBinaryAssign.AssignNonzerosIterateThatLookupThisMergeUpdates.isValid(Vector x,
Vector y,
DoubleDoubleFunction f) |
boolean |
VectorBinaryAssign.AssignIterateIntersection.isValid(Vector x,
Vector y,
DoubleDoubleFunction f) |
boolean |
VectorBinaryAssign.AssignIterateUnionSequentialMergeUpdates.isValid(Vector x,
Vector y,
DoubleDoubleFunction f) |
boolean |
VectorBinaryAssign.AssignIterateUnionSequentialInplaceUpdates.isValid(Vector x,
Vector y,
DoubleDoubleFunction f) |
boolean |
VectorBinaryAssign.AssignIterateUnionRandomMergeUpdates.isValid(Vector x,
Vector y,
DoubleDoubleFunction f) |
boolean |
VectorBinaryAssign.AssignIterateUnionRandomInplaceUpdates.isValid(Vector x,
Vector y,
DoubleDoubleFunction f) |
boolean |
VectorBinaryAssign.AssignAllIterateSequentialMergeUpdates.isValid(Vector x,
Vector y,
DoubleDoubleFunction f) |
boolean |
VectorBinaryAssign.AssignAllIterateSequentialInplaceUpdates.isValid(Vector x,
Vector y,
DoubleDoubleFunction f) |
boolean |
VectorBinaryAssign.AssignAllIterateThisLookupThatMergeUpdates.isValid(Vector x,
Vector y,
DoubleDoubleFunction f) |
boolean |
VectorBinaryAssign.AssignAllIterateThisLookupThatInplaceUpdates.isValid(Vector x,
Vector y,
DoubleDoubleFunction f) |
boolean |
VectorBinaryAssign.AssignAllIterateThatLookupThisMergeUpdates.isValid(Vector x,
Vector y,
DoubleDoubleFunction f) |
boolean |
VectorBinaryAssign.AssignAllIterateThatLookupThisInplaceUpdates.isValid(Vector x,
Vector y,
DoubleDoubleFunction f) |
boolean |
VectorBinaryAssign.AssignAllLoopMergeUpdates.isValid(Vector x,
Vector y,
DoubleDoubleFunction f) |
boolean |
VectorBinaryAssign.AssignAllLoopInplaceUpdates.isValid(Vector x,
Vector y,
DoubleDoubleFunction f) |
abstract boolean |
VectorBinaryAggregate.isValid(Vector x,
Vector y,
DoubleDoubleFunction fa,
DoubleDoubleFunction fc)
Returns true iff we can use this algorithm to apply fc to x and y component-wise and aggregate the result using fa.
|
boolean |
VectorBinaryAggregate.AggregateNonzerosIterateThisLookupThat.isValid(Vector x,
Vector y,
DoubleDoubleFunction fa,
DoubleDoubleFunction fc) |
boolean |
VectorBinaryAggregate.AggregateNonzerosIterateThatLookupThis.isValid(Vector x,
Vector y,
DoubleDoubleFunction fa,
DoubleDoubleFunction fc) |
boolean |
VectorBinaryAggregate.AggregateIterateIntersection.isValid(Vector x,
Vector y,
DoubleDoubleFunction fa,
DoubleDoubleFunction fc) |
boolean |
VectorBinaryAggregate.AggregateIterateUnionSequential.isValid(Vector x,
Vector y,
DoubleDoubleFunction fa,
DoubleDoubleFunction fc) |
boolean |
VectorBinaryAggregate.AggregateIterateUnionRandom.isValid(Vector x,
Vector y,
DoubleDoubleFunction fa,
DoubleDoubleFunction fc) |
boolean |
VectorBinaryAggregate.AggregateAllIterateSequential.isValid(Vector x,
Vector y,
DoubleDoubleFunction fa,
DoubleDoubleFunction fc) |
boolean |
VectorBinaryAggregate.AggregateAllIterateThisLookupThat.isValid(Vector x,
Vector y,
DoubleDoubleFunction fa,
DoubleDoubleFunction fc) |
boolean |
VectorBinaryAggregate.AggregateAllIterateThatLookupThis.isValid(Vector x,
Vector y,
DoubleDoubleFunction fa,
DoubleDoubleFunction fc) |
boolean |
VectorBinaryAggregate.AggregateAllLoop.isValid(Vector x,
Vector y,
DoubleDoubleFunction fa,
DoubleDoubleFunction fc) |
Vector |
NamedVector.minus(Vector x) |
Vector |
Vector.minus(Vector x)
Return a new vector containing the element by element difference of the recipient and the argument
|
Vector |
DelegatingVector.minus(Vector that) |
Vector |
AbstractVector.minus(Vector that) |
static Vector |
Algebra.mult(Matrix m,
Vector v) |
Vector |
NamedVector.plus(Vector x) |
Vector |
Vector.plus(Vector x)
Return a new vector containing the element by element sum of the recipient and the argument
|
Vector |
DelegatingVector.plus(Vector x) |
Vector |
AbstractVector.plus(Vector that) |
static WeightedVector |
WeightedVector.project(Vector v,
Vector projection) |
static WeightedVector |
WeightedVector.project(Vector v,
Vector projection,
int index) |
Vector |
NamedVector.times(Vector x) |
Vector |
Vector.times(Vector x)
Return a new vector containing the element-wise product of the recipient and the argument
|
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 |
AbstractMatrix.times(Vector v) |
Vector |
DelegatingVector.times(Vector x) |
Vector |
AbstractVector.times(Vector that) |
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) |
void |
Centroid.update(Vector v) |
void |
Centroid.update(Vector other,
double wy) |
Constructor and Description |
---|
Centroid(int key,
Vector initialValue) |
Centroid(int key,
Vector initialValue,
double weight) |
DelegatingVector(Vector v) |
DenseSymmetricMatrix(Vector data) |
DenseVector(Vector vector)
Copy-constructor (for use in turning a sparse vector into a dense one, for example)
|
DiagonalMatrix(Vector values) |
MatrixSlice(Vector v,
int index) |
NamedVector(Vector delegate,
String name) |
PermutedVectorView(Vector vector,
int[] pivot) |
PermutedVectorView(Vector vector,
int[] pivot,
int[] unpivot) |
RandomAccessSparseVector(Vector other) |
SequentialAccessSparseVector(Vector other) |
SparseColumnMatrix(int rows,
int columns,
Vector[] columnVectors)
Deprecated.
Construct a matrix of the given cardinality with the given data columns
|
SparseColumnMatrix(int rows,
int columns,
Vector[] columnVectors,
boolean shallow)
Deprecated.
|
SparseRowMatrix(int rows,
int columns,
Vector[] rowVectors)
Construct a sparse matrix starting with the provided row vectors.
|
SparseRowMatrix(int rows,
int columns,
Vector[] vectors,
boolean shallowCopy,
boolean randomAccess) |
UpperTriangular(Vector data) |
VectorView(Vector vector,
int offset,
int cardinality) |
WeightedVector(Vector v,
double weight,
int index) |
WeightedVector(Vector v,
Vector projection,
int index) |
Constructor and Description |
---|
SparseMatrix(int rows,
int columns,
Map<Integer,Vector> rowVectors)
Construct a matrix of the given cardinality with the given row map
|
SparseMatrix(int rows,
int columns,
Map<Integer,Vector> rowVectors,
boolean shallow) |
Modifier and Type | Method and Description |
---|---|
static Vector |
AlternatingLeastSquaresSolver.solve(Iterable<Vector> featureVectors,
Vector ratingVector,
double lambda,
int numFeatures) |
Vector |
ImplicitFeedbackAlternatingLeastSquaresSolver.solve(Vector ratings) |
Modifier and Type | Method and Description |
---|---|
static Vector |
AlternatingLeastSquaresSolver.solve(Iterable<Vector> featureVectors,
Vector ratingVector,
double lambda,
int numFeatures) |
Vector |
ImplicitFeedbackAlternatingLeastSquaresSolver.solve(Vector ratings) |
Modifier and Type | Method and Description |
---|---|
Matrix |
ImplicitFeedbackAlternatingLeastSquaresSolver.getYtransposeY(OpenIntObjectHashMap<Vector> Y) |
static Vector |
AlternatingLeastSquaresSolver.solve(Iterable<Vector> featureVectors,
Vector ratingVector,
double lambda,
int numFeatures) |
Constructor and Description |
---|
ImplicitFeedbackAlternatingLeastSquaresSolver(int numFeatures,
double lambda,
double alpha,
OpenIntObjectHashMap<Vector> Y,
int numTrainingThreads) |
Modifier and Type | Method and Description |
---|---|
protected EigenStatus |
AsyncEigenVerifier.innerVerify(VectorIterable corpus,
Vector vector) |
EigenStatus |
SimpleEigenVerifier.verify(VectorIterable corpus,
Vector vector) |
EigenStatus |
AsyncEigenVerifier.verify(VectorIterable corpus,
Vector vector) |
EigenStatus |
SingularVectorVerifier.verify(VectorIterable eigenMatrix,
Vector vector) |
Modifier and Type | Method and Description |
---|---|
Vector |
TrainingState.currentTrainingProjection() |
Vector |
TrainingState.getHelperVector() |
Vector |
TrainingState.mostRecentEigen() |
Modifier and Type | Method and Description |
---|---|
protected boolean |
HebbianSolver.hasNotConverged(Vector currentPseudoEigen,
Matrix corpus,
TrainingState state)
Uses the
SingularVectorVerifier to check for convergence |
void |
TrainingState.setHelperVector(Vector helperVector) |
void |
EigenUpdater.update(Vector pseudoEigen,
Vector trainingVector,
TrainingState currentState) |
void |
HebbianUpdater.update(Vector pseudoEigen,
Vector trainingVector,
TrainingState currentState) |
protected EigenStatus |
HebbianSolver.verify(Matrix corpus,
Vector currentPseudoEigen) |
Modifier and Type | Field and Description |
---|---|
protected Map<Integer,Vector> |
LanczosState.basis
Deprecated.
|
protected Map<Integer,Vector> |
LanczosState.singularVectors
Deprecated.
|
Modifier and Type | Method and Description |
---|---|
Vector |
LanczosState.getBasisVector(int i)
Deprecated.
|
Vector |
LanczosState.getRightSingularVector(int i)
Deprecated.
|
Modifier and Type | Method and Description |
---|---|
protected static double |
LanczosSolver.calculateScaleFactor(Vector nextVector)
Deprecated.
|
protected static void |
LanczosSolver.orthoganalizeAgainstAllButLast(Vector nextVector,
LanczosState state)
Deprecated.
|
void |
LanczosState.setBasisVector(int i,
Vector basisVector)
Deprecated.
|
void |
LanczosState.setRightSingularVector(int i,
Vector vector)
Deprecated.
|
Constructor and Description |
---|
LanczosState(VectorIterable corpus,
int desiredRank,
Vector initialVector)
Deprecated.
|
Modifier and Type | Method and Description |
---|---|
double |
VectorFunction.apply(Vector f) |
Modifier and Type | Method and Description |
---|---|
Vector |
MultiNormal.getScale() |
Vector |
MultiNormal.sample() |
Constructor and Description |
---|
MultiNormal(double radius,
Vector mean) |
MultiNormal(Matrix a,
Vector mean)
Constructs a sampler with non-trivial scale matrix and mean.
|
MultiNormal(Vector diagonal)
Constructs a sampler with diagonal scale matrix.
|
MultiNormal(Vector diagonal,
Vector mean)
Constructs a sampler with diagonal scale matrix and (potentially)
non-zero mean.
|
Modifier and Type | Method and Description |
---|---|
Vector |
EigenDecomposition.getImagEigenvalues()
Return the imaginary parts of the eigenvalues
|
Vector |
EigenDecomposition.getRealEigenvalues()
Return the real parts of the eigenvalues
|
Vector |
JacobiConditioner.precondition(Vector v) |
Vector |
Preconditioner.precondition(Vector v)
Preconditions the specified vector.
|
Vector |
LSMR.solve(Matrix A,
Vector b) |
Vector |
ConjugateGradientSolver.solve(VectorIterable a,
Vector b)
Solves the system Ax = b with default termination criteria.
|
Vector |
ConjugateGradientSolver.solve(VectorIterable a,
Vector b,
Preconditioner precond)
Solves the system Ax = b with default termination criteria using the specified preconditioner.
|
Vector |
ConjugateGradientSolver.solve(VectorIterable a,
Vector b,
Preconditioner preconditioner,
int maxIterations,
double maxError)
Solves the system Ax = b, where A is a linear operator and b is a vector.
|
Modifier and Type | Method and Description |
---|---|
Vector |
JacobiConditioner.precondition(Vector v) |
Vector |
Preconditioner.precondition(Vector v)
Preconditions the specified vector.
|
Vector |
LSMR.solve(Matrix A,
Vector b) |
Vector |
ConjugateGradientSolver.solve(VectorIterable a,
Vector b)
Solves the system Ax = b with default termination criteria.
|
Vector |
ConjugateGradientSolver.solve(VectorIterable a,
Vector b,
Preconditioner precond)
Solves the system Ax = b with default termination criteria using the specified preconditioner.
|
Vector |
ConjugateGradientSolver.solve(VectorIterable a,
Vector b,
Preconditioner preconditioner,
int maxIterations,
double maxError)
Solves the system Ax = b, where A is a linear operator and b is a vector.
|
Modifier and Type | Method and Description |
---|---|
Vector |
SequentialBigSvd.getSingularValues() |
Copyright © 2008–2017 The Apache Software Foundation. All rights reserved.