Vector (Cognitive Foundry)

All Superinterfaces:

java.lang.Cloneable, CloneableSerializable, java.lang.Iterable<VectorEntry>, Ring<Vector>, java.io.Serializable, Vectorizable, VectorSpace<Vector,VectorEntry>

All Known Subinterfaces:

Vector1D, Vector2D, Vector3D

All Known Implementing Classes:

AbstractMTJVector, AbstractVector, DenseVector, DenseVector, SparseVector, SparseVector, Vector1, Vector2, Vector3
```
@CodeReview(reviewer="Kevin R. Dixon",date="2008-02-26",changesNeeded=false,comments={"Minor changes to formatting.","Otherwise, looks good."}) @CodeReview(reviewer="Jonathan McClain",date="2006-05-17",changesNeeded=false,comments="Looks fine.")
public interface Vector
extends VectorSpace<Vector,VectorEntry>, Vectorizable
```
The Vector interface defines the operations that are expected on a mathematical vector. The Vector can be thought of as a collection of doubles of fixed size (the dimensionality) that supports array-like indexing into the Vector. The Vector is defined as an interface because there is more than one way to implement a Vector, in particular if you want to make use of sparseness, which occurs when most of the elements of a Vector are zero so that they are not represented.

Since:

1.0

Author:

Kevin R. Dixon, Justin Basilico

Nested Class Summary

Nested Classes
Modifier and Type	Interface and Description
`static interface`	`Vector.IndexValueConsumer` Defines the functionality for a consumer of vector entries, which are an index and a value.
`static interface`	`Vector.IndexValueTransform` Defines the functionality for a transform of vector entries, which are an index and a value and return the new value.

Nested classes/interfaces inherited from interface gov.sandia.cognition.math.matrix.VectorSpace
VectorSpace.Entry

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`void`	`assertDimensionalityEquals(int otherDimensionality)` Asserts that the dimensionality of this vector equals the given dimensionality.
`void`	`assertSameDimensionality(Vector other)` Asserts that this vector has the same dimensionality as the given vector.
`boolean`	`checkSameDimensionality(Vector other)` Determines if `this` and `other` have the same number of dimensions (size)
`Vector`	`clone()` Returns a smart copy of `this`, such that changing the values of the return class will not effect `this`
`int`	`countNonZeros()` Counts the number of non-zero entries in the vector.
`void`	`decrement(int index)` Decrements the value of the given index by 1.
`void`	`decrement(int index, double value)` Decrements the value of the given index by the given value.
`Vector`	`dotDivide(Vector other)` Element-wise division of `this` by `other`.
`void`	`dotDivideEquals(Vector other)` Inline element-wise division of `this` by `other`.
`void`	`forEachElement(Vector.IndexValueConsumer consumer)` Applies the given function to each element in this vector.
`void`	`forEachEntry(Vector.IndexValueConsumer consumer)` Applies the given function to each active entry in this vector.
`void`	`forEachNonZero(Vector.IndexValueConsumer consumer)` Applies the given function to each non-zero entry in this vector.
`double`	`get(int index)` Gets the value of element of the vector at the zero-based index.
`int`	`getDimensionality()` Returns the number of elements in the Vector
`double`	`getElement(int index)` Gets the zero-based indexed element from the Vector
`int`	`getEntryCount()` Gets the number of active entries in the vector.
`VectorFactory<?>`	`getVectorFactory()` Gets a vector factory associated with this kind of vector.
`void`	`increment(int index)` Increments the value of the given index by 1.
`void`	`increment(int index, double value)` Increments the value of the given index by the given value.
`boolean`	`isSparse()` Returns true if this vector has a potentially sparse underlying structure.
`Matrix`	`outerProduct(Vector other)` Computes the outer matrix product between the two vectors
`void`	`set(int index, double value)` Sets the value for an element at the zero-based index from the vector.
`void`	`setElement(int index, double value)` Sets the zero-based indexed element in the Vector from the specified value
`Vector`	`stack(Vector other)` Stacks "other" below "this" and returns the stacked Vector
`Vector`	`subVector(int minIndex, int maxIndex)` Gets a subvector of "this", specified by the inclusive indices
`Vector`	`times(Matrix matrix)` Premultiplies the matrix by the vector "this"
`double[]`	`toArray()` Converts this vector to a new array of doubles, in the same order as they are in the vector.
`java.lang.String`	`toString()`
`java.lang.String`	`toString(java.text.NumberFormat format)` Converts the vector to a `String`, using the given formatter.
`java.lang.String`	`toString(java.text.NumberFormat format, java.lang.String delimiter)` Converts the vector to a `String`, using the given formatter and delimiter.
`Vector`	`transform(UnivariateScalarFunction function)` Applies the given function to each of the elements of this vector and returns a new vector with the result.
`Vector`	`transform(Vector.IndexValueTransform function)` Applies the given function to each of the elements of this vector and returns a new vector with the result.
`void`	`transformEquals(UnivariateScalarFunction function)` Applies the given function to each of the elements of this vector and sets them to the result.
`void`	`transformEquals(Vector.IndexValueTransform function)` Applies the given function to each of the elements of this vector and sets them to the result.
`Vector`	`transformNonZeros(UnivariateScalarFunction function)` Applies the given function to each of the non-zero elements of this vector and returns a new vector with the result.
`Vector`	`transformNonZeros(Vector.IndexValueTransform function)` Applies the given function to each of the non-zero elements of this vector and returns a new vector with the result.
`void`	`transformNonZerosEquals(UnivariateScalarFunction function)` Applies the given function to each of the non-zero elements of this vector and sets them to the result.
`void`	`transformNonZerosEquals(Vector.IndexValueTransform function)` Applies the given function to each of the non-zero elements of this vector and sets them to the result.
`java.util.List<java.lang.Double>`	`valuesAsList()` Gets a view of this vector as a list.

