org.apache.commons.math3.linear
Class OpenMapRealVector

java.lang.Object
  extended by org.apache.commons.math3.linear.RealVector
      extended by org.apache.commons.math3.linear.SparseRealVector
          extended by org.apache.commons.math3.linear.OpenMapRealVector
All Implemented Interfaces:
Serializable

public class OpenMapRealVector
extends SparseRealVector
implements Serializable

This class implements the RealVector interface with a OpenIntToDoubleHashMap backing store.

Since:
2.0
Version:
$Id: OpenMapRealVector.java 1244107 2012-02-14 16:17:55Z erans $
See Also:
Serialized Form

Nested Class Summary
protected  class OpenMapRealVector.OpenMapEntry
          Implementation of Entry optimized for OpenMap.
protected  class OpenMapRealVector.OpenMapSparseIterator
          Iterator class to do iteration over just the non-zero elements.
 
Nested classes/interfaces inherited from class org.apache.commons.math3.linear.RealVector
RealVector.Entry, RealVector.SparseEntryIterator
 
Field Summary
static double DEFAULT_ZERO_TOLERANCE
          Default Tolerance for having a value considered zero.
private  OpenIntToDoubleHashMap entries
          Entries of the vector.
private  double epsilon
          Tolerance for having a value considered zero.
private static long serialVersionUID
          Serializable version identifier.
private  int virtualSize
          Dimension of the vector.
 
Constructor Summary
  OpenMapRealVector()
          Build a 0-length vector.
  OpenMapRealVector(double[] values)
          Create from an array.
  OpenMapRealVector(Double[] values)
          Create from an array.
  OpenMapRealVector(double[] values, double epsilon)
          Create from an array, specifying zero tolerance.
  OpenMapRealVector(Double[] values, double epsilon)
          Create from an array.
  OpenMapRealVector(int dimension)
          Construct a vector of zeroes.
  OpenMapRealVector(int dimension, double epsilon)
          Construct a vector of zeroes, specifying zero tolerance.
  OpenMapRealVector(int dimension, int expectedSize)
          Build a vector with known the sparseness (for advanced use only).
  OpenMapRealVector(int dimension, int expectedSize, double epsilon)
          Build a vector with known the sparseness and zero tolerance setting (for advanced use only).
  OpenMapRealVector(OpenMapRealVector v)
          Copy constructor.
protected OpenMapRealVector(OpenMapRealVector v, int resize)
          Build a resized vector, for use with append.
  OpenMapRealVector(RealVector v)
          Generic copy constructor.
 
Method Summary
 OpenMapRealVector add(OpenMapRealVector v)
          Optimized method to add two OpenMapRealVectors.
 RealVector add(RealVector v)
          Compute the sum of this vector and v.
 OpenMapRealVector append(double d)
          Construct a new vector by appending a double to this vector.
 OpenMapRealVector append(OpenMapRealVector v)
          Optimized method to append a OpenMapRealVector.
 OpenMapRealVector append(RealVector v)
          Construct a new vector by appending a vector to this vector.
 OpenMapRealVector copy()
          Returns a (deep) copy of this vector.
 double dotProduct(OpenMapRealVector v)
          Optimized method to compute the dot product with an OpenMapRealVector.
 double dotProduct(RealVector v)
          Compute the dot product of this vector with v.
 OpenMapRealVector ebeDivide(RealVector v)
          Element-by-element division.
 OpenMapRealVector ebeMultiply(RealVector v)
          Element-by-element multiplication.
 boolean equals(Object obj)
           Implementation Note: This performs an exact comparison, and as a result it is possible for a.subtract(b} to be the zero vector, while a.equals(b) == false.
 int getDimension()
          Returns the size of the vector.
 double getDistance(OpenMapRealVector v)
          Optimized method to compute distance.
 double getDistance(RealVector v)
          Distance between two vectors.
private  OpenIntToDoubleHashMap getEntries()
          Get the entries of this instance.
 double getEntry(int index)
          Return the entry at the specified index.
 double getL1Distance(OpenMapRealVector v)
          Distance between two vectors.
 double getL1Distance(RealVector v)
          Distance between two vectors.
private  double getLInfDistance(OpenMapRealVector v)
          Optimized method to compute LInfDistance.
 double getLInfDistance(RealVector v)
          Distance between two vectors.
 double getSparsity()
           
 OpenMapRealVector getSubVector(int index, int n)
          Get a subvector from consecutive elements.
 int hashCode()
           Implementation Note: This works on exact values, and as a result it is possible for a.subtract(b) to be the zero vector, while a.hashCode() != b.hashCode().
