## Uses of Class
org.apache.mahout.math.function.DoubleDoubleFunction

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.

Copyright © 2008–2014 The Apache Software Foundation. All rights reserved.