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   
org.apache.mahout.math.function Core interfaces for functions, comparisons and procedures on objects and primitive data types. 
 

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 MatrixVectorView
          Provides a virtual vector that is really a row or column or diagonal of a matrix.
 class NamedVector
           
 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 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 NamedVector.assign(BinaryFunction f, double y)
           
 Vector AbstractVector.assign(BinaryFunction f, double y)
           
 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(UnaryFunction function)
          Apply the function to each element of the receiver
 Vector NamedVector.assign(UnaryFunction function)
           
 Vector AbstractVector.assign(UnaryFunction 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, BinaryFunction function)
          Apply the function to each element of the receiver and the corresponding element of the other argument
 Vector NamedVector.assign(Vector other, BinaryFunction function)
           
 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 MatrixVectorView.clone()
           
 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 vector containing the values of the recipient divided by the argument
 Vector NamedVector.divide(double x)
           
 Vector AbstractVector.divide(double x)
           
 Vector VectorList.getColumn(int column)
           
 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 NamedVector.getDelegate()
           
 Vector VectorList.getRow(int row)
          Return the row at the given index
 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 Vector.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 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)
           
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 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 Matrix.viewColumn(int column)
           
 Vector AbstractMatrix.viewColumn(int column)
          Returns a view of a row.
 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 Matrix.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)
           
 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 NamedVector.addTo(Vector v)
           
 void DenseVector.addTo(Vector v)
           
 void AbstractVector.addTo(Vector v)
           
 void VectorList.adjoinRow(Vector vector)
           
 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 NamedVector.aggregate(Vector other, BinaryFunction aggregator, BinaryFunction combiner)
           
 double AbstractVector.aggregate(Vector other, BinaryFunction aggregator, BinaryFunction 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, BinaryFunction function)
          Apply the function to each element of the receiver and the corresponding element of the other argument
 Vector NamedVector.assign(Vector other, BinaryFunction function)
           
 Vector DenseVector.assign(Vector other, BinaryFunction function)
           
 Vector AbstractVector.assign(Vector other, BinaryFunction function)
           
 Matrix VectorList.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 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 VectorList.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 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 NamedVector.cross(Vector other)
           
 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 NamedVector.dot(Vector x)
           
 double DenseVector.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)
           
 com.google.gson.JsonElement JsonVectorAdapter.serialize(Vector src, java.lang.reflect.Type typeOfSrc, com.google.gson.JsonSerializationContext context)
           
 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)
MatrixSlice(Vector v, int index)
           
NamedVector(Vector delegate, java.lang.String name)
           
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)
           
 

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)
           
 



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