FieldVector (Apache Commons Math 3.6.1 API)

Type Parameters:
T - the type of the field elements

All Known Implementing Classes:

ArrayFieldVector, SparseFieldVector
```
public interface FieldVector<T extends FieldElement<T>>
```
Interface defining a field-valued vector with basic algebraic operations.
vector element indexing is 0-based -- e.g., getEntry(0) returns the first element of the vector.

The various mapXxx and mapXxxToSelf methods operate on vectors element-wise, i.e. they perform the same operation (adding a scalar, applying a function ...) on each element in turn. The mapXxx versions create a new vector to hold the result and do not change the instance. The mapXxxToSelf versions use the instance itself to store the results, so the instance is changed by these methods. In both cases, the result vector is returned by the methods, this allows to use the fluent API style, like this:
```
   RealVector result = v.mapAddToSelf(3.0).mapTanToSelf().mapSquareToSelf();
 
```
Note that as almost all operations on FieldElement throw NullArgumentException when operating on a null element, it is the responsibility of FieldVector implementations to make sure no null elements are inserted into the vector. This must be done in all constructors and all setters.
Since:

2.0

Method Summary

Methods
Modifier and Type	Method and Description
`FieldVector<T>`	`add(FieldVector<T> v)` Compute the sum of `this` and `v`.
`FieldVector<T>`	`append(FieldVector<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.
`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.
`T[]`	`getData()` Deprecated. as of 3.1, to be removed in 4.0. Please use the `toArray()` method instead.
`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.
`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.
`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`.
`T[]`	`toArray()` Convert the vector to a T array.

- Method Detail
  - getField
```
Field<T> getField()
```
    Get the type of field elements of the vector.
    
    Returns:
    type of field elements of the vector
  - copy
```
FieldVector<T> copy()
```
    Returns a (deep) copy of this.
    
    Returns:
    vector copy
  - add
```
FieldVector<T> add(FieldVector<T> v)
                                           throws DimensionMismatchException
```
    Compute the sum of this and v.
    
    Parameters:
    v - vector to be added
    
    Returns:
    this + v
    
    Throws:
    
    DimensionMismatchException - if v is not the same size as this
  - subtract
```
FieldVector<T> subtract(FieldVector<T> v)
                                                throws DimensionMismatchException
```
    Compute this minus v.
    
    Parameters:
    v - vector to be subtracted
    
    Returns:
    this - v
    
    Throws:
    
    DimensionMismatchException - if v is not the same size as this
  - mapAdd
```
FieldVector<T> mapAdd(T d)
                                              throws NullArgumentException
```
    Map an addition operation to each entry.
    
    Parameters:
    d - value to be added to each entry
    
    Returns:
    this + d
    
    Throws:
    
    NullArgumentException - if d is null.
  - mapAddToSelf
```
FieldVector<T> mapAddToSelf(T d)
                                                    throws NullArgumentException
```
    Map an addition operation to each entry.
    The instance is changed by this method.
    
    Parameters:
    d - value to be added to each entry
    
    Returns:
    for convenience, return this
    
    Throws:
    
    NullArgumentException - if d is null.
  - mapSubtract
```
FieldVector<T> mapSubtract(T d)
                                                   throws NullArgumentException
```
    Map a subtraction operation to each entry.
    
    Parameters:
    d - value to be subtracted to each entry
    
    Returns:
    this - d
    
    Throws:
    
    NullArgumentException - if d is null
  - mapSubtractToSelf
```
FieldVector<T> mapSubtractToSelf(T d)
                                                         throws NullArgumentException
```
    Map a subtraction operation to each entry.
    The instance is changed by this method.
    
    Parameters:
    d - value to be subtracted to each entry
    
    Returns:
    for convenience, return this
    
    Throws:
    
    NullArgumentException - if d is null
  - mapMultiply
```
FieldVector<T> mapMultiply(T d)
                                                   throws NullArgumentException
```
    Map a multiplication operation to each entry.
    
    Parameters:
    d - value to multiply all entries by
    
    Returns:
    this * d
    
    Throws:
    
    NullArgumentException - if d is null.
  - mapMultiplyToSelf
```
FieldVector<T> mapMultiplyToSelf(T d)
                                                         throws NullArgumentException
```
    Map a multiplication operation to each entry.
    The instance is changed by this method.
    
    Parameters:
    d - value to multiply all entries by
    
    Returns:
    for convenience, return this
    
    Throws:
    
    NullArgumentException - if d is null.
  - mapDivide
