Package org.apache.commons.math3.linear

# Class SparseFieldVector<T extends FieldElement<T>>

java.lang.Object
org.apache.commons.math3.linear.SparseFieldVector<T>

Type Parameters:
  `T` - the type of the field elements

All Implemented Interfaces:
  `Serializable`, `FieldVector<T>`

public class SparseFieldVector<T extends FieldElement<T>> extends Object implements FieldVector<T>, Serializable
This class implements the `FieldVector` interface with a `OpenIntToFieldHashMap` backing store.

Caveat: This implementation assumes that, for any `x`, the equality `x * 0d == 0d` holds. But it is is not true for `NaN`. Moreover, zero entries will lose their sign. Some operations (that involve `NaN` and/or infinities) may thus give incorrect results.

Since:
  2.0
See Also:
  - Serialized Form

## Constructor Summary

Constructors
Modifier
Constructor
Description
``
`SparseFieldVector(Field<T> field)`
Build a 0-length vector.
``
`SparseFieldVector(Field<T> field, int dimension)`
Construct a vector of zeroes.
``
`SparseFieldVector(Field<T> field, int dimension, int expectedSize)`
Build a vector with known the sparseness (for advanced use only).
``
`SparseFieldVector(Field<T> field, T[] values)`
Create from a Field array.
``
`SparseFieldVector(SparseFieldVector<T> v)`
Copy constructor.
`protected`
`SparseFieldVector(SparseFieldVector<T> v, int resize)`
Build a resized vector, for use with append.

## Method Summary

Modifier and Type
Method
Description
`FieldVector<T>`
`add(FieldVector<T> v)`
Compute the sum of `this` and `v`.
`FieldVector<T>`
`add(SparseFieldVector<T> v)`
Optimized method to add sparse vectors.
`FieldVector<T>`
`append(FieldVector<T> v)`
Construct a vector by appending a vector to this vector.
`FieldVector<T>`
`append(SparseFieldVector<T> v)`
Construct a vector by appending a vector to this vector.
`FieldVector<T>`
`append(T d)`
Construct a vector by appending a T to this vector.
`protected void`
`checkVectorDimensions(int n)`
Check if instance dimension is equal to some expected value.
`FieldVector<T>`
`copy()`
Returns a (deep) copy of this.
`T`
`dotProduct(FieldVector<T> v)`
Compute the dot product.
`FieldVector<T>`
`ebeDivide(FieldVector<T> v)`
Element-by-element division.
`FieldVector<T>`
`ebeMultiply(FieldVector<T> v)`
Element-by-element multiplication.
`boolean`
`equals(Object obj)`
`T[]`
`getData()`
Deprecated.
as of 3.1, to be removed in 4.0.
`int`
`getDimension()`
Returns the size of the vector.
`T`
`getEntry(int index)`
Returns the entry in the specified index.
`Field<T>`
`getField()`
Get the type of field elements of the vector.
`FieldVector<T>`
`getSubVector(int index, int n)`
Get a subvector from consecutive elements.
`int`
`hashCode()`
`FieldVector<T>`
`mapAdd(T d)`
Map an addition operation to each entry.
`FieldVector<T>`
`mapAddToSelf(T d)`
Map an addition operation to each entry.
`FieldVector<T>`
`mapDivide(T d)`
Map a division operation to each entry.
`FieldVector<T>`
`mapDivideToSelf(T d)`
Map a division operation to each entry.
`FieldVector<T>`
`mapInv()`
Map the 1/x function to each entry.
`FieldVector<T>`
`mapInvToSelf()`
Map the 1/x function to each entry.
`FieldVector<T>`
`mapMultiply(T d)`
Map a multiplication operation to each entry.
`FieldVector<T>`
`mapMultiplyToSelf(T d)`
Map a multiplication operation to each entry.
`FieldVector<T>`
`mapSubtract(T d)`
Map a subtraction operation to each entry.
`FieldVector<T>`
`mapSubtractToSelf(T d)`
Map a subtraction operation to each entry.
`FieldMatrix<T>`
`outerProduct(FieldVector<T> v)`
Compute the outer product.
`FieldMatrix<T>`
`outerProduct(SparseFieldVector<T> v)`
Optimized method to compute outer product when both vectors are sparse.
`FieldVector<T>`
`projection(FieldVector<T> v)`
Find the orthogonal projection of this vector onto another vector.
`void`
`set(T value)`
Set all elements to a single value.
`void`
`setEntry(int index, T value)`
Set a single element.
`void`
`setSubVector(int index, FieldVector<T> v)`
Set a set of consecutive elements.
`FieldVector<T>`
`subtract(FieldVector<T> v)`
Compute `this` minus `v`.
`SparseFieldVector<T>`
`subtract(SparseFieldVector<T> v)`
Optimized method to compute `this` minus `v`.
`T[]`
`toArray()`
Convert the vector to a T array.
`T`
`walkInDefaultOrder(FieldVectorChangingVisitor<T> visitor)`
Visits (and possibly alters) all entries of this vector in default order (increasing index).
`T`
`walkInDefaultOrder(FieldVectorChangingVisitor<T> visitor, int start, int end)`
Visits (and possibly alters) some entries of this vector in default order (increasing index).
`T`
`walkInDefaultOrder(FieldVectorPreservingVisitor<T> visitor)`
Visits (but does not alter) all entries of this vector in default order (increasing index).
`T`
`walkInDefaultOrder(FieldVectorPreservingVisitor<T> visitor, int start, int end)`
Visits (but does not alter) some entries of this vector in default order (increasing index).
`T`
`walkInOptimizedOrder(FieldVectorChangingVisitor<T> visitor)`
Visits (and possibly alters) all entries of this vector in optimized order.
`T`
`walkInOptimizedOrder(FieldVectorChangingVisitor<T> visitor, int start, int end)`
Visits (and possibly change) some entries of this vector in optimized order.
`T`
`walkInOptimizedOrder(FieldVectorPreservingVisitor<T> visitor)`
Visits (but does not alter) all entries of this vector in optimized order.
`T`
`walkInOptimizedOrder(FieldVectorPreservingVisitor<T> visitor, int start, int end)`
Visits (but does not alter) some entries of this vector in optimized order.