protected  boolean isDefaultValue(double value)
          Determine if this value is within epsilon of zero.
 boolean isInfinite()
          Check whether any coordinate of this vector is infinite and none are NaN.
 boolean isNaN()
          Check whether any coordinate of this vector is NaN.
 OpenMapRealVector mapAdd(double d)
          Add a value to each entry.
 OpenMapRealVector mapAddToSelf(double d)
          Add a value to each entry.
 RealVector projection(RealVector v)
          Find the orthogonal projection of this vector onto another vector.
 void set(double value)
          Set all elements to a single value.
 void setEntry(int index, double value)
          Set a single element.
 void setSubVector(int index, RealVector v)
          Set a sequence of consecutive elements.
 Iterator<RealVector.Entry> sparseIterator()
          Create a sparse iterator over the vector, which may omit some entries.
 OpenMapRealVector subtract(OpenMapRealVector v)
          Optimized method to subtract OpenMapRealVectors.
 RealVector subtract(RealVector v)
          Subtract v from this vector.
 double[] toArray()
          Convert the vector to an array of doubles.
 void unitize()
          Converts this vector into a unit vector.
 OpenMapRealVector unitVector()
          Creates a unit vector pointing in the direction of this vector.
 
Methods inherited from class org.apache.commons.math3.linear.RealVector
addToEntry, checkIndex, checkVectorDimensions, checkVectorDimensions, combine, combineToSelf, cosine, getL1Norm, getLInfNorm, getMaxIndex, getMaxValue, getMinIndex, getMinValue, getNorm, iterator, map, mapDivide, mapDivideToSelf, mapMultiply, mapMultiplyToSelf, mapSubtract, mapSubtractToSelf, mapToSelf, outerProduct, unmodifiableRealVector
 
Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

DEFAULT_ZERO_TOLERANCE

public static final double DEFAULT_ZERO_TOLERANCE
Default Tolerance for having a value considered zero.

See Also:
Constant Field Values

serialVersionUID

private static final long serialVersionUID
Serializable version identifier.

See Also:
Constant Field Values

entries

private final OpenIntToDoubleHashMap entries
Entries of the vector.


virtualSize

private final int virtualSize
Dimension of the vector.


epsilon

private final double epsilon
Tolerance for having a value considered zero.

Constructor Detail

OpenMapRealVector

public OpenMapRealVector()
Build a 0-length vector. Zero-length vectors may be used to initialized construction of vectors by data gathering. We start with zero-length and use either the OpenMapRealVector(OpenMapRealVector, int) constructor or one of the append method (append(double), append(RealVector)) to gather data into this vector.


OpenMapRealVector

public OpenMapRealVector(int dimension)
Construct a vector of zeroes.

Parameters:
dimension - Size of the vector.

OpenMapRealVector

public OpenMapRealVector(int dimension,
                         double epsilon)
Construct a vector of zeroes, specifying zero tolerance.

Parameters:
dimension - Size of the vector.
epsilon - Tolerance below which a value considered zero.

OpenMapRealVector

protected OpenMapRealVector(OpenMapRealVector v,
                            int resize)
Build a resized vector, for use with append.

Parameters:
v - Original vector.
resize - Amount to add.

OpenMapRealVector

public OpenMapRealVector(int dimension,
                         int expectedSize)
Build a vector with known the sparseness (for advanced use only).

Parameters:
dimension - Size of the vector.
expectedSize - The expected number of non-zero entries.

OpenMapRealVector

public OpenMapRealVector(int dimension,
                         int expectedSize,
                         double epsilon)
Build a vector with known the sparseness and zero tolerance setting (for advanced use only).

Parameters:
dimension - Size of the vector.
expectedSize - Expected number of non-zero entries.
epsilon - Tolerance below which a value is considered zero.

OpenMapRealVector

public OpenMapRealVector(double[] values)
Create from an array. Only non-zero entries will be stored.

Parameters:
values - Set of values to create from.

OpenMapRealVector

public OpenMapRealVector(double[] values,
                         double epsilon)
Create from an array, specifying zero tolerance. Only non-zero entries will be stored.

Parameters:
values - Set of values to create from.
epsilon - Tolerance below which a value is considered zero.

OpenMapRealVector

public OpenMapRealVector(Double[] values)
Create from an array. Only non-zero entries will be stored.

Parameters:
values - The set of values to create from

OpenMapRealVector

public OpenMapRealVector(Double[] values,
                         double epsilon)
Create from an array. Only non-zero entries will be stored.

Parameters:
values - Set of values to create from.
epsilon - Tolerance below which a value is considered zero.

OpenMapRealVector

public OpenMapRealVector(OpenMapRealVector v)
Copy constructor.

Parameters:
v - Instance to copy from.

