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

java.lang.Object
  org.apache.commons.math.linear.SparseFieldVector<T>

Type Parameters:

T - the type of the field elements

All Implemented Interfaces:

Serializable, FieldVector<T>

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

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

Since:

2.0

Version:

$Revision: 983921 $ $Date: 2010-08-10 12:46:06 +0200 (mar. 10 août 2010) $

See Also:

Serialized Form

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.
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(Object obj)
T[]	getData() Returns vector entries as a T 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()
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

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

add

public FieldVector<T> add(SparseFieldVector<T> v)
                                           throws IllegalArgumentException

Optimized method to add sparse vectors.

Parameters:

v - vector to add

Returns:

The sum of this and v

Throws:

IllegalArgumentException - If the dimensions don't match

add

public FieldVector<T> add(T[] v)
                                           throws 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:

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

IllegalArgumentException - if v is not the same size as this

dotProduct

public T dotProduct(T[] v)
                                     throws 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:

IllegalArgumentException - if v is not the same size as this

ebeDivide

public FieldVector<T> ebeDivide(FieldVector<T> v)
                                                 throws 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:

IllegalArgumentException - if v is not the same size as this

ebeDivide

public FieldVector<T> ebeDivide(T[] v)
                                                 throws 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:

IllegalArgumentException - if v is not the same size as this

ebeMultiply

public FieldVector<T> ebeMultiply(FieldVector<T> v)
                                                   throws 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:

IllegalArgumentException - if v is not the same size as this

ebeMultiply

public FieldVector<T> ebeMultiply(T[] v)
                                                   throws 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:

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

IllegalArgumentException - if v is not the same size as this

outerProduct

public FieldMatrix<T> outerProduct(T[] v)
                                                    throws 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:

IllegalArgumentException - if v is not the same size as this

outerProduct

public FieldMatrix<T> outerProduct(FieldVector<T> v)
                                                    throws 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:

IllegalArgumentException - if v is not the same size as this

projection

public FieldVector<T> projection(FieldVector<T> v)
                                                  throws 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:

IllegalArgumentException - if v is not the same size as this

projection

public FieldVector<T> projection(T[] v)
                                                  throws 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:

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 IllegalArgumentException

Optimized method to subtract SparseRealVectors.

Parameters:

v - The vector to subtract from this

Returns:

The difference of this and v

Throws:

IllegalArgumentException - If the dimensions don't match

subtract

public FieldVector<T> subtract(FieldVector<T> v)
                                                throws 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:

IllegalArgumentException - if v is not the same size as this

subtract

public FieldVector<T> subtract(T[] v)
                                                throws 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:

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

checkVectorDimensions

protected void checkVectorDimensions(int n)
                              throws IllegalArgumentException

Check if instance dimension is equal to some expected value.

Parameters:

n - expected dimension.

Throws:

IllegalArgumentException - if the dimension is inconsistent with vector size

add

public FieldVector<T> add(FieldVector<T> v)
                                           throws 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:

IllegalArgumentException - if v is not the same size as this

hashCode

public int hashCode()

Overrides:

hashCode in class Object

equals

public boolean equals(Object obj)

Overrides:

equals in class Object