```
FieldVector<T> mapDivide(T d)
                                                 throws NullArgumentException,
                                                        MathArithmeticException
```
    Map a division operation to each entry.
    
    Parameters:
    d - value to divide all entries by
    
    Returns:
    this / d
    
    Throws:
    
    NullArgumentException - if d is null.
    
    MathArithmeticException - if d is zero.
  - mapDivideToSelf
```
FieldVector<T> mapDivideToSelf(T d)
                                                       throws NullArgumentException,
                                                              MathArithmeticException
```
    Map a division operation to each entry.
    The instance is changed by this method.
    
    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
```
FieldVector<T> mapInv()
                                              throws MathArithmeticException
```
    Map the 1/x function to each entry.
    
    Returns:
    a vector containing the result of applying the function to each entry.
    
    Throws:
    
    MathArithmeticException - if one of the entries is zero.
  - mapInvToSelf
```
FieldVector<T> mapInvToSelf()
                                                    throws MathArithmeticException
```
    Map the 1/x function to each entry.
    The instance is changed by this method.
    
    Returns:
    for convenience, return this
    
    Throws:
    
    MathArithmeticException - if one of the entries is zero.
  - ebeMultiply
```
FieldVector<T> ebeMultiply(FieldVector<T> v)
                                                   throws DimensionMismatchException
```
    Element-by-element multiplication.
    
    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
  - ebeDivide
```
FieldVector<T> ebeDivide(FieldVector<T> v)
                                                 throws DimensionMismatchException,
                                                        MathArithmeticException
```
    Element-by-element division.
    
    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.
  - getData
```
@Deprecated
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.
    
    Returns:
    T array of entries
  - dotProduct
```
T dotProduct(FieldVector<T> v)
                                     throws DimensionMismatchException
```
    Compute the dot product.
    
    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
  - projection
```
FieldVector<T> projection(FieldVector<T> v)
                                                  throws DimensionMismatchException,
                                                         MathArithmeticException
```
    Find the orthogonal projection of this vector onto another vector.
    
    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.
  - outerProduct
```
FieldMatrix<T> outerProduct(FieldVector<T> v)
```
    Compute the outer product.
    
    Parameters:
    v - vector with which outer product should be computed
    
    Returns:
    the matrix outer product between instance and v
  - getEntry
```
T getEntry(int index)
                                   throws OutOfRangeException
```
    Returns the entry in the specified index.
    
    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:
    setEntry(int, FieldElement)
  - setEntry
```
void setEntry(int index,
            T value)
              throws OutOfRangeException
```
    Set a single element.
    
    Parameters:
    index - element index.
    value - new value for the element.
    
    Throws:
    
    OutOfRangeException - if the index is not valid.
    See Also:
    getEntry(int)
  - getDimension
```
int getDimension()
```
    Returns the size of the vector.
    
    Returns:
    size
  - append
```
FieldVector<T> append(FieldVector<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
```
FieldVector<T> append(T d)
```
    Construct a vector by appending a T to this vector.
    
    Parameters:
    d - T to append.
    
    Returns:
    a new vector
  - getSubVector
```
FieldVector<T> getSubVector(int index,
                          int n)
                                                    throws OutOfRangeException,
                                                           NotPositiveException
```
    Get a subvector from consecutive elements.
    
    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.
  - setSubVector
```
void setSubVector(int index,
                FieldVector<T> v)
                  throws OutOfRangeException
```
    Set a set of consecutive elements.
    
    Parameters:
    index - index of first element to be set.
    v - vector containing the values to set.
    
    Throws:
    
    OutOfRangeException - if the index is not valid.
  - set
```
void set(T value)
```
    Set all elements to a single value.
    
    Parameters:
    value - single value to set for all elements
  - toArray
```
T[] toArray()
```
    Convert the vector to a T array.
    The array is independent from vector data, it's elements are copied.
    
    Returns:
    array containing a copy of vector elements

Interface FieldVector<T extends FieldElement<T>>

Method Summary

Method Detail

getField

copy

add

subtract

mapAdd

mapAddToSelf

mapSubtract

mapSubtractToSelf

mapMultiply

mapMultiplyToSelf

mapDivide

mapDivideToSelf

mapInv

mapInvToSelf

ebeMultiply

ebeDivide

getData

dotProduct

projection

outerProduct

getEntry

setEntry

getDimension

append

append

getSubVector

setSubVector

set

toArray