Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## 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 1416643 2012-12-03 19:37:14Z tn $
See Also:
  Serialized Form

Constructor Summary
`ArrayFieldVector(ArrayFieldVector<T> v)` Construct a vector from another vector, using a deep copy.
`ArrayFieldVector(ArrayFieldVector<T> v1, ArrayFieldVector<T> v2)` Construct a vector by appending one vector to another vector.
`ArrayFieldVector(ArrayFieldVector<T> v, boolean deep)` Construct a vector from another vector.
`ArrayFieldVector(ArrayFieldVector<T> v1, T[] v2)` Construct a vector by appending one vector to another vector.
`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(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)` Construct a vector by appending one vector to another vector.
`ArrayFieldVector(T[] d, boolean copyArray)` Create a new ArrayFieldVector using the input array as the underlying data array.
`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
`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.

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

    public ArrayFieldVector(ArrayFieldVector<T> v1,
                            ArrayFieldVector<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`.

### ArrayFieldVector

    public ArrayFieldVector(ArrayFieldVector<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`.

### ArrayFieldVector

    public ArrayFieldVector(T[] v1,
                            ArrayFieldVector<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`.

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

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

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2003-2013 The Apache Software Foundation. All Rights Reserved.