### Methods inherited from class java.lang.Object

`clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait`

## Constructor Details

### SparseFieldVector

public SparseFieldVector(Field<T> field)
Build a 0-length vector. Zero-length vectors may be used to initialize construction of vectors by data gathering. We start with zero-length and use either the `SparseFieldVector(SparseFieldVector, int)` constructor or one of the `append` method (`append(FieldVector)` or `append(SparseFieldVector)`) to gather data into this vector.

Parameters:
  `field` - Field to which the elements belong.

### SparseFieldVector

public SparseFieldVector(Field<T> field, int dimension)
Construct a vector of zeroes.

Parameters:
  `field` - Field to which the elements belong.
  `dimension` - Size of the vector.

### SparseFieldVector

protected SparseFieldVector(SparseFieldVector<T> v, int resize)
Build a resized vector, for use with append.

Parameters:
  `v` - Original vector
  `resize` - Amount to add.

### SparseFieldVector

public SparseFieldVector(Field<T> field, int dimension, int expectedSize)
Build a vector with known the sparseness (for advanced use only).

Parameters:
  `field` - Field to which the elements belong.
  `dimension` - Size of the vector.
  `expectedSize` - Expected number of non-zero entries.

### SparseFieldVector

public SparseFieldVector(Field<T> field, T[] values) throws NullArgumentException
Create from a Field array. Only non-zero entries will be stored.

Parameters:
  `field` - Field to which the elements belong.
  `values` - Set of values to create from.
Throws:
  `NullArgumentException` - if values is null

### SparseFieldVector

public SparseFieldVector(SparseFieldVector<T> v)
Copy constructor.

Parameters:
  `v` - Instance to copy.

## Method Details

### add

public FieldVector<T> add(SparseFieldVector<T> v) throws DimensionMismatchException
Optimized method to add sparse vectors.

Parameters:
  `v` - Vector to add.
Returns:
  `this + v`.
Throws:
  `DimensionMismatchException` - if `v` is not the same size as `this`.

### append

public FieldVector<T> append(SparseFieldVector<T> v)
Construct a vector by appending a vector to this vector.