OpenMapRealVector

public OpenMapRealVector(RealVector v)
Generic copy constructor.

Parameters:
v - Instance to copy from.
Method Detail

getEntries

private OpenIntToDoubleHashMap getEntries()
Get the entries of this instance.

Returns:
the entries of this instance.

isDefaultValue

protected boolean isDefaultValue(double value)
Determine if this value is within epsilon of zero.

Parameters:
value - Value to test
Returns:
true if this value is within epsilon to zero, false otherwise.
Since:
2.1

add

public RealVector add(RealVector v)
Compute the sum of this vector and v. Returns a new vector. Does not change instance data.

Overrides:
add in class RealVector
Parameters:
v - Vector to be added.
Returns:
this + v.

add

public OpenMapRealVector add(OpenMapRealVector v)
Optimized method to add two OpenMapRealVectors. It copies the larger vector, then iterates over the smaller.

Parameters:
v - Vector to add.
Returns:
the sum of this and v.
Throws:
DimensionMismatchException - if the dimensions do not match.

append

public OpenMapRealVector append(OpenMapRealVector v)
Optimized method to append a OpenMapRealVector.

Parameters:
v - vector to append
Returns:
The result of appending v to self

append

public OpenMapRealVector append(RealVector v)
Construct a new vector by appending a vector to this vector.

Specified by:
append in class RealVector
Parameters:
v - vector to append to this one.
Returns:
a new vector.

append

public OpenMapRealVector append(double d)
Construct a new vector by appending a double to this vector.

Specified by:
append in class RealVector
Parameters:
d - double to append.
Returns:
a new vector.

copy

public OpenMapRealVector copy()
Returns a (deep) copy of this vector.

Specified by:
copy in class RealVector
Returns:
a vector copy.
Since:
2.1

dotProduct

public double dotProduct(OpenMapRealVector v)
Optimized method to compute the dot product with an OpenMapRealVector. It iterates over the smallest of the two.

Parameters:
v - Cector to compute the dot product with.
Returns:
the dot product of this and v.
Throws:
DimensionMismatchException - if the dimensions do not match.

dotProduct

public double dotProduct(RealVector v)
Compute the dot product of this vector with v.

Overrides:
dotProduct in class RealVector
Parameters:
v - Vector with which dot product should be computed
Returns:
the scalar dot product between this instance and v.

ebeDivide

public OpenMapRealVector ebeDivide(RealVector v)
Element-by-element division.

Specified by:
ebeDivide in class RealVector
Parameters:
v - Vector by which instance elements must be divided.
Returns:
a vector containing this[i] / v[i] for all i.

ebeMultiply

public OpenMapRealVector ebeMultiply(RealVector v)
Element-by-element multiplication.

Specified by:
ebeMultiply in class RealVector
Parameters:
v - Vector by which instance elements must be multiplied
Returns:
a vector containing this[i] * v[i] for all i.

getSubVector

public OpenMapRealVector getSubVector(int index,
                                      int n)
Get a subvector from consecutive elements.

Specified by:
getSubVector in class RealVector
Parameters:
index - index of first element.
n - number of elements to be retrieved.
Returns:
a vector containing n elements.

getDimension

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

Specified by:
getDimension in class RealVector
Returns:
the size of this vector.

getDistance

public double getDistance(OpenMapRealVector v)
Optimized method to compute distance.

Parameters:
v - Vector to compute distance to.
Returns:
the distance from this and v.
Throws:
DimensionMismatchException - if the dimensions do not match.

getDistance

public double getDistance(RealVector v)
Distance between two vectors.

This method computes the distance consistent with the L2 norm, i.e. the square root of the sum of element differences, or Euclidian distance.

Overrides:
getDistance in class RealVector
Parameters:
v - Vector to which distance is requested.
Returns:
the distance between two vectors.
See Also:
RealVector.getL1Distance(RealVector), RealVector.getLInfDistance(RealVector), RealVector.getNorm()

getEntry

public double getEntry(int index)
Return the entry at the specified index.

Specified by:
getEntry in class RealVector
Parameters:
index - Index location of entry to be fetched.
Returns:
the vector entry at index.
See Also:
RealVector.setEntry(int, double)

getL1Distance

public double getL1Distance(OpenMapRealVector v)
Distance between two vectors. This method computes the distance consistent with L1 norm, i.e. the sum of the absolute values of elements differences.

Parameters:
v - Vector to which distance is requested.
Returns:
distance between this vector and v.

getL1Distance

public double getL1Distance(RealVector v)
Distance between two vectors.

This method computes the distance consistent with L1 norm, i.e. the sum of the absolute values of the elements differences.

