Uses of Interface
org.apache.mahout.math.Vector

Packages that use Vector
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   
 

Uses of Vector in org.apache.mahout.math
 

Classes in org.apache.mahout.math that implement Vector
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 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.
 

Fields in org.apache.mahout.math declared as Vector
protected  Vector DelegatingVector.delegate
           
 

Methods in org.apache.mahout.math that return Vector
 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 Vector.assign(double value)
          Assign the value to all elements of the receiver
 Vector NamedVector.assign(double value)
           
 Vector DenseVector.assign(double value)
           
 Vector DelegatingVector.assign(double value)
           
 Vector AbstractVector.assign(double value)
           
 Vector Vector.assign(double[] values)
          Assign the values to the receiver
 Vector NamedVector.assign(double[] values)
           
 Vector DelegatingVector.assign(double[] values)
           
 Vector AbstractVector.assign(double[] values)
           
 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)
           
 Vector Vector.assign(DoubleFunction function)
          Apply the function to each element of the receiver
 Vector NamedVector.assign(DoubleFunction function)
           
 Vector DelegatingVector.assign(DoubleFunction function)
           
 Vector AbstractVector.assign(DoubleFunction f)
           
 Vector Vector.assign(Vector other)
          Assign the other vector values to the receiver
 Vector RandomAccessSparseVector.assign(Vector other)
           
 Vector NamedVector.assign(Vector other)
           
 Vector DelegatingVector.assign(Vector other)
           
 Vector AbstractVector.assign(Vector other)
           
 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.
 Vector VectorView.clone()
           
 Vector Vector.clone()
          Return a copy of the recipient
 Vector MatrixVectorView.clone()
           
 Vector DelegatingVector.clone()
           
 Vector AbstractVector.clone()
           
 Vector AbstractMatrix.TransposeViewVector.clone()
           
protected  Vector AbstractVector.createOptimizedCopy()
          Copy the current vector in the most optimum fashion.
 Vector Vector.divide(double x)
          Return a new vector containing the values of the recipient divided by the argument
 Vector NamedVector.divide(double x)
           
 Vector DelegatingVector.divide(double x)
           
 Vector AbstractVector.divide(double x)
           
 Vector NamedVector.getDelegate()
           
 Vector DelegatingVector.getVector()
           
 Vector WeightedVector.like()
           
 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 MatrixVectorView.like()
          Return an empty vector of the same underlying class as the receiver
 Vector DelegatingVector.like()
           
 Vector ConstantVector.like()
          Return an empty vector of the same underlying class as the receiver
 Vector AbstractMatrix.TransposeViewVector.like()
           
 Vector AbstractMatrix.TransposeViewVector.like(int cardinality)
           
 Vector Vector.logNormalize()
          Return a new vector containing the log(1 + entry)/ L_2 norm values of the recipient
 Vector NamedVector.logNormalize()
           
 Vector DelegatingVector.logNormalize()
           
 Vector AbstractVector.logNormalize()
           
 Vector Vector.logNormalize(double power)
          Return a new Vector with a normalized value calculated as log_power(1 + entry)/ L_power norm.
 Vector NamedVector.logNormalize(double power)
           
 Vector DelegatingVector.logNormalize(double power)
           
 Vector AbstractVector.logNormalize(double power)
           
 Vector AbstractVector.logNormalize(double power, double normLength)
           
 Vector Vector.minus(Vector x)
          Return a new vector containing the element by element difference of the recipient and the argument
 Vector NamedVector.minus(Vector x)
           
 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 Vector.normalize()
          Return a new vector containing the normalized (L_2 norm) values of the recipient
 Vector NamedVector.normalize()
           
 Vector DelegatingVector.normalize()
           
 Vector AbstractVector.normalize()
           
 Vector Vector.normalize(double power)
          Return a new Vector containing the normalized (L_power norm) values of the recipient.
 Vector NamedVector.normalize(double power)
           
 Vector DelegatingVector.normalize(double power)
           
 Vector AbstractVector.normalize(double power)
           
 Vector Vector.plus(double x)
          Return a new vector containing the sum of each value of the recipient and the argument
 Vector NamedVector.plus(double x)
           
 Vector DelegatingVector.plus(double x)
           
 Vector AbstractVector.plus(double x)
           
 Vector Vector.plus(Vector x)
          Return a new vector containing the element by element sum of the recipient and the argument
 Vector NamedVector.plus(Vector x)
           
 Vector DelegatingVector.plus(Vector x)
           
 Vector AbstractVector.plus(Vector that)
           
 Vector Vector.times(double x)
          Return a new vector containing the product of each value of the recipient and the argument
 Vector NamedVector.times(double x)
           
 Vector DelegatingVector.times(double x)
           
 Vector AbstractVector.times(double x)
           
 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 Vector.times(Vector x)
          Return a new vector containing the element-wise product of the recipient and the argument
 Vector NamedVector.times(Vector x)
           
 Vector DelegatingVector.times(Vector x)
           
 Vector AbstractVector.times(Vector that)
           
 Vector AbstractMatrix.times(Vector v)
           
 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 SparseColumnMatrix.viewColumn(int column)
           
 Vector PivotedMatrix.viewColumn(int column)
          Return the column at the given index
 Vector MatrixView.viewColumn(int column)
           
 Vector Matrix.viewColumn(int column)
          Return a reference to a column.
 Vector AbstractMatrix.viewColumn(int column)
          Returns a view of a row.
 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 VectorView.viewPart(int offset, int length)
           
 Vector Vector.viewPart(int offset, int length)
          Return a new vector containing the subset of the recipient
 Vector NamedVector.viewPart(int offset, int length)
           
 Vector DenseVector.viewPart(int offset, int length)
           
 Vector DelegatingVector.viewPart(int offset, int length)
           
 Vector AbstractVector.viewPart(int offset, int length)
           
 Vector SparseRowMatrix.viewRow(int row)
           
 Vector SparseMatrix.viewRow(int row)
           
 Vector PivotedMatrix.viewRow(int row)
          Return the row at the given index
 Vector MatrixView.viewRow(int row)
           
 Vector Matrix.viewRow(int row)
          Return a reference to a row.
 Vector FileBasedSparseBinaryMatrix.viewRow(int rowIndex)
          Returns a view of a row.
 Vector DenseMatrix.viewRow(int row)
           
 Vector AbstractMatrix.viewRow(int row)
          Returns a view of a row.
 