Parameters:
  `v` - Vector to append to this one.
Returns:
  a new vector.

### append

public FieldVector<T> append(FieldVector<T> v)
Construct a vector by appending a vector to this vector.

Specified by:
  `append` in interface `FieldVector<T extends FieldElement<T>>`
Parameters:
  `v` - vector to append to this one.
Returns:
  a new vector

### append

public FieldVector<T> append(T d) throws NullArgumentException
Construct a vector by appending a T to this vector.

Specified by:
  `append` in interface `FieldVector<T extends FieldElement<T>>`
Parameters:
  `d` - T to append.
Returns:
  a new vector
Throws:
  `NullArgumentException` - if d is null

### copy

public FieldVector<T> copy()
Returns a (deep) copy of this.

Specified by:
  `copy` in interface `FieldVector<T extends FieldElement<T>>`
Returns:
  vector copy

### dotProduct

public T dotProduct(FieldVector<T> v) throws DimensionMismatchException
Compute the dot product.

Specified by:
  `dotProduct` in interface `FieldVector<T extends FieldElement<T>>`
Parameters:
  `v` - vector with which dot product should be computed
Returns:
  the scalar dot product of `this` and `v`
Throws:
  `DimensionMismatchException` - if `v` is not the same size as `this`

### ebeDivide

public FieldVector<T> ebeDivide(FieldVector<T> v) throws DimensionMismatchException, MathArithmeticException
Element-by-element division.

Specified by:
  `ebeDivide` in interface `FieldVector<T extends FieldElement<T>>`
Parameters:
  `v` - vector by which instance elements must be divided
Returns:
  a vector containing `this[i] / v[i]` for all `i`
Throws:
  `DimensionMismatchException` - if `v` is not the same size as `this`
  `MathArithmeticException` - if one entry of `v` is zero.

### ebeMultiply

public FieldVector<T> ebeMultiply(FieldVector<T> v) throws DimensionMismatchException
Element-by-element multiplication.

Specified by:
  `ebeMultiply` in interface `FieldVector<T extends FieldElement<T>>`
Parameters:
  `v` - vector by which instance elements must be multiplied
Returns:
  a vector containing `this[i] * v[i]` for all `i`
Throws:
  `DimensionMismatchException` - if `v` is not the same size as `this`

### getData

@Deprecated public T[] getData()
Deprecated.
as of 3.1, to be removed in 4.0. Please use the `toArray()` method instead.
Returns vector entries as a T array.

Specified by:
  `getData` in interface `FieldVector<T extends FieldElement<T>>`
Returns:
  T array of entries

### getDimension

public int getDimension()
Returns the size of the vector.

Specified by:
  `getDimension` in interface `FieldVector<T extends FieldElement<T>>`
Returns:
  size

### getEntry

public T getEntry(int index) throws OutOfRangeException
Returns the entry in the specified index.

Specified by:
  `getEntry` in interface `FieldVector<T extends FieldElement<T>>`
Parameters:
  `index` - Index location of entry to be fetched.
Returns:
  the vector entry at `index`.
Throws:
  `OutOfRangeException` - if the index is not valid.
See Also:
  - `FieldVector.setEntry(int, FieldElement)`

### getField

public Field<T> getField()
Get the type of field elements of the vector.

Specified by:
  `getField` in interface `FieldVector<T extends FieldElement<T>>`
Returns:
  type of field elements of the vector

### getSubVector

public FieldVector<T> getSubVector(int index, int n) throws OutOfRangeException, NotPositiveException
Get a subvector from consecutive elements.

Specified by:
  `getSubVector` in interface `FieldVector<T extends FieldElement<T>>`
Parameters:
  `index` - index of first element.
  `n` - number of elements to be retrieved.
Returns:
  a vector containing n elements.
Throws:
  `OutOfRangeException` - if the index is not valid.
  `NotPositiveException` - if the number of elements if not positive.

### mapAdd

public FieldVector<T> mapAdd(T d) throws NullArgumentException
Map an addition operation to each entry.

Specified by:
  `mapAdd` in interface `FieldVector<T extends FieldElement<T>>`
