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.