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();
 

Since:
2.0
Version:
$Id: FieldVector.java 1416643 2012-12-03 19:37:14Z tn $

Method Summary
 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-2013 The Apache Software Foundation. All Rights Reserved.