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.matrix   
org.apache.mahout.math.matrix.impl Matrix implementations; You normally need not look at this package, because all concrete classes implement the abstract interfaces of org.apache.mahout.math.matrix, without subsetting or supersetting
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  class AbstractMatrix.TransposeViewVector
           
 class AbstractVector
          Implementations of generic capabilities like sum of elements and dot products
 class ConstantVector
          Implements a vector with all the same values.
 class DenseVector
          Implements vector as an array of doubles
 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
 

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 AbstractVector.assign(double value)
           
 Vector Vector.assign(double[] values)
          Assign the values to the receiver
 Vector NamedVector.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 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 AbstractVector.assign(DoubleFunction function)
           
 Vector Vector.assign(Vector other)
          Assign the other vector values to the receiver
 Vector SequentialAccessSparseVector.assign(Vector other)
           
 Vector RandomAccessSparseVector.assign(Vector other)
           
 Vector NamedVector.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 DenseVector.assign(Vector other, DoubleDoubleFunction function)
           
 Vector AbstractVector.assign(Vector other, DoubleDoubleFunction function)
           
 Vector VectorView.clone()
           
 Vector Vector.clone()
          Return a copy of the recipient
 Vector MatrixVectorView.clone()
           
 Vector AbstractVector.clone()
           
 Vector AbstractMatrix.TransposeViewVector.clone()
           
 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 AbstractVector.divide(double x)
           
 Vector NamedVector.getDelegate()
           
 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 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 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 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 SequentialAccessSparseVector.minus(Vector that)
           
 Vector NamedVector.minus(Vector x)
           
 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 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 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 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 AbstractVector.plus(Vector x)
           
 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 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 AbstractVector.times(Vector x)
           
 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 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 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 AbstractVector.aggregate(Vector other, DoubleDoubleFunction aggregator, DoubleDoubleFunction combiner)
           
 Vector Vector.assign(Vector other)
          Assign the other vector values to the receiver
 Vector SequentialAccessSparseVector.assign(Vector other)
           
 Vector RandomAccessSparseVector.assign(Vector other)
           
 Vector NamedVector.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 DenseVector.assign(Vector other, DoubleDoubleFunction function)
           
 Vector AbstractVector.assign(Vector other, DoubleDoubleFunction function)
           
 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 DiagonalMatrix.assignColumn(int column, Vector other)
           
 Matrix DenseMatrix.assignColumn(int column, 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 DiagonalMatrix.assignRow(int row, Vector other)
          Assign the other vector values to the row of the receiver
 Matrix DenseMatrix.assignRow(int row, Vector other)
           
 Matrix Vector.cross(Vector other)
          Return the cross product of the receiver and the other vector
 Matrix NamedVector.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 AbstractVector.dot(Vector x)
           
 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 AbstractVector.getDistanceSquared(Vector v)
           
 Vector Vector.minus(Vector x)
          Return a new vector containing the element by element difference of the recipient and the argument
 Vector SequentialAccessSparseVector.minus(Vector that)
           
 Vector NamedVector.minus(Vector x)
           
 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 AbstractVector.plus(Vector 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 AbstractVector.times(Vector x)
           
 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)
           
 

Constructors in org.apache.mahout.math with parameters of type Vector
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)
           
VectorView(Vector vector, int offset, int cardinality)
           
 

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

Methods in org.apache.mahout.math.als that return Vector
 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
 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
 Vector AlternatingLeastSquaresSolver.solve(Iterable<Vector> featureVectors, Vector ratingVector, double lambda, int numFeatures)
           
 

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  double LanczosSolver.calculateScaleFactor(Vector nextVector)
           
protected  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.matrix
 

Methods in org.apache.mahout.math.matrix that return Vector
 Vector DoubleMatrix1D.toVector()
          Deprecated.  
 

Uses of Vector in org.apache.mahout.math.matrix.impl
 

Methods in org.apache.mahout.math.matrix.impl that return Vector
 Vector SparseDoubleMatrix1D.toVector()
          Deprecated.  
 

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

Methods in org.apache.mahout.math.solver that return 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.
 

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-2012 The Apache Software Foundation. All Rights Reserved.