Parameters:
  `d` - value to be added to each entry
Returns:
  `this + d`
Throws:
  `NullArgumentException` - if `d` is `null`.

### mapAddToSelf

public FieldVector<T> mapAddToSelf(T d) throws NullArgumentException
Map an addition operation to each entry.

The instance is changed by this method.

Specified by:
  `mapAddToSelf` in interface `FieldVector<T extends FieldElement<T>>`
Parameters:
  `d` - value to be added to each entry
Returns:
  for convenience, return `this`
Throws:
  `NullArgumentException` - if `d` is `null`.

### mapDivide

public FieldVector<T> mapDivide(T d) throws NullArgumentException, MathArithmeticException
Map a division operation to each entry.

Specified by:
  `mapDivide` in interface `FieldVector<T extends FieldElement<T>>`
Parameters:
  `d` - value to divide all entries by
Returns:
  `this / d`
Throws:
  `NullArgumentException` - if `d` is `null`.
  `MathArithmeticException` - if `d` is zero.

### mapDivideToSelf

public FieldVector<T> mapDivideToSelf(T d) throws NullArgumentException, MathArithmeticException
Map a division operation to each entry.

The instance is changed by this method.

Specified by:
  `mapDivideToSelf` in interface `FieldVector<T extends FieldElement<T>>`
Parameters:
  `d` - value to divide all entries by
Returns:
  for convenience, return `this`
Throws:
  `NullArgumentException` - if `d` is `null`.
  `MathArithmeticException` - if `d` is zero.

### mapInv

public FieldVector<T> mapInv() throws MathArithmeticException
Map the 1/x function to each entry.

Specified by:
  `mapInv` in interface `FieldVector<T extends FieldElement<T>>`
Returns:
  a vector containing the result of applying the function to each entry.
Throws:
  `MathArithmeticException` - if one of the entries is zero.

### mapInvToSelf

public FieldVector<T> mapInvToSelf() throws MathArithmeticException
Map the 1/x function to each entry.

The instance is changed by this method.

Specified by:
  `mapInvToSelf` in interface `FieldVector<T extends FieldElement<T>>`
Returns:
  for convenience, return `this`
Throws:
  `MathArithmeticException` - if one of the entries is zero.

### mapMultiply

public FieldVector<T> mapMultiply(T d) throws NullArgumentException
Map a multiplication operation to each entry.

Specified by:
  `mapMultiply` in interface `FieldVector<T extends FieldElement<T>>`
Parameters:
  `d` - value to multiply all entries by
Returns:
  `this * d`
Throws:
  `NullArgumentException` - if `d` is `null`.

### mapMultiplyToSelf

public FieldVector<T> mapMultiplyToSelf(T d) throws NullArgumentException
Map a multiplication operation to each entry.

The instance is changed by this method.

Specified by:
  `mapMultiplyToSelf` in interface `FieldVector<T extends FieldElement<T>>`
Parameters:
  `d` - value to multiply all entries by
Returns:
  for convenience, return `this`
Throws:
  `NullArgumentException` - if `d` is `null`.

### mapSubtract

public FieldVector<T> mapSubtract(T d) throws NullArgumentException
Map a subtraction operation to each entry.

Specified by:
  `mapSubtract` in interface `FieldVector<T extends FieldElement<T>>`
Parameters:
  `d` - value to be subtracted to each entry
Returns:
  `this - d`
Throws:
  `NullArgumentException` - if `d` is `null`

### mapSubtractToSelf

public FieldVector<T> mapSubtractToSelf(T d) throws NullArgumentException
Map a subtraction operation to each entry.

The instance is changed by this method.

Specified by:
  `mapSubtractToSelf` in interface `FieldVector<T extends FieldElement<T>>`
Parameters:
  `d` - value to be subtracted to each entry
Returns:
  for convenience, return `this`
Throws:
  `NullArgumentException` - if `d` is `null`

### outerProduct

public FieldMatrix<T> outerProduct(SparseFieldVector<T> v)
Optimized method to compute outer product when both vectors are sparse.

Parameters:
  `v` - vector with which outer product should be computed
Returns:
  the matrix outer product between instance and v

### outerProduct