Overrides:
getL1Distance in class RealVector
Parameters:
v - Vector to which distance is requested.
Returns:
the distance between two vectors.

getLInfDistance

private double getLInfDistance(OpenMapRealVector v)
Optimized method to compute LInfDistance.

Parameters:
v - Vector to compute distance from.
Returns:
the LInfDistance.

getLInfDistance

public double getLInfDistance(RealVector v)
Distance between two vectors.

This method computes the distance consistent with L norm, i.e. the max of the absolute values of element differences.

Overrides:
getLInfDistance in class RealVector
Parameters:
v - Vector to which distance is requested.
Returns:
the distance between two vectors.
See Also:
RealVector.getDistance(RealVector), RealVector.getL1Distance(RealVector), RealVector.getLInfNorm()

isInfinite

public boolean isInfinite()
Check whether any coordinate of this vector is infinite and none are NaN.

Specified by:
isInfinite in class RealVector
Returns:
true if any coordinate of this vector is infinite and none are NaN, false otherwise.

isNaN

public boolean isNaN()
Check whether any coordinate of this vector is NaN.

Specified by:
isNaN in class RealVector
Returns:
true if any coordinate of this vector is NaN, false otherwise.

mapAdd

public OpenMapRealVector mapAdd(double d)
Add a value to each entry. Returns a new vector. Does not change instance data.

Overrides:
mapAdd in class RealVector
Parameters:
d - Value to be added to each entry.
Returns:
this + d.

mapAddToSelf

public OpenMapRealVector mapAddToSelf(double d)
Add a value to each entry. The instance is changed in-place.

Overrides:
mapAddToSelf in class RealVector
Parameters:
d - Value to be added to each entry.
Returns:
this.

projection

public RealVector projection(RealVector v)
Find the orthogonal projection of this vector onto another vector.

Specified by:
projection in class RealVector
Parameters:
v - vector onto which instance must be projected.
Returns:
projection of the instance onto v.

setEntry

public void setEntry(int index,
                     double value)
Set a single element.

Specified by:
setEntry in class RealVector
Parameters:
index - element index.
value - new value for the element.
See Also:
RealVector.getEntry(int)

setSubVector

public void setSubVector(int index,
                         RealVector v)
Set a sequence of consecutive elements.

Specified by:
setSubVector in class RealVector
Parameters:
index - index of first element to be set.
v - vector containing the values to set.

set

public void set(double value)
Set all elements to a single value.

Overrides:
set in class RealVector
Parameters:
value - Single value to set for all elements.

subtract

public OpenMapRealVector subtract(OpenMapRealVector v)
Optimized method to subtract OpenMapRealVectors.

Parameters:
v - Vector to subtract from this.
Returns:
the difference of this and v.
Throws:
DimensionMismatchException - if the dimensions do not match.

subtract

public RealVector subtract(RealVector v)
Subtract v from this vector. Returns a new vector. Does not change instance data.

Overrides:
subtract in class RealVector
Parameters:
v - Vector to be subtracted.
Returns:
this - v.

unitVector

public OpenMapRealVector unitVector()
Creates a unit vector pointing in the direction of this vector. The instance is not changed by this method.

Overrides:
unitVector in class RealVector
Returns:
a unit vector pointing in direction of this vector.

unitize

public void unitize()
Converts this vector into a unit vector. The instance itself is changed by this method.

Overrides:
unitize in class RealVector

toArray

public double[] toArray()
Convert the vector to an array of doubles. The array is independent from this vector data: the elements are copied.

Overrides:
toArray in class RealVector
Returns:
an array containing a copy of the vector elements.

hashCode

public int hashCode()
Implementation Note: This works on exact values, and as a result it is possible for a.subtract(b) to be the zero vector, while a.hashCode() != b.hashCode().

Overrides:
hashCode in class Object

equals

public boolean equals(Object obj)
Implementation Note: This performs an exact comparison, and as a result it is possible for a.subtract(b} to be the zero vector, while a.equals(b) == false.

Overrides:
equals in class Object

getSparsity

public double getSparsity()
Returns:
the percentage of none zero elements as a decimal percent.
Since:
2.2

sparseIterator

public Iterator<RealVector.Entry> sparseIterator()
Create a sparse iterator over the vector, which may omit some entries. Specialized implementations may choose to not iterate over all dimensions, either because those values are unset, or are equal to defaultValue(), or are small enough to be ignored for the purposes of iteration. No guarantees are made about order of iteration. In dense implementations, this method will often delegate to RealVector.iterator().

Overrides:
sparseIterator in class RealVector
Returns:
a sparse iterator.


Copyright (c) 2003-2013 Apache Software Foundation