org.apache.commons.math.linear
Class SparseFieldVector<T extends FieldElement<T>>

java.lang.Object
  extended by org.apache.commons.math.linear.SparseFieldVector<T>
Type Parameters:
T - the type of the field elements
All Implemented Interfaces:
java.io.Serializable, FieldVector<T>

public class SparseFieldVector<T extends FieldElement<T>>
extends java.lang.Object
implements FieldVector<T>, java.io.Serializable

This class implements the FieldVector interface with a OpenIntToFieldHashMap backing store.

Since:
2.0
Version:
$Revision: 922714 $ $Date: 2010-03-13 20:35:14 -0500 (Sat, 13 Mar 2010) $
See Also:
Serialized Form

Field Summary
private  OpenIntToFieldHashMap<T> entries
          Entries of the vector.
private  Field<T> field
          Field to which the elements belong.
private static long serialVersionUID
          Serial version id
private  int virtualSize
          Dimension of the vector.
 
Constructor Summary
  SparseFieldVector(Field<T> field)
          Build a 0-length vector.
  SparseFieldVector(Field<T> field, int dimension)
          Construct a (dimension)-length vector of zeros.
  SparseFieldVector(Field<T> field, int dimension, int expectedSize)
          Build a vector with known the sparseness (for advanced use only).
  SparseFieldVector(Field<T> field, T[] values)
          Create from a Field array.
  SparseFieldVector(SparseFieldVector<T> v)
          Copy constructor.
protected SparseFieldVector(SparseFieldVector<T> v, int resize)
          Build a resized vector, for use with append.
 
