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.decomposer   
org.apache.mahout.math.decomposer.hebbian   
org.apache.mahout.math.decomposer.lanczos   
 

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 DenseVector
          Implements vector as an array of doubles
 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 Vector.assign(BinaryFunction f, double y)
          Apply the function to each element of the receiver, using the y value as the second argument of the BinaryFunction
 Vector AbstractVector.assign(BinaryFunction f, double y)
           
 Vector Vector.assign(double value)
          Assign the value to all elements of the receiver
 Vector DenseVector.assign(double value)
           
 Vector AbstractVector.assign(double value)
           
 Vector Vector.assign(double[] values)
          Assign the values to the receiver
 Vector AbstractVector.assign(double[] values)
           
 Vector Vector.assign(UnaryFunction function)
          Apply the function to each element of the receiver
 Vector AbstractVector.assign(UnaryFunction function)
           
 Vector Vector.assign(Vector other)
          Assign the other matrix values to the receiver
 Vector RandomAccessSparseVector.assign(Vector other)
           
 Vector AbstractVector.assign(Vector other)
           
 Vector Vector.assign(Vector other, BinaryFunction function)
          Apply the function to each element of the receiver and the corresponding element of the other argument
 Vector DenseVector.assign(Vector other, BinaryFunction function)
           
 Vector AbstractVector.assign(Vector other, BinaryFunction function)
           
 Vector VectorView.clone()
           
 Vector Vector.clone()
          Return a copy of the recipient
 Vector AbstractVector.clone()
           
 Vector AbstractMatrix.TransposeViewVector.clone()
           
static Vector AbstractVector.decodeVector(java.lang.String formattedString)
          Decodes a point from its string representation.
 Vector JsonVectorAdapter.deserialize(com.google.gson.JsonElement json, java.lang.reflect.Type typeOfT, com.google.gson.JsonDeserializationContext context)
           
 Vector Vector.divide(double x)
          Return a new matrix containing the values of the recipient divided by the argument
 Vector AbstractVector.divide(double x)
           
 Vector SparseRowMatrix.getColumn(int column)
           
 Vector SparseMatrix.getColumn(int column)
           
 Vector SparseColumnMatrix.getColumn(int column)
           
 Vector MatrixView.getColumn(int column)
           
 Vector Matrix.getColumn(int column)
          Return the column at the given index
 Vector DenseMatrix.getColumn(int column)
           
 Vector SparseRowMatrix.getRow(int row)
           
 Vector SparseMatrix.getRow(int row)
           
 Vector SparseColumnMatrix.getRow(int row)
           
 Vector MatrixView.getRow(int row)
           
 Vector Matrix.getRow(int row)
          Return the row at the given index
 Vector DenseMatrix.getRow(int row)
           
 Vector VectorView.like()
           
 Vector Vector.like()
          Return an empty matrix of the same underlying class as the receiver
 Vector AbstractMatrix.TransposeViewVector.like()
           
 Vector VectorView.like(int cardinality)
           
 Vector Vector.like(int cardinality)
          Return an empty matrix of the same underlying class as the receiver and of the given cardinality
 Vector SequentialAccessSparseVector.like(int newCardinality)
           
 Vector RandomAccessSparseVector.like(int newCardinality)
           
 Vector DenseVector.like(int cardinality)
           
 Vector AbstractMatrix.TransposeViewVector.like(int cardinality)
           
 Vector Vector.minus(Vector x)
          Return a new matrix containing the element by element difference of the recipient and the argument
 Vector AbstractVector.minus(Vector x)
           
protected  Vector AbstractMatrix.TransposeViewVector.newVector(int cardinality)
           
 Vector Vector.normalize()
          Return a new matrix containing the normalized (L_2 norm) values of the recipient
 Vector AbstractVector.normalize()
           
 Vector Vector.normalize(double power)
          Return a new Vector containing the normalized (L_power norm) values of the recipient.
 Vector AbstractVector.normalize(double power)
           
 Vector Vector.plus(double x)
          Return a new matrix containing the sum of each value of the recipient and the argument
 Vector AbstractVector.plus(double x)
           
 Vector Vector.plus(Vector x)
          Return a new matrix containing the element by element sum of the recipient and the argument
 Vector AbstractVector.plus(Vector x)
           
protected  Vector SparseColumnMatrix.slice(int index)
          Iterate over columns.