Methods inherited from interface gov.sandia.cognition.math.matrix.VectorSpace
angle, cosine, dot, dotProduct, euclideanDistance, euclideanDistanceSquared, getMaxValue, getMinValue, isUnitVector, isUnitVector, norm, norm1, norm2, norm2Squared, normInfinity, sum, unitVector, unitVectorEquals

Methods inherited from interface gov.sandia.cognition.math.Ring
dotTimes, dotTimesEquals, equals, equals, isZero, isZero, minus, minusEquals, negative, negativeEquals, plus, plusEquals, scale, scaledMinus, scaledMinusEquals, scaledPlus, scaledPlusEquals, scaleEquals, zero

Methods inherited from interface java.lang.Iterable
forEach, iterator, spliterator

Methods inherited from interface gov.sandia.cognition.math.matrix.Vectorizable
convertFromVector, convertToVector

- Method Detail
  - clone
```
Vector clone()
```
    Description copied from interface: Ring
    
    Returns a smart copy of this, such that changing the values of the return class will not effect this
    
    Specified by:
    
    clone in interface CloneableSerializable
    
    Specified by:
    
    clone in interface Ring<Vector>
    
    Specified by:
    
    clone in interface Vectorizable
    
    Returns:
    
    smart copy of this
  - getDimensionality
```
int getDimensionality()
```
    Returns the number of elements in the Vector
    
    Returns:
    
    number of elements in the Vector
  - get
```
double get(int index)
```
    Gets the value of element of the vector at the zero-based index. It throws an ArrayIndexOutOfBoundsException if the index is out of range. It is a convenience method for getElement.
    
    Parameters:
    
    index - The zero-based index. Must be between 0 (inclusive) and the dimensionality of the vector (exclusive).
    
    Returns:
    
    The value at the index in the vector.
    
    Since:
    
    3.4.0
  - set
```
void set(int index,
         double value)
```
    Sets the value for an element at the zero-based index from the vector. It throws an ArrayIndexOutOfBoundsException if the index is out of range. It is a convenience method for setElement.
    
    Parameters:
    
    index - The zero-based index. Must be between 0 (inclusive) and the dimensionality of the vector (exclusive).
    
    value - The value at the index in the vector.
    
    Since:
    
    3.4.0
  - getElement
```
double getElement(int index)
```
    Gets the zero-based indexed element from the Vector
    
    Parameters:
    
    index - zero-based index
    
    Returns:
    
    zero-based indexed element in the Vector
  - setElement
```
void setElement(int index,
                double value)
```
    Sets the zero-based indexed element in the Vector from the specified value
    
    Parameters:
    
    index - zero-based index
    
    value - value to set the element in the Vector
  - outerProduct
```
Matrix outerProduct(Vector other)
```
    Computes the outer matrix product between the two vectors
    
    Parameters:
    
    other - post-multiplied Vector with which to compute the outer product
    
    Returns:
    
    Outer matrix product, which will have dimensions (this.getDimensionality x other.getDimensionality) and WILL BE singular
  - times
```
Vector times(Matrix matrix)
```
    Premultiplies the matrix by the vector "this"
    
    Parameters:
    
    matrix - Matrix to premultiply by "this", must have the same number of rows as the dimensionality of "this"
    
    Returns:
    
    Vector of dimension equal to the number of columns of "matrix"
  - dotDivide
