org.apache.commons.math3.linear

## Class OpenMapRealVector

- java.lang.Object
- - org.apache.commons.math3.linear.RealVector
  - - org.apache.commons.math3.linear.SparseRealVector
    - - 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

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `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

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static double` | `DEFAULT_ZERO_TOLERANCE` Default Tolerance for having a value considered zero.

  - ### Constructor Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `` | `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

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `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.
    `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.
    `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 `double`s.
    `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

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

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

          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 `double`s. 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 © 2003-2012 The Apache Software Foundation. All Rights Reserved.