org.apache.commons.math3.linear

## Class SparseFieldVector<T extends FieldElement<T>>

• ### Constructor Summary

Constructors
Modifier Constructor and 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

Methods
Modifier and Type Method and 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()`
Returns vector entries as a T array.
`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 subtract SparseRealVectors.
`T[]` `toArray()`
Convert the vector to a T array.
• ### Methods inherited from class java.lang.Object

`clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait`
• ### Constructor Detail

• #### 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)```
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.
• #### SparseFieldVector

`public SparseFieldVector(SparseFieldVector<T> v)`
Copy constructor.
Parameters:
`v` - Instance to copy.
• ### Method Detail

`public FieldVector<T> add(SparseFieldVector<T> v)`
Optimized method to add sparse vectors.
Parameters:
`v` - Vector to add.
Returns:
the sum of `this` and `v`.
Throws:
`DimensionMismatchException` - if the dimensions do not match.
• #### 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)`
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
• #### 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)`
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 between instance and v
• #### ebeDivide

`public FieldVector<T> ebeDivide(FieldVector<T> v)`
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
• #### ebeMultiply

`public FieldVector<T> ebeMultiply(FieldVector<T> v)`
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
• #### getData

`public T[] getData()`
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)`
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`.
`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)```
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.

`public FieldVector<T> mapAdd(T d)`
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

`public FieldVector<T> mapAddToSelf(T d)`
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
• #### mapDivide

`public FieldVector<T> mapDivide(T d)`
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
• #### mapDivideToSelf

`public FieldVector<T> mapDivideToSelf(T d)`
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
• #### mapInv

`public FieldVector<T> mapInv()`
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
• #### mapInvToSelf

`public FieldVector<T> mapInvToSelf()`
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
• #### mapMultiply

`public FieldVector<T> mapMultiply(T d)`
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
• #### mapMultiplyToSelf

`public FieldVector<T> mapMultiplyToSelf(T d)`
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
• #### mapSubtract

`public FieldVector<T> mapSubtract(T d)`
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
• #### mapSubtractToSelf

`public FieldVector<T> mapSubtractToSelf(T d)`
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
• #### 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 square matrix outer product between instance and v
Throws:
`DimensionMismatchException` - if the dimensions do not match.
• #### 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)`
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 instance must be projected
Returns:
projection of the instance onto v
• #### 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
• #### setEntry

```public void setEntry(int index,
T value)```
Set a single element.
Specified by:
`setEntry` in interface `FieldVector<T extends FieldElement<T>>`
Parameters:
`index` - element index.
`value` - new value for the element.
`FieldVector.getEntry(int)`
• #### setSubVector

```public void setSubVector(int index,
FieldVector<T> v)```
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.
• #### subtract

`public SparseFieldVector<T> subtract(SparseFieldVector<T> v)`
Optimized method to subtract SparseRealVectors.
Parameters:
`v` - Vector to subtract.
Returns:
the difference between `this` and `v`.
Throws:
`DimensionMismatchException` - if the dimensions do not match.
• #### subtract

`public FieldVector<T> subtract(FieldVector<T> v)`
Compute this minus v.
Specified by:
`subtract` in interface `FieldVector<T extends FieldElement<T>>`
Parameters:
`v` - vector to be subtracted
Returns:
this + v
• #### 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)`
Check if instance dimension is equal to some expected value.
Parameters:
`n` - Expected dimension.
Throws:
`DimensionMismatchException` - if the dimensions do not match.

`public FieldVector<T> add(FieldVector<T> v)`
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
• #### hashCode

`public int hashCode()`
Overrides:
`hashCode` in class `Object`
• #### equals

`public boolean equals(Object obj)`
Overrides:
`equals` in class `Object`