protected  Vector AbstractMatrix.slice(int index)
          Abstracted out for iterating over either rows or columns (default is rows).
 Vector Vector.times(double x)
          Return a new matrix containing the product of each value of the recipient and the argument
 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 matrix containing the element-wise product of the recipient and the argument
 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 VectorView.viewPart(int offset, int length)
           
 Vector Vector.viewPart(int offset, int length)
          Return a new matrix containing the subset of the recipient
 Vector DenseVector.viewPart(int offset, int length)
           
 Vector AbstractVector.viewPart(int offset, int length)
           
 

Methods in org.apache.mahout.math with parameters of type Vector
 void DenseVector.addAll(Vector v)
           
 void VectorView.addTo(Vector v)
           
 void Vector.addTo(Vector v)
          Add the elements to the other vector and results are stored in that vector.
 void RandomAccessSparseVector.addTo(Vector v)
           
 void DenseVector.addTo(Vector v)
           
 void AbstractVector.addTo(Vector v)
           
 double Vector.aggregate(Vector other, BinaryFunction aggregator, BinaryFunction 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 AbstractVector.aggregate(Vector other, BinaryFunction aggregator, BinaryFunction combiner)
           
 Vector Vector.assign(Vector other)
          Assign the other matrix values to the receiver
 Vector RandomAccessSparseVector.assign(Vector other)
           
 Vector AbstractVector.assign(Vector other)
           
 Vector Vector.assign(Vector other, BinaryFunction function)
          Apply the function to each element of the receiver and the corresponding element of the other argument
 Vector DenseVector.assign(Vector other, BinaryFunction function)
           
 Vector AbstractVector.assign(Vector other, BinaryFunction function)
           
 Matrix SparseRowMatrix.assignColumn(int column, Vector other)
           
 Matrix SparseMatrix.assignColumn(int column, Vector other)
           
 Matrix SparseColumnMatrix.assignColumn(int column, Vector other)
           
 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 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 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 DenseMatrix.assignRow(int row, Vector other)
           
 Matrix Vector.cross(Vector other)
          Return the cross product of the receiver and the other vector
 Matrix AbstractVector.cross(Vector other)
           
 double VectorView.dot(Vector x)
           
 double Vector.dot(Vector x)
          Return the dot product of the recipient and the argument
 double SequentialAccessSparseVector.dot(Vector x)
           
 double RandomAccessSparseVector.dot(Vector x)
           
 double DenseVector.dot(Vector x)
           
 double AbstractVector.dot(Vector x)
           
static boolean AbstractVector.equivalent(Vector left, Vector right)
          Compare whether two Vector implementations have the same elements, regardless of the implementation and name.
 double VectorView.getDistanceSquared(Vector v)
           
 double Vector.getDistanceSquared(Vector v)
          Get the square of the distance between this vector and the other vector.
 double AbstractVector.getDistanceSquared(Vector v)
           
 Vector Vector.minus(Vector x)
          Return a new matrix containing the element by element difference of the recipient and the argument
 Vector AbstractVector.minus(Vector x)
           
 Vector Vector.plus(Vector x)
          Return a new matrix containing the element by element sum of the recipient and the argument
 Vector AbstractVector.plus(Vector x)
           
 com.google.gson.JsonElement JsonVectorAdapter.serialize(Vector src, java.lang.reflect.Type typeOfSrc, com.google.gson.JsonSerializationContext context)
           
static boolean AbstractVector.strictEquivalence(Vector left, Vector right)
          Compare whether two Vector implementations are the same, including the underlying implementation.
 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 matrix containing the element-wise product of the recipient and the argument
 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)
MatrixSlice(Vector v, int index)
           
RandomAccessSparseVector(Vector other)
           
SequentialAccessSparseVector(Vector other)
           
SparseRowMatrix(int[] cardinality, Vector[] rows)
          Construct a matrix of the given cardinality with the given rows
SparseRowMatrix(int[] cardinality, Vector[] rows, boolean shallowCopy, boolean randomAccess)
           
VectorView(Vector vector, int offset, int cardinality)
           
 

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
 

Methods in org.apache.mahout.math.decomposer.lanczos that return Vector
protected  Vector LanczosSolver.getInitialVector(VectorIterable corpus)
           
 

Methods in org.apache.mahout.math.decomposer.lanczos with parameters of type Vector
protected  void LanczosSolver.calculateScaleFactor(Vector nextVector)
           
 



Copyright © 2008-2010 The Apache Software Foundation. All Rights Reserved.