Package | Description |
---|---|
org.apache.mahout.math |
Core base classes; Operations on primitive arrays such as sorting, partitioning and permuting.
|
org.apache.mahout.math.function |
Core interfaces for functions, comparisons and procedures on objects and primitive data types.
|
Modifier and Type | Method and Description |
---|---|
double |
NamedVector.aggregate(DoubleDoubleFunction aggregator,
DoubleFunction map) |
double |
Matrix.aggregate(DoubleDoubleFunction combiner,
DoubleFunction mapper)
Collects the results of a function applied to each element of a matrix and then
aggregated.
|
double |
Vector.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 |
AbstractMatrix.aggregate(DoubleDoubleFunction combiner,
DoubleFunction mapper)
Collects the results of a function applied to each element of a matrix and then aggregated.
|
double |
DelegatingVector.aggregate(DoubleDoubleFunction aggregator,
DoubleFunction map) |
double |
AbstractVector.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 |
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(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) |
Matrix |
SparseMatrix.assign(Matrix other,
DoubleDoubleFunction function) |
Matrix |
TransposedMatrixView.assign(Matrix other,
DoubleDoubleFunction function) |
Matrix |
Matrix.assign(Matrix other,
DoubleDoubleFunction function)
Apply the function to each element of the receiver and the corresponding element of the other argument
|
Matrix |
AbstractMatrix.assign(Matrix other,
DoubleDoubleFunction function) |
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.
|
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.
|
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) |
Modifier and Type | Class and Description |
---|---|
class |
PlusMult
Only for performance tuning of compute intensive linear algebraic computations.
|
class |
TimesFunction |
Modifier and Type | Field and Description |
---|---|
static DoubleDoubleFunction |
Functions.ATAN2
Function that returns Math.atan2(a,b).
|
static DoubleDoubleFunction |
Functions.COMPARE
Function that returns a < b ? -1 : a > b ? 1 : 0.
|
static DoubleDoubleFunction |
Functions.DIV
Function that returns a / b.
|
static DoubleDoubleFunction |
Functions.EQUALS
Function that returns a == b ? 1 : 0.
|
static DoubleDoubleFunction |
Functions.GREATER
Function that returns a > b ? 1 : 0.
|
static DoubleDoubleFunction |
Functions.IEEE_REMAINDER
Function that returns Math.IEEEremainder(a,b).
|
static DoubleDoubleFunction |
Functions.LESS
Function that returns a < b ? 1 : 0.
|
static DoubleDoubleFunction |
Functions.LG
Function that returns Math.log(a) / Math.log(b).
|
static DoubleDoubleFunction |
Functions.MAX
Function that returns Math.max(a,b).
|
static DoubleDoubleFunction |
Functions.MAX_ABS |
static DoubleDoubleFunction |
Functions.MIN
Function that returns Math.min(a,b).
|
static DoubleDoubleFunction |
Functions.MINUS
Function that returns a - b.
|
static DoubleDoubleFunction |
Functions.MINUS_ABS |
static DoubleDoubleFunction |
Functions.MINUS_SQUARED |
static DoubleDoubleFunction |
Functions.MOD
Function that returns a % b.
|
static DoubleDoubleFunction |
Functions.MULT
Function that returns a * b.
|
static DoubleDoubleFunction |
Functions.MULT_RIGHT_PLUS1 |
static DoubleDoubleFunction |
Functions.MULT_SQUARE_LEFT |
static DoubleDoubleFunction |
Functions.PLUS
Function that returns a + b.
|
static DoubleDoubleFunction |
Functions.PLUS_ABS
Function that returns Math.abs(a) + Math.abs(b).
|
static DoubleDoubleFunction |
Functions.POW
Function that returns Math.pow(a,b).
|
static DoubleDoubleFunction |
Functions.SECOND |
static DoubleDoubleFunction |
Functions.SECOND_LEFT_ZERO
This function is specifically designed to be used when assigning a vector to one that is all zeros (created
by like()).
|
Modifier and Type | Method and Description |
---|---|
static DoubleDoubleFunction |
Functions.chain(DoubleDoubleFunction f,
DoubleFunction g,
DoubleFunction h)
Constructs the function f( g(a), h(b) ).
|
static DoubleDoubleFunction |
Functions.chain(DoubleFunction g,
DoubleDoubleFunction h)
Constructs the function g( h(a,b) ).
|
static DoubleDoubleFunction |
Functions.minusAbsPow(double exponent) |
static DoubleDoubleFunction |
Functions.minusMult(double constant)
Constructs a function that returns a - b*constant.
|
static DoubleDoubleFunction |
Functions.plusMult(double constant)
Constructs a function that returns a + b*constant.
|
static DoubleDoubleFunction |
Functions.reweigh(double wx,
double wy) |
static DoubleDoubleFunction |
Functions.swapArgs(DoubleDoubleFunction function)
Constructs a function that returns function.apply(b,a), i.e.
|
Modifier and Type | Method and Description |
---|---|
static DoubleFunction |
Functions.bindArg1(DoubleDoubleFunction function,
double c)
Constructs a unary function from a binary function with the first operand (argument) fixed to the given constant
c.
|
static DoubleFunction |
Functions.bindArg2(DoubleDoubleFunction function,
double c)
Constructs a unary function from a binary function with the second operand (argument) fixed to the given constant
c.
|
static DoubleDoubleFunction |
Functions.chain(DoubleDoubleFunction f,
DoubleFunction g,
DoubleFunction h)
Constructs the function f( g(a), h(b) ).
|
static DoubleDoubleFunction |
Functions.chain(DoubleFunction g,
DoubleDoubleFunction h)
Constructs the function g( h(a,b) ).
|
static DoubleDoubleFunction |
Functions.swapArgs(DoubleDoubleFunction function)
Constructs a function that returns function.apply(b,a), i.e.
|
Copyright © 2008–2017 The Apache Software Foundation. All rights reserved.