Method Summary
 FieldVector<T> add(FieldVector<T> v)
          Compute the sum of this and v.
 FieldVector<T> add(SparseFieldVector<T> v)
          Optimized method to add sparse vectors.
 FieldVector<T> add(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(SparseFieldVector<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> append(T[] a)
          Construct a vector by appending a T array to this vector.
private  T[] buildArray(int length)
          Build an array of elements.
private  void checkIndex(int index)
          Check if an index is valid.
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(FieldVector<T> v)
          Compute the dot product.
 T dotProduct(T[] v)
          Compute the dot product.
 FieldVector<T> ebeDivide(FieldVector<T> v)
          Element-by-element division.
 FieldVector<T> ebeDivide(T[] v)
          Element-by-element division.
 FieldVector<T> ebeMultiply(FieldVector<T> v)
          Element-by-element multiplication.
 FieldVector<T> ebeMultiply(T[] v)
          Element-by-element multiplication.
 boolean equals(java.lang.Object obj)
          
 T[] getData()
          Returns vector entries as a T array.
 int getDimension()
          Returns the size of the vector.
private  OpenIntToFieldHashMap<T> getEntries()
          Get the entries of this instance.
 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()
          
 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.
 FieldMatrix<T> outerProduct(SparseFieldVector<T> v)
          Optimized method to compute outer product when both vectors are sparse.
 FieldMatrix<T> outerProduct(T[] v)
          Compute the outer product.
 FieldVector<T> projection(FieldVector<T> v)
          Find the orthogonal projection of this vector onto another vector.
 FieldVector<T> projection(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.
 void setSubVector(int index, T[] v)
          Set a set of consecutive elements.
 FieldVector<T> subtract(FieldVector<T> v)
          Compute this minus v.
 SparseFieldVector<T> subtract(SparseFieldVector<T> v)
          Optimized method to subtract SparseRealVectors.
 FieldVector<T> subtract(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
 

Field Detail

serialVersionUID

private static final long serialVersionUID
Serial version id

See Also:
Constant Field Values

field

private final Field<T extends FieldElement<T>> field
Field to which the elements belong.


entries

private final OpenIntToFieldHashMap<T extends FieldElement<T>> entries
Entries of the vector.


virtualSize

private final int virtualSize
Dimension of the vector.

Constructor Detail

SparseFieldVector

public SparseFieldVector(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 SparseFieldVector(SparseFieldVector, int) constructor or one of the append method (append(FieldElement), append(FieldElement[]), append(FieldVector), append(SparseFieldVector)) to gather data into this vector.

Parameters:
field - field to which the elements belong

SparseFieldVector

public SparseFieldVector(Field<T> field,
                         int dimension)
Construct a (dimension)-length vector of zeros.

Parameters:
field - field to which the elements belong
dimension - Size of the vector

SparseFieldVector

protected SparseFieldVector(SparseFieldVector<T> v,
                            int resize)
Build a resized vector, for use with append.

Parameters:
v - The original vector
resize - The amount to resize it

SparseFieldVector

public SparseFieldVector(Field<T> field,
                         int dimension,
                         int expectedSize)
Build a vector with known the sparseness (for advanced use only).

Parameters:
field - field to which the elements belong
dimension - The size of the vector
expectedSize - The expected number of non-zero entries

SparseFieldVector

public SparseFieldVector(Field<T> field,
                         T[] values)
Create from a Field array. Only non-zero entries will be stored

Parameters:
field - field to which the elements belong
values - The set of values to create from

SparseFieldVector

public SparseFieldVector(SparseFieldVector<T> v)
Copy constructor.

Parameters:
v - The instance to copy from
Method Detail

getEntries

private OpenIntToFieldHashMap<T> getEntries()
Get the entries of this instance.

Returns:
entries of this instance

add

public FieldVector<T> add(SparseFieldVector<T> v)
                                           throws java.lang.IllegalArgumentException
Optimized method to add sparse vectors.

Parameters:
v - vector to add
Returns:
The sum of this and v
Throws:
java.lang.IllegalArgumentException - If the dimensions don't match

add

public FieldVector<T> add(T[] v)
                                           throws java.lang.IllegalArgumentException
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:
java.lang.IllegalArgumentException - if v is not the same size as this

append

public FieldVector<T> append(SparseFieldVector<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(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 FieldVector<T> append(T d)
Construct a vector by appending a T to this vector.

Specified by:
append in interface FieldVector<T extends FieldElement<T>>
Parameters:
d - T to append.
Returns:
a new vector

append

public FieldVector<T> append(T[] a)
Construct a vector by appending a T array to this vector.

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

dotProduct

public T dotProduct(FieldVector<T> v)
                                     throws java.lang.IllegalArgumentException
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 between instance and v
Throws:
java.lang.IllegalArgumentException - if v is not the same size as this

dotProduct

public T dotProduct(T[] v)
                                     throws java.lang.IllegalArgumentException
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 between instance and v
Throws:
java.lang.IllegalArgumentException - if v is not the same size as this

ebeDivide

public FieldVector<T> ebeDivide(FieldVector<T> v)
                                                 throws java.lang.IllegalArgumentException
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:
java.lang.IllegalArgumentException - if v is not the same size as this

ebeDivide

public FieldVector<T> ebeDivide(T[] v)
                                                 throws java.lang.IllegalArgumentException
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:
java.lang.IllegalArgumentException - if v is not the same size as this

ebeMultiply

public FieldVector<T> ebeMultiply(FieldVector<T> v)
                                                   throws java.lang.IllegalArgumentException
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:
java.lang.IllegalArgumentException - if v is not the same size as this

ebeMultiply

public FieldVector<T> ebeMultiply(T[] v)
                                                   throws java.lang.IllegalArgumentException
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:
java.lang.IllegalArgumentException - if v is not the same size as this

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

getDimension

public int getDimension()
Returns the size of the vector.

Specified by:
getDimension in interface FieldVector<T extends FieldElement<T>>
Returns:
size

getEntry

public T getEntry(int index)
                                   throws MatrixIndexException
Returns the entry in the specified index.

The index start at 0 and must be lesser than the size, otherwise a MatrixIndexException is thrown.

Specified by:
getEntry in interface FieldVector<T extends FieldElement<T>>
Parameters:
index - index location of entry to be fetched
Returns:
vector entry at index
Throws:
MatrixIndexException - if the index is not valid
See Also:
FieldVector.setEntry(int, FieldElement)

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

getSubVector

public FieldVector<T> getSubVector(int index,
                                   int n)
                                                    throws MatrixIndexException
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:
MatrixIndexException - if the index is inconsistent with vector size

mapAdd

public FieldVector<T> mapAdd(T d)
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

mapAddToSelf

public FieldVector<T> mapAddToSelf(T d)
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

mapDivide

public FieldVector<T> mapDivide(T d)
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

mapDivideToSelf

public FieldVector<T> mapDivideToSelf(T d)
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

mapInv

public FieldVector<T> mapInv()
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

mapInvToSelf

public FieldVector<T> mapInvToSelf()
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

mapMultiply

public FieldVector<T> mapMultiply(T d)
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

mapMultiplyToSelf

public FieldVector<T> mapMultiplyToSelf(T d)
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

mapSubtract

public FieldVector<T> mapSubtract(T d)
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

mapSubtractToSelf

public FieldVector<T> mapSubtractToSelf(T d)
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

outerProduct

public FieldMatrix<T> outerProduct(SparseFieldVector<T> v)
                                                    throws java.lang.IllegalArgumentException
Optimized method to compute outer product when both vectors are sparse.

Parameters:
v - vector with which outer product should be computed
Returns:
the square matrix outer product between instance and v
Throws:
java.lang.IllegalArgumentException - if v is not the same size as this

outerProduct

public FieldMatrix<T> outerProduct(T[] v)
                                                    throws java.lang.IllegalArgumentException
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 square matrix outer product between instance and v
Throws:
java.lang.IllegalArgumentException - if v is not the same size as this

outerProduct

public FieldMatrix<T> outerProduct(FieldVector<T> v)
                                                    throws java.lang.IllegalArgumentException
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 square matrix outer product between instance and v
Throws:
java.lang.IllegalArgumentException - if v is not the same size as this

projection

public FieldVector<T> projection(FieldVector<T> v)
                                                  throws java.lang.IllegalArgumentException
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 instance must be projected
Returns:
projection of the instance onto v
Throws:
java.lang.IllegalArgumentException - if v is not the same size as this

projection

public FieldVector<T> projection(T[] v)
                                                  throws java.lang.IllegalArgumentException
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 instance must be projected
Returns:
projection of the instance onto v
Throws:
java.lang.IllegalArgumentException - if v is not the same size as this

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

setEntry

public void setEntry(int index,
                     T value)
              throws MatrixIndexException
Set a single element.

Specified by:
setEntry in interface FieldVector<T extends FieldElement<T>>
Parameters:
index - element index.
value - new value for the element.
Throws:
MatrixIndexException - if the index is inconsistent with vector size
See Also:
FieldVector.getEntry(int)

setSubVector

public void setSubVector(int index,
                         FieldVector<T> v)
                  throws MatrixIndexException
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:
MatrixIndexException - if the index is inconsistent with vector size
See Also:
FieldVector.setSubVector(int, FieldElement[])

setSubVector

public void setSubVector(int index,
                         T[] v)
                  throws MatrixIndexException
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:
MatrixIndexException - if the index is inconsistent with vector size
See Also:
FieldVector.setSubVector(int, FieldVector)

subtract

public SparseFieldVector<T> subtract(SparseFieldVector<T> v)
                                                      throws java.lang.IllegalArgumentException
Optimized method to subtract SparseRealVectors.

Parameters:
v - The vector to subtract from this
Returns:
The difference of this and v
Throws:
java.lang.IllegalArgumentException - If the dimensions don't match

subtract

public FieldVector<T> subtract(FieldVector<T> v)
                                                throws java.lang.IllegalArgumentException
Compute this minus v.

Specified by:
subtract in interface FieldVector<T extends FieldElement<T>>
Parameters:
v - vector to be subtracted
Returns:
this + v
Throws:
java.lang.IllegalArgumentException - if v is not the same size as this

subtract

public FieldVector<T> subtract(T[] v)
                                                throws java.lang.IllegalArgumentException
Compute this minus v.

Specified by:
subtract in interface FieldVector<T extends FieldElement<T>>
Parameters:
v - vector to be subtracted
Returns:
this + v
Throws:
java.lang.IllegalArgumentException - if v is not the same size as this

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

checkIndex

private void checkIndex(int index)
                 throws MatrixIndexException
Check if an index is valid.

Parameters:
index - index to check
Throws:
MatrixIndexException - if index is not valid

checkVectorDimensions

protected void checkVectorDimensions(int n)
                              throws java.lang.IllegalArgumentException
Check if instance dimension is equal to some expected value.

Parameters:
n - expected dimension.
Throws:
java.lang.IllegalArgumentException - if the dimension is inconsistent with vector size

add

public FieldVector<T> add(FieldVector<T> v)
                                           throws java.lang.IllegalArgumentException
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:
java.lang.IllegalArgumentException - if v is not the same size as this

buildArray

private T[] buildArray(int length)
Build an array of elements.

Parameters:
length - size of the array to build
Returns:
a new array

hashCode

public int hashCode()

Overrides:
hashCode in class java.lang.Object

equals

public boolean equals(java.lang.Object obj)

Overrides:
equals in class java.lang.Object


Copyright (c) 2003-2010 Apache Software Foundation