|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use DoubleDoubleFunction | |
---|---|
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. |
Uses of DoubleDoubleFunction in org.apache.mahout.math |
---|
Methods in org.apache.mahout.math with parameters of type DoubleDoubleFunction | |
---|---|
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 |
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 |
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 |
AbstractMatrix.aggregate(DoubleDoubleFunction combiner,
DoubleFunction mapper)
Collects the results of a function applied to each element of a matrix and then aggregated. |
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 |
NamedVector.aggregate(Vector other,
DoubleDoubleFunction aggregator,
DoubleDoubleFunction 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 |
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 |
NamedVector.assign(DoubleDoubleFunction f,
double y)
|
Vector |
DelegatingVector.assign(DoubleDoubleFunction f,
double y)
|
Vector |
AbstractVector.assign(DoubleDoubleFunction f,
double y)
|
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 |
Vector.assign(Vector other,
DoubleDoubleFunction function)
Apply the function to each element of the receiver and the corresponding element of the other argument |
Vector |
NamedVector.assign(Vector other,
DoubleDoubleFunction function)
|
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)
|
Uses of DoubleDoubleFunction in org.apache.mahout.math.function |
---|
Subclasses of DoubleDoubleFunction in org.apache.mahout.math.function | |
---|---|
class |
PlusMult
Only for performance tuning of compute intensive linear algebraic computations. |
class |
TimesFunction
|
Fields in org.apache.mahout.math.function declared as DoubleDoubleFunction | |
---|---|
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()). |
Methods in org.apache.mahout.math.function that return DoubleDoubleFunction | |
---|---|
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. |
Methods in org.apache.mahout.math.function with parameters of type DoubleDoubleFunction | |
---|---|
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. |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |