org.apache.commons.math3.linear

## Interface FieldVector<T extends FieldElement<T>>

- 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
  Version:
    $Id: FieldVector.java 1455233 2013-03-11 17:00:41Z luc $

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

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