public FieldMatrix<T> outerProduct(FieldVector<T> v)
Compute the outer product.

Specified by:
  `outerProduct` in interface `FieldVector<T extends FieldElement<T>>`
Parameters:
  `v` - vector with which outer product should be computed
Returns:
  the matrix outer product between instance and v

### projection

public FieldVector<T> projection(FieldVector<T> v) throws DimensionMismatchException, MathArithmeticException
Find the orthogonal projection of this vector onto another vector.

Specified by:
  `projection` in interface `FieldVector<T extends FieldElement<T>>`
Parameters:
  `v` - vector onto which `this` must be projected
Returns:
  projection of `this` onto `v`
Throws:
  `DimensionMismatchException` - if `v` is not the same size as `this`
  `MathArithmeticException` - if `v` is the null vector.

### set

public void set(T value)
Set all elements to a single value.

Specified by:
  `set` in interface `FieldVector<T extends FieldElement<T>>`
Parameters:
  `value` - single value to set for all elements
Throws:
  `NullArgumentException` - if value is null

### setEntry

public void setEntry(int index, T value) throws NullArgumentException, OutOfRangeException
Set a single element.

Specified by:
  `setEntry` in interface `FieldVector<T extends FieldElement<T>>`
Parameters:
  `index` - element index.
  `value` - new value for the element.
Throws:
  `NullArgumentException` - if value is null
  `OutOfRangeException` - if the index is not valid.
See Also:
  - `FieldVector.getEntry(int)`

### setSubVector

public void setSubVector(int index, FieldVector<T> v) throws OutOfRangeException
Set a set of consecutive elements.

Specified by:
  `setSubVector` in interface `FieldVector<T extends FieldElement<T>>`
Parameters:
  `index` - index of first element to be set.
  `v` - vector containing the values to set.
Throws:
  `OutOfRangeException` - if the index is not valid.

### subtract

public SparseFieldVector<T> subtract(SparseFieldVector<T> v) throws DimensionMismatchException
Optimized method to compute `this` minus `v`.

Parameters:
  `v` - vector to be subtracted
Returns:
  `this - v`
Throws:
  `DimensionMismatchException` - if `v` is not the same size as `this`.

### subtract

public FieldVector<T> subtract(FieldVector<T> v) throws DimensionMismatchException
Compute `this` minus `v`.

Specified by:
  `subtract` in interface `FieldVector<T extends FieldElement<T>>`
Parameters:
  `v` - vector to be subtracted
Returns:
  `this - v`
Throws:
  `DimensionMismatchException` - if `v` is not the same size as `this`

### toArray

public T[] toArray()
Convert the vector to a T array.

The array is independent from vector data, it's elements are copied.

Specified by:
  `toArray` in interface `FieldVector<T extends FieldElement<T>>`
Returns:
  array containing a copy of vector elements

### checkVectorDimensions

protected void checkVectorDimensions(int n) throws DimensionMismatchException
Check if instance dimension is equal to some expected value.

Parameters:
  `n` - Expected dimension.
Throws:
  `DimensionMismatchException` - if the dimensions do not match.

### add

public FieldVector<T> add(FieldVector<T> v) throws DimensionMismatchException
Compute the sum of `this` and `v`.

Specified by:
  `add` in interface `FieldVector<T extends FieldElement<T>>`
Parameters:
  `v` - vector to be added
Returns:
  `this + v`
Throws:
  `DimensionMismatchException` - if `v` is not the same size as `this`

### walkInDefaultOrder

public T walkInDefaultOrder(FieldVectorPreservingVisitor<T> visitor)
Visits (but does not alter) all entries of this vector in default order (increasing index).

Parameters:
  `visitor` - the visitor to be used to process the entries of this vector
Returns:
  the value returned by `FieldVectorPreservingVisitor.end()` at the end of the walk
Since:
  3.3

### walkInDefaultOrder

public T walkInDefaultOrder(FieldVectorPreservingVisitor<T> visitor, int start, int end) throws NumberIsTooSmallException, OutOfRangeException
Visits (but does not alter) some entries of this vector in default order (increasing index).