```
Vector dotDivide(Vector other)
```
    Element-wise division of this by other. Note that if other has zero elements the result will contain NaN values.
    
    Parameters:
    
    other - The other ring whose elements will divide into this one.
    
    Returns:
    
    A new ring of equal size whose elements are equal to the corresponding element in this divided by the element in other.
  - dotDivideEquals
```
void dotDivideEquals(Vector other)
```
    Inline element-wise division of this by other. Note that if other has zero elements this will contain NaN values.
    
    Parameters:
    
    other - The other vector whose elements will divide into this one.
  - checkSameDimensionality
```
boolean checkSameDimensionality(Vector other)
```
    Determines if this and other have the same number of dimensions (size)
    
    Parameters:
    
    other - vector to compare to
    
    Returns:
    
    true iff this.getDimensionality() == other.getDimensionality(), false otherwise
  - assertSameDimensionality
```
void assertSameDimensionality(Vector other)
```
    Asserts that this vector has the same dimensionality as the given vector. If this assertion fails, a DimensionalityMismatchException is thrown.
    
    Parameters:
    
    other - The other vector to compare to.
  - assertDimensionalityEquals
```
void assertDimensionalityEquals(int otherDimensionality)
```
    Asserts that the dimensionality of this vector equals the given dimensionality. If this assertion fails, a DimensionalityMismatchException is thrown.
    
    Parameters:
    
    otherDimensionality - The dimensionality of the.
  - stack
```
Vector stack(Vector other)
```
    Stacks "other" below "this" and returns the stacked Vector
    
    Parameters:
    
    other - Vector to stack below "this"
    
    Returns:
    
    stacked Vector
  - subVector
```
Vector subVector(int minIndex,
                 int maxIndex)
```
    Gets a subvector of "this", specified by the inclusive indices
    
    Parameters:
    
    minIndex - minimum index to get (inclusive)
    
    maxIndex - maximum index to get (inclusive)
    
    Returns:
    
    vector of dimension (maxIndex-minIndex+1)
  - transform
```
Vector transform(UnivariateScalarFunction function)
```
    Applies the given function to each of the elements of this vector and returns a new vector with the result. Note that this is a dense operation where zero elements will be passed to the function.
    
    Parameters:
    
    function - The function from double to double to apply.
    
    Returns:
    
    A new vector whose elements represent the result of applying the function to corresponding element in this vector.
  - transform
```
Vector transform(Vector.IndexValueTransform function)
```
    Applies the given function to each of the elements of this vector and returns a new vector with the result. Note that this is a dense operation where zero elements will be passed to the function.
    
    Parameters:
    
    function - The function from index and value to double to apply.
    
    Returns:
    
    A new vector whose elements represent the result of applying the function to corresponding element in this vector.
  - transformEquals
```
void transformEquals(UnivariateScalarFunction function)
```
    Applies the given function to each of the elements of this vector and sets them to the result.
    
    Parameters:
    
    function - The function from double to double to apply.
  - transformEquals
```
void transformEquals(Vector.IndexValueTransform function)
```
    Applies the given function to each of the elements of this vector and sets them to the result.
    
    Parameters:
    
    function - The function from index and value to double to apply.
  - transformNonZeros
```
Vector transformNonZeros(UnivariateScalarFunction function)
```
    Applies the given function to each of the non-zero elements of this vector and returns a new vector with the result.
    
    Parameters:
    
    function - The function from double to double to apply to the non-zero elements.
    
    Returns:
    
    A new vector whose elements represent the result of applying the function to the corresponding element in this vector, except for zeros, which are exactly the same as in this vector.
  - transformNonZeros
```
Vector transformNonZeros(Vector.IndexValueTransform function)
```
    Applies the given function to each of the non-zero elements of this vector and returns a new vector with the result.
    
    Parameters:
    
    function - The function from index and value to double to apply to non-zero elements.
    
    Returns:
    
    A new vector whose elements represent the result of applying the function to the corresponding element in this vector, except for zeros, which are exactly the same as in this vector.
  - transformNonZerosEquals
```
void transformNonZerosEquals(UnivariateScalarFunction function)
```
    Applies the given function to each of the non-zero elements of this vector and sets them to the result.
    
    Parameters:
    
    function - The function from double to double to apply to the non-zero elements.
  - transformNonZerosEquals
```
void transformNonZerosEquals(Vector.IndexValueTransform function)
```
    Applies the given function to each of the non-zero elements of this vector and sets them to the result.
    
    Parameters:
    
    function - The function from index and value to double to apply to non-zero elements.
  - forEachElement
