org.apache.commons.math3.linear

## Class ArrayFieldVector<T extends FieldElement<T>>

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

- Type Parameters:
    `T` - the type of the field elements
  All Implemented Interfaces:
    Serializable, FieldVector<T>

      public class ArrayFieldVector<T extends FieldElement<T>>
      extends Object
      implements FieldVector<T>, Serializable

  This class implements the `FieldVector` interface with a `FieldElement` array.
  Since:
    2.0
  Version:
    $Id: ArrayFieldVector.java 1570536 2014-02-21 11:26:09Z luc $
  See Also:
    Serialized Form

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `ArrayFieldVector(ArrayFieldVector<T> v)` Construct a vector from another vector, using a deep copy.
    `ArrayFieldVector(ArrayFieldVector<T> v1, ArrayFieldVector<T> v2)` Deprecated. as of 3.2, replaced by `ArrayFieldVector(FieldVector, FieldVector)`
    `ArrayFieldVector(ArrayFieldVector<T> v, boolean deep)` Construct a vector from another vector.
    `ArrayFieldVector(ArrayFieldVector<T> v1, T[] v2)` Deprecated. as of 3.2, replaced by `ArrayFieldVector(FieldVector, FieldElement[])`
    `ArrayFieldVector(Field<T> field)` Build a 0-length vector.
    `ArrayFieldVector(Field<T> field, int size)` Construct a vector of zeroes.
    `ArrayFieldVector(Field<T> field, T[] d)` Construct a vector from an array, copying the input array.
    `ArrayFieldVector(Field<T> field, T[] d, boolean copyArray)` Create a new ArrayFieldVector using the input array as the underlying data array.
    `ArrayFieldVector(Field<T> field, T[] d, int pos, int size)` Construct a vector from part of a array.
    `ArrayFieldVector(Field<T> field, T[] v1, T[] v2)` Construct a vector by appending one vector to another vector.
    `ArrayFieldVector(FieldVector<T> v)` Construct a vector from another vector, using a deep copy.
    `ArrayFieldVector(FieldVector<T> v1, FieldVector<T> v2)` Construct a vector by appending one vector to another vector.
    `ArrayFieldVector(FieldVector<T> v1, T[] v2)` Construct a vector by appending one vector to another vector.
    `ArrayFieldVector(int size, T preset)` Construct a vector with preset values.
    `ArrayFieldVector(T[] d)` Construct a vector from an array, copying the input array.
    `ArrayFieldVector(T[] v1, ArrayFieldVector<T> v2)` Deprecated. as of 3.2, replaced by `ArrayFieldVector(FieldElement[], FieldVector)`
    `ArrayFieldVector(T[] d, boolean copyArray)` Create a new ArrayFieldVector using the input array as the underlying data array.
    `ArrayFieldVector(T[] v1, FieldVector<T> v2)` Construct a vector by appending one vector to another vector.
    `ArrayFieldVector(T[] d, int pos, int size)` Construct a vector from part of a array.
    `ArrayFieldVector(T[] v1, T[] v2)` Construct a vector by appending one vector to another vector.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `ArrayFieldVector<T>` | `add(ArrayFieldVector<T> v)` Compute the sum of `this` and `v`.
    `FieldVector<T>` | `add(FieldVector<T> v)` Compute the sum of `this` and `v`.
    `ArrayFieldVector<T>` | `append(ArrayFieldVector<T> v)` Construct a vector by appending a vector to this vector.
    `FieldVector<T>` | `append(FieldVector<T> v)` Construct a vector by appending a vector to this vector.
    `FieldVector<T>` | `append(T in)` Construct a vector by appending a T to this vector.
    `protected void` | `checkVectorDimensions(FieldVector<T> v)` Check if instance and specified vectors have the same dimension.
    `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(ArrayFieldVector<T> v)` Compute the dot product.
    `T` | `dotProduct(FieldVector<T> v)` Compute the dot product.
    `ArrayFieldVector<T>` | `ebeDivide(ArrayFieldVector<T> v)` Element-by-element division.
    `FieldVector<T>` | `ebeDivide(FieldVector<T> v)` Element-by-element division.
    `ArrayFieldVector<T>` | `ebeMultiply(ArrayFieldVector<T> v)` Element-by-element multiplication.
    `FieldVector<T>` | `ebeMultiply(FieldVector<T> v)` Element-by-element multiplication.
    `boolean` | `equals(Object other)` Test for the equality of two vectors.
    `T[]` | `getData()` Returns vector entries as a T array.
    `T[]` | `getDataRef()` Returns a reference to the underlying data 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()` Get a hashCode for the real vector.
    `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(ArrayFieldVector<T> v)` Compute the outer product.
    `FieldMatrix<T>` | `outerProduct(FieldVector<T> v)` Compute the outer product.
    `ArrayFieldVector<T>` | `projection(ArrayFieldVector<T> v)` Find the orthogonal projection of this vector onto another vector.
    `FieldVector<T>` | `projection(FieldVector<T> v)` Find the orthogonal projection of this vector onto another vector.
    `void` | `set(int index, ArrayFieldVector<T> v)` Set a set of consecutive elements.
    `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.
    `ArrayFieldVector<T>` | `subtract(ArrayFieldVector<T> v)` Compute `this` minus `v`.
    `FieldVector<T>` | `subtract(FieldVector<T> v)` 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 Detail

    - #### ArrayFieldVector

          public ArrayFieldVector(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 `ArrayFieldVector(ArrayFieldVector, ArrayFieldVector)` constructor or one of the `append` methods (`add(FieldVector)` or `append(ArrayFieldVector)`) to gather data into this vector.
      Parameters:
        `field` - field to which the elements belong

    - #### ArrayFieldVector

          public ArrayFieldVector(Field<T> field,
                          int size)

      Construct a vector of zeroes.
      Parameters:
        `field` - Field to which the elements belong.
        `size` - Size of the vector.

    - #### ArrayFieldVector

          public ArrayFieldVector(int size,
                          T preset)

      Construct a vector with preset values.
      Parameters:
        `size` - Size of the vector.
        `preset` - All entries will be set with this value.

    - #### ArrayFieldVector

          public ArrayFieldVector(T[] d)
                           throws NullArgumentException,
                                  ZeroException

      Construct a vector from an array, copying the input array. This constructor needs a non-empty `d` array to retrieve the field from its first element. This implies it cannot build 0 length vectors. To build vectors from any size, one should use the `ArrayFieldVector(Field, FieldElement[])` constructor.
      Parameters:
        `d` - Array.
      Throws:
        `NullArgumentException` - if `d` is `null`.
        `ZeroException` - if `d` is empty.
      See Also:
        `ArrayFieldVector(Field, FieldElement[])`

    - #### ArrayFieldVector

          public ArrayFieldVector(Field<T> field,
                          T[] d)
                           throws NullArgumentException

      Construct a vector from an array, copying the input array.
      Parameters:
        `field` - Field to which the elements belong.
        `d` - Array.
      Throws:
        `NullArgumentException` - if `d` is `null`.
      See Also:
        `ArrayFieldVector(FieldElement[])`

    - #### ArrayFieldVector

          public ArrayFieldVector(T[] d,
                          boolean copyArray)
                           throws NullArgumentException,
                                  ZeroException

      Create a new ArrayFieldVector using the input array as the underlying data array. If an array is built specially in order to be embedded in a ArrayFieldVector and not used directly, the `copyArray` may be set to `false`. This will prevent the copying and improve performance as no new array will be built and no data will be copied. This constructor needs a non-empty `d` array to retrieve the field from its first element. This implies it cannot build 0 length vectors. To build vectors from any size, one should use the `ArrayFieldVector(Field, FieldElement[], boolean)` constructor.
      Parameters:
        `d` - Data for the new vector.
        `copyArray` - If `true`, the input array will be copied, otherwise it will be referenced.
      Throws:
        `NullArgumentException` - if `d` is `null`.
        `ZeroException` - if `d` is empty.
      See Also:
        `ArrayFieldVector(FieldElement[])`, `ArrayFieldVector(Field, FieldElement[], boolean)`

    - #### ArrayFieldVector

          public ArrayFieldVector(Field<T> field,
                          T[] d,
                          boolean copyArray)
                           throws NullArgumentException

      Create a new ArrayFieldVector using the input array as the underlying data array. If an array is built specially in order to be embedded in a ArrayFieldVector and not used directly, the `copyArray` may be set to `false`. This will prevent the copying and improve performance as no new array will be built and no data will be copied.
      Parameters:
        `field` - Field to which the elements belong.
        `d` - Data for the new vector.
        `copyArray` - If `true`, the input array will be copied, otherwise it will be referenced.
      Throws:
        `NullArgumentException` - if `d` is `null`.
      See Also:
        `ArrayFieldVector(FieldElement[], boolean)`

    - #### ArrayFieldVector

          public ArrayFieldVector(T[] d,
                          int pos,
                          int size)
                           throws NullArgumentException,
                                  NumberIsTooLargeException

      Construct a vector from part of a array.
      Parameters:
        `d` - Array.
        `pos` - Position of the first entry.
        `size` - Number of entries to copy.
      Throws:
        `NullArgumentException` - if `d` is `null`.
        `NumberIsTooLargeException` - if the size of `d` is less than `pos + size`.

    - #### ArrayFieldVector

          public ArrayFieldVector(Field<T> field,
                          T[] d,
                          int pos,
                          int size)
                           throws NullArgumentException,
                                  NumberIsTooLargeException

      Construct a vector from part of a array.
      Parameters:
        `field` - Field to which the elements belong.
        `d` - Array.
        `pos` - Position of the first entry.
        `size` - Number of entries to copy.
      Throws:
        `NullArgumentException` - if `d` is `null`.
        `NumberIsTooLargeException` - if the size of `d` is less than `pos + size`.

    - #### ArrayFieldVector

          public ArrayFieldVector(FieldVector<T> v)
                           throws NullArgumentException

      Construct a vector from another vector, using a deep copy.
      Parameters:
        `v` - Vector to copy.
      Throws:
        `NullArgumentException` - if `v` is `null`.

    - #### ArrayFieldVector

          public ArrayFieldVector(ArrayFieldVector<T> v)
                           throws NullArgumentException

      Construct a vector from another vector, using a deep copy.
      Parameters:
        `v` - Vector to copy.
      Throws:
        `NullArgumentException` - if `v` is `null`.

    - #### ArrayFieldVector

          public ArrayFieldVector(ArrayFieldVector<T> v,
                          boolean deep)
                           throws NullArgumentException

      Construct a vector from another vector.
      Parameters:
        `v` - Vector to copy.
        `deep` - If `true` perform a deep copy, otherwise perform a shallow copy
      Throws:
        `NullArgumentException` - if `v` is `null`.

    - #### ArrayFieldVector

          @Deprecated
          public ArrayFieldVector(ArrayFieldVector<T> v1,
                                     ArrayFieldVector<T> v2)
                           throws NullArgumentException

      Deprecated. as of 3.2, replaced by `ArrayFieldVector(FieldVector, FieldVector)`
      Construct a vector by appending one vector to another vector.
      Parameters:
        `v1` - First vector (will be put in front of the new vector).
        `v2` - Second vector (will be put at back of the new vector).
      Throws:
        `NullArgumentException` - if `v1` or `v2` is `null`.

    - #### ArrayFieldVector

          public ArrayFieldVector(FieldVector<T> v1,
                          FieldVector<T> v2)
                           throws NullArgumentException

      Construct a vector by appending one vector to another vector.
      Parameters:
        `v1` - First vector (will be put in front of the new vector).
        `v2` - Second vector (will be put at back of the new vector).
      Throws:
        `NullArgumentException` - if `v1` or `v2` is `null`.
      Since:
        3.2

    - #### ArrayFieldVector

          @Deprecated
          public ArrayFieldVector(ArrayFieldVector<T> v1,
                                     T[] v2)
                           throws NullArgumentException

      Deprecated. as of 3.2, replaced by `ArrayFieldVector(FieldVector, FieldElement[])`
      Construct a vector by appending one vector to another vector.
      Parameters:
        `v1` - First vector (will be put in front of the new vector).
        `v2` - Second vector (will be put at back of the new vector).
      Throws:
        `NullArgumentException` - if `v1` or `v2` is `null`.

    - #### ArrayFieldVector

          public ArrayFieldVector(FieldVector<T> v1,
                          T[] v2)
                           throws NullArgumentException

      Construct a vector by appending one vector to another vector.
      Parameters:
        `v1` - First vector (will be put in front of the new vector).
        `v2` - Second vector (will be put at back of the new vector).
      Throws:
        `NullArgumentException` - if `v1` or `v2` is `null`.
      Since:
        3.2

    - #### ArrayFieldVector

          @Deprecated
          public ArrayFieldVector(T[] v1,
                                     ArrayFieldVector<T> v2)
                           throws NullArgumentException

      Deprecated. as of 3.2, replaced by `ArrayFieldVector(FieldElement[], FieldVector)`
      Construct a vector by appending one vector to another vector.
      Parameters:
        `v1` - First vector (will be put in front of the new vector).
        `v2` - Second vector (will be put at back of the new vector).
      Throws:
        `NullArgumentException` - if `v1` or `v2` is `null`.

    - #### ArrayFieldVector

          public ArrayFieldVector(T[] v1,
                          FieldVector<T> v2)
                           throws NullArgumentException

      Construct a vector by appending one vector to another vector.
      Parameters:
        `v1` - First vector (will be put in front of the new vector).
        `v2` - Second vector (will be put at back of the new vector).
      Throws:
        `NullArgumentException` - if `v1` or `v2` is `null`.
      Since:
        3.2

    - #### ArrayFieldVector

          public ArrayFieldVector(T[] v1,
                          T[] v2)
                           throws NullArgumentException,
                                  ZeroException

      Construct a vector by appending one vector to another vector. This constructor needs at least one non-empty array to retrieve the field from its first element. This implies it cannot build 0 length vectors. To build vectors from any size, one should use the `ArrayFieldVector(Field, FieldElement[], FieldElement[])` constructor.
      Parameters:
        `v1` - First vector (will be put in front of the new vector).
        `v2` - Second vector (will be put at back of the new vector).
      Throws:
        `NullArgumentException` - if `v1` or `v2` is `null`.
        `ZeroException` - if both arrays are empty.
      See Also:
        `ArrayFieldVector(Field, FieldElement[], FieldElement[])`

    - #### ArrayFieldVector

          public ArrayFieldVector(Field<T> field,
                          T[] v1,
                          T[] v2)
                           throws NullArgumentException,
                                  ZeroException

      Construct a vector by appending one vector to another vector.
      Parameters:
        `field` - Field to which the elements belong.
        `v1` - First vector (will be put in front of the new vector).
        `v2` - Second vector (will be put at back of the new vector).
      Throws:
        `NullArgumentException` - if `v1` or `v2` is `null`.
        `ZeroException` - if both arrays are empty.
      See Also:
        `ArrayFieldVector(FieldElement[], FieldElement[])`

  - ### Method Detail

    - #### 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

    - #### copy

          public FieldVector<T> copy()

      Returns a (deep) copy of this.
      Specified by:
        `copy` in interface `FieldVector<T extends FieldElement<T>>`
      Returns:
        vector copy

    - #### 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`

    - #### add

          public ArrayFieldVector<T> add(ArrayFieldVector<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

          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`

    - #### subtract

          public ArrayFieldVector<T> subtract(ArrayFieldVector<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

          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`.

    - #### 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`

    - #### 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`.

    - #### 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.

    - #### 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`

    - #### ebeMultiply

          public ArrayFieldVector<T> ebeMultiply(ArrayFieldVector<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

          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.

    - #### ebeDivide

          public ArrayFieldVector<T> ebeDivide(ArrayFieldVector<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

          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

    - #### getDataRef

          public T[] getDataRef()

      Returns a reference to the underlying data array.

      Does not make a fresh copy of the underlying data.

      Returns:
        array of entries

    - #### 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`

    - #### dotProduct

          public T dotProduct(ArrayFieldVector<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

          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.

    - #### projection

          public ArrayFieldVector<T> projection(ArrayFieldVector<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

          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

    - #### outerProduct

          public FieldMatrix<T> outerProduct(ArrayFieldVector<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

          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`.
      See Also:
        `FieldVector.setEntry(int, FieldElement)`

    - #### getDimension

          public int getDimension()

      Returns the size of the vector.
      Specified by:
        `getDimension` in interface `FieldVector<T extends FieldElement<T>>`
      Returns:
        size

    - #### 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 ArrayFieldVector<T> append(ArrayFieldVector<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(T in)

      Construct a vector by appending a T to this vector.
      Specified by:
        `append` in interface `FieldVector<T extends FieldElement<T>>`
      Parameters:
        `in` - T to append.
      Returns:
        a new 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.

    - #### 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.
      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.

    - #### set

          public void set(int index,
                 ArrayFieldVector<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 invalid.

    - #### 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

    - #### 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(FieldVector<T> v)
                                        throws DimensionMismatchException

      Check if instance and specified vectors have the same dimension.
      Parameters:
        `v` - vector to compare instance with
      Throws:
        `DimensionMismatchException` - if the vectors do not have the same dimensions

    - #### 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 dimension is not equal to the size of `this` vector.

    - #### 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

    - #### equals

          public boolean equals(Object other)

      Test for the equality of two vectors.
      Overrides:
        `equals` in class `Object`
      Parameters:
        `other` - Object to test for equality.
      Returns:
        `true` if two vector objects are equal, `false` otherwise.

    - #### hashCode

          public int hashCode()

      Get a hashCode for the real vector.

      All NaN values have the same hash code.

      Overrides:
        `hashCode` in class `Object`
      Returns:
        a hash code value for this object

Copyright © 2003–2014 The Apache Software Foundation. All rights reserved.