Parameters:
  `visitor` - visitor to be used to process the entries of this vector
  `start` - the index of the first entry to be visited
  `end` - the index of the last entry to be visited (inclusive)
Returns:
  the value returned by `FieldVectorPreservingVisitor.end()` at the end of the walk
Throws:
  `NumberIsTooSmallException` - if `end < start`.
  `OutOfRangeException` - if the indices are not valid.
Since:
  3.3

### walkInOptimizedOrder

public T walkInOptimizedOrder(FieldVectorPreservingVisitor<T> visitor)
Visits (but does not alter) all entries of this vector in optimized order. The order in which the entries are visited is selected so as to lead to the most efficient implementation; it might depend on the concrete implementation of this abstract class.

Parameters:
  `visitor` - the visitor to be used to process the entries of this vector
Returns:
  the value returned by `FieldVectorPreservingVisitor.end()` at the end of the walk
Since:
  3.3

### walkInOptimizedOrder

public T walkInOptimizedOrder(FieldVectorPreservingVisitor<T> visitor, int start, int end) throws NumberIsTooSmallException, OutOfRangeException
Visits (but does not alter) some entries of this vector in optimized order. The order in which the entries are visited is selected so as to lead to the most efficient implementation; it might depend on the concrete implementation of this abstract class.

Parameters:
  `visitor` - visitor to be used to process the entries of this vector
  `start` - the index of the first entry to be visited
  `end` - the index of the last entry to be visited (inclusive)
Returns:
  the value returned by `FieldVectorPreservingVisitor.end()` at the end of the walk
Throws:
  `NumberIsTooSmallException` - if `end < start`.
  `OutOfRangeException` - if the indices are not valid.
Since:
  3.3

### walkInDefaultOrder

public T walkInDefaultOrder(FieldVectorChangingVisitor<T> visitor)
Visits (and possibly alters) all entries of this vector in default order (increasing index).

Parameters:
  `visitor` - the visitor to be used to process and modify the entries of this vector
Returns:
  the value returned by `FieldVectorChangingVisitor.end()` at the end of the walk
Since:
  3.3

### walkInDefaultOrder

public T walkInDefaultOrder(FieldVectorChangingVisitor<T> visitor, int start, int end) throws NumberIsTooSmallException, OutOfRangeException
Visits (and possibly alters) some entries of this vector in default order (increasing index).

Parameters:
  `visitor` - visitor to be used to process the entries of this vector
  `start` - the index of the first entry to be visited
  `end` - the index of the last entry to be visited (inclusive)
Returns:
  the value returned by `FieldVectorChangingVisitor.end()` at the end of the walk
Throws:
  `NumberIsTooSmallException` - if `end < start`.
  `OutOfRangeException` - if the indices are not valid.
Since:
  3.3

### walkInOptimizedOrder

public T walkInOptimizedOrder(FieldVectorChangingVisitor<T> visitor)
Visits (and possibly alters) all entries of this vector in optimized order. The order in which the entries are visited is selected so as to lead to the most efficient implementation; it might depend on the concrete implementation of this abstract class.

Parameters:
  `visitor` - the visitor to be used to process the entries of this vector
Returns:
  the value returned by `FieldVectorChangingVisitor.end()` at the end of the walk
Since:
  3.3

### walkInOptimizedOrder

public T walkInOptimizedOrder(FieldVectorChangingVisitor<T> visitor, int start, int end) throws NumberIsTooSmallException, OutOfRangeException
Visits (and possibly change) some entries of this vector in optimized order. The order in which the entries are visited is selected so as to lead to the most efficient implementation; it might depend on the concrete implementation of this abstract class.

Parameters:
  `visitor` - visitor to be used to process the entries of this vector
  `start` - the index of the first entry to be visited
  `end` - the index of the last entry to be visited (inclusive)
Returns:
  the value returned by `FieldVectorChangingVisitor.end()` at the end of the walk
Throws:
  `NumberIsTooSmallException` - if `end < start`.
  `OutOfRangeException` - if the indices are not valid.
Since:
  3.3

### hashCode

public int hashCode()

Overrides:
  `hashCode` in class `Object`

### equals

public boolean equals(Object obj)

Overrides:
  `equals` in class `Object`