```
void forEachElement(Vector.IndexValueConsumer consumer)
```
    Applies the given function to each element in this vector. This is a dense operation that includes all values, even on a sparse vector.
    
    Parameters:
    
    consumer - The consumer for the entries. It is called for each element in the vector, in order by increasing index.
  - forEachEntry
```
void forEachEntry(Vector.IndexValueConsumer consumer)
```
    Applies the given function to each active entry in this vector. This can be faster than looping over the entries using an iterator.
    
    Parameters:
    
    consumer - The consumer for the entries. It is called for each active entry in the vector, in order by increasing index.
  - forEachNonZero
```
void forEachNonZero(Vector.IndexValueConsumer consumer)
```
    Applies the given function to each non-zero entry in this vector. This can be faster than looping over the entries using an iterator.
    
    Parameters:
    
    consumer - The consumer for the non-zero entries. It is called for each non-zero entry in the vector, in order by increasing index.
  - increment
```
void increment(int index)
```
    Increments the value of the given index by 1.
    
    Parameters:
    
    index - The index of the dimension to increment.
  - increment
```
void increment(int index,
               double value)
```
    Increments the value of the given index by the given value.
    
    Parameters:
    
    index - The index of the dimension to increment.
    
    value - The value to add.
  - decrement
```
void decrement(int index)
```
    Decrements the value of the given index by 1.
    
    Parameters:
    
    index - The index of the dimension to decrement.
  - decrement
```
void decrement(int index,
               double value)
```
    Decrements the value of the given index by the given value.
    
    Parameters:
    
    index - The index of the dimension to decrement.
    
    value - The value to subtract.
  - isSparse
```
boolean isSparse()
```
    Returns true if this vector has a potentially sparse underlying structure. This can indicate that it is faster to only process the non-zero elements rather than to do dense operations on it. Of course, even with a sparse structure, there may be no zero elements or conversely even with a non-sparse (dense) structure there may be many zero elements.
    
    Returns:
    
    True if the vector has a potentially sparse structure. Otherwise, false.
  - getEntryCount
```
int getEntryCount()
```
    Gets the number of active entries in the vector. Must be between zero and the dimensionality.
    
    Returns:
    
    The number of active entries in the vector.
  - countNonZeros
```
int countNonZeros()
```
    Counts the number of non-zero entries in the vector. Must be between zero and the dimensionality. This operation may require evaluating all entries in the vector based on the implementation.
    
    Returns:
    
    The number of non-zero values in the vector.
  - toArray
```
double[] toArray()
```
    Converts this vector to a new array of doubles, in the same order as they are in the vector. The returned will be safe in that no references are maintained by this vector.
    
    Returns:
    
    The vector as a dense array of doubles. Its length will be equal to the dimensionality of the vector.
  - valuesAsList
```
java.util.List<java.lang.Double> valuesAsList()
```
    Gets a view of this vector as a list. The list is the same size as this array.
    
    Returns:
    
    A list representing this array.
  - toString
```
java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - toString
```
java.lang.String toString(java.text.NumberFormat format)
```
    Converts the vector to a String, using the given formatter.
    
    Parameters:
    
    format - The number format to use.
    
    Returns:
    
    The string representation of the vector.
  - toString
```
java.lang.String toString(java.text.NumberFormat format,
                          java.lang.String delimiter)
```
    Converts the vector to a String, using the given formatter and delimiter.
    
    Parameters:
    
    format - The number format to use.
    
    delimiter - The delimiter to use.
    
    Returns:
    
    The string representation of the vector.
  - getVectorFactory
```
VectorFactory<?> getVectorFactory()
```
    Gets a vector factory associated with this kind of vector.
    
    Returns:
    
    The associated factory.

Interface Vector

Nested Class Summary

Nested classes/interfaces inherited from interface gov.sandia.cognition.math.matrix.VectorSpace

Method Summary

Methods inherited from interface gov.sandia.cognition.math.matrix.VectorSpace

Methods inherited from interface gov.sandia.cognition.math.Ring

Methods inherited from interface java.lang.Iterable

Methods inherited from interface gov.sandia.cognition.math.matrix.Vectorizable

Method Detail

clone

getDimensionality

get

set

getElement

setElement

outerProduct

times

dotDivide

dotDivideEquals

checkSameDimensionality

assertSameDimensionality

assertDimensionalityEquals

stack

subVector

transform

transform

transformEquals

transformEquals

transformNonZeros

transformNonZeros

transformNonZerosEquals

transformNonZerosEquals

forEachElement

forEachEntry

forEachNonZero

increment

increment

decrement

decrement

isSparse

getEntryCount

countNonZeros

toArray

valuesAsList

toString

toString

toString

getVectorFactory