Methods in org.apache.mahout.math with parameters of type Vector
 void DenseVector.addAll(Vector v)
           
 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(Vector other)
          Assign the other vector values to the receiver
 Vector RandomAccessSparseVector.assign(Vector other)
           
 Vector NamedVector.assign(Vector other)
           
 Vector DelegatingVector.assign(Vector other)
           
 Vector AbstractVector.assign(Vector other)
           
 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.
 Matrix UpperTriangular.assignColumn(int column, Vector other)
           
 Matrix SparseRowMatrix.assignColumn(int column, Vector other)
           
 Matrix SparseMatrix.assignColumn(int column, Vector other)
           
 Matrix SparseColumnMatrix.assignColumn(int column, Vector other)
           
 Matrix RandomTrinaryMatrix.assignColumn(int column, Vector other)
           
 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 Matrix.assignColumn(int column, Vector other)
          Assign the other vector values to the column of the receiver
 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 DiagonalMatrix.assignColumn(int column, Vector other)
           
 Matrix DenseMatrix.assignColumn(int column, Vector other)
           
 Matrix UpperTriangular.assignRow(int row, Vector other)
           
 Matrix SparseRowMatrix.assignRow(int row, Vector other)
           
 Matrix SparseMatrix.assignRow(int row, Vector other)
           
 Matrix SparseColumnMatrix.assignRow(int row, Vector other)
           
 Matrix RandomTrinaryMatrix.assignRow(int row, Vector other)
           
 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 Matrix.assignRow(int row, Vector other)
          Assign the other vector values to the row of the receiver
 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 DiagonalMatrix.assignRow(int row, Vector other)
          Assign the other vector values to the row of the receiver
 Matrix DenseMatrix.assignRow(int row, Vector other)
           
static Centroid Centroid.create(int key, Vector initialValue)
           
 Matrix Vector.cross(Vector other)
          Return the cross product of the receiver and the other vector
 Matrix NamedVector.cross(Vector other)
           
 Matrix DelegatingVector.cross(Vector other)
           
 Matrix AbstractVector.cross(Vector other)
           
 double Vector.dot(Vector x)
          Return the dot product of the recipient and the argument
 double NamedVector.dot(Vector x)
           
 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 VectorView.getDistanceSquared(Vector v)
           
 double Vector.getDistanceSquared(Vector v)
          Get the square of the distance between this vector and the other vector.
 double NamedVector.getDistanceSquared(Vector v)
           
 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 Vector.minus(Vector x)
          Return a new vector containing the element by element difference of the recipient and the argument
 Vector NamedVector.minus(Vector x)
           
 Vector DelegatingVector.minus(Vector that)
           
 Vector AbstractVector.minus(Vector that)
           
static Vector Algebra.mult(Matrix m, Vector v)
           
 Vector Vector.plus(Vector x)
          Return a new vector containing the element by element sum of the recipient and the argument
 Vector NamedVector.plus(Vector x)
           
 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 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 Vector.times(Vector x)
          Return a new vector containing the element-wise product of the recipient and the argument
 Vector NamedVector.times(Vector x)
           
 Vector DelegatingVector.times(Vector x)
           
 Vector AbstractVector.times(Vector that)
           
 Vector AbstractMatrix.times(Vector v)
           
 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)
           
 

Constructors in org.apache.mahout.math with parameters of type Vector
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)
           
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)
           
 

Uses of Vector in org.apache.mahout.math.als
 

Methods in org.apache.mahout.math.als that return Vector
static Vector AlternatingLeastSquaresSolver.solve(Iterable<Vector> featureVectors, Vector ratingVector, double lambda, int numFeatures)
           
 Vector ImplicitFeedbackAlternatingLeastSquaresSolver.solve(Vector ratings)
           
 

Methods in org.apache.mahout.math.als with parameters of type Vector
static Vector AlternatingLeastSquaresSolver.solve(Iterable<Vector> featureVectors, Vector ratingVector, double lambda, int numFeatures)
           
 Vector ImplicitFeedbackAlternatingLeastSquaresSolver.solve(Vector ratings)
           
 

Method parameters in org.apache.mahout.math.als with type arguments of type Vector
static Vector AlternatingLeastSquaresSolver.solve(Iterable<Vector> featureVectors, Vector ratingVector, double lambda, int numFeatures)
           
 

Constructor parameters in org.apache.mahout.math.als with type arguments of type Vector
ImplicitFeedbackAlternatingLeastSquaresSolver(int numFeatures, double lambda, double alpha, OpenIntObjectHashMap<Vector> Y)
           
 

Uses of Vector in org.apache.mahout.math.decomposer
 

Methods in org.apache.mahout.math.decomposer with parameters of type Vector
protected  EigenStatus AsyncEigenVerifier.innerVerify(VectorIterable corpus, Vector vector)
           
 EigenStatus SingularVectorVerifier.verify(VectorIterable eigenMatrix, Vector vector)
           
 EigenStatus SimpleEigenVerifier.verify(VectorIterable corpus, Vector vector)
           
 EigenStatus AsyncEigenVerifier.verify(VectorIterable corpus, Vector vector)
           
 

Uses of Vector in org.apache.mahout.math.decomposer.hebbian
 

Methods in org.apache.mahout.math.decomposer.hebbian that return Vector
 Vector TrainingState.currentTrainingProjection()
           
 Vector TrainingState.getHelperVector()
           
 Vector TrainingState.mostRecentEigen()
           
 

Methods in org.apache.mahout.math.decomposer.hebbian with parameters of type Vector
protected  boolean HebbianSolver.hasNotConverged(Vector currentPseudoEigen, Matrix corpus, TrainingState state)
          Uses the SingularVectorVerifier to check for convergence
 void TrainingState.setHelperVector(Vector helperVector)
           
 void HebbianUpdater.update(Vector pseudoEigen, Vector trainingVector, TrainingState currentState)
           
 void EigenUpdater.update(Vector pseudoEigen, Vector trainingVector, TrainingState currentState)
           
protected  EigenStatus HebbianSolver.verify(Matrix corpus, Vector currentPseudoEigen)
           
 

Uses of Vector in org.apache.mahout.math.decomposer.lanczos
 

Fields in org.apache.mahout.math.decomposer.lanczos with type parameters of type Vector
protected  Map<Integer,Vector> LanczosState.basis
           
protected  Map<Integer,Vector> LanczosState.singularVectors
           
 

Methods in org.apache.mahout.math.decomposer.lanczos that return Vector
 Vector LanczosState.getBasisVector(int i)
           
 Vector LanczosState.getRightSingularVector(int i)
           
 

Methods in org.apache.mahout.math.decomposer.lanczos with parameters of type Vector
protected static double LanczosSolver.calculateScaleFactor(Vector nextVector)
           
protected static void LanczosSolver.orthoganalizeAgainstAllButLast(Vector nextVector, LanczosState state)
           
 void LanczosState.setBasisVector(int i, Vector basisVector)
           
 void LanczosState.setRightSingularVector(int i, Vector vector)
           
 

Constructors in org.apache.mahout.math.decomposer.lanczos with parameters of type Vector
LanczosState(VectorIterable corpus, int desiredRank, Vector initialVector)
           
 

Uses of Vector in org.apache.mahout.math.function
 

Methods in org.apache.mahout.math.function with parameters of type Vector
 double VectorFunction.apply(Vector f)
           
 

Uses of Vector in org.apache.mahout.math.random
 

Methods in org.apache.mahout.math.random that return Vector
 Vector MultiNormal.getScale()
           
 Vector MultiNormal.sample()
           
 

Constructors in org.apache.mahout.math.random with parameters of type Vector
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.
 

Uses of Vector in org.apache.mahout.math.solver
 

Methods in org.apache.mahout.math.solver that return Vector
 Vector EigenDecomposition.getImagEigenvalues()
          Return the imaginary parts of the eigenvalues
 Vector EigenDecomposition.getRealEigenvalues()
          Return the real parts of the eigenvalues
 Vector Preconditioner.precondition(Vector v)
          Preconditions the specified vector.
 Vector JacobiConditioner.precondition(Vector v)
           
 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.
 

Methods in org.apache.mahout.math.solver with parameters of type Vector
 Vector Preconditioner.precondition(Vector v)
          Preconditions the specified vector.
 Vector JacobiConditioner.precondition(Vector v)
           
 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.
 

Uses of Vector in org.apache.mahout.math.ssvd
 

Methods in org.apache.mahout.math.ssvd that return Vector
 Vector SequentialBigSvd.getSingularValues()
           
 



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