RealVector (Commons MATH 3.5)

java.lang.Object
- org.apache.commons.math3.linear.RealVector

Direct Known Subclasses:

ArrayRealVector, SparseRealVector
```
public abstract class RealVector
extends java.lang.Object
```
Class defining a real-valued vector with basic algebraic operations.
vector element indexing is 0-based -- e.g., getEntry(0) returns the first element of the vector.

The code map and mapToSelf 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 map versions create a new vector to hold the result and do not change the instance. The mapToSelf version uses the instance itself to store the results, so the instance is changed by this method. In all cases, the result vector is returned by the methods, allowing the fluent API style, like this:
```
   RealVector result = v.mapAddToSelf(3.4).mapToSelf(new Tan()).mapToSelf(new Power(2.3));
 
```
Since:

2.1

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected class`	`RealVector.Entry` An entry in the vector.
`protected class`	`RealVector.SparseEntryIterator` This class should rarely be used, but is here to provide a default implementation of sparseIterator(), which is implemented by walking over the entries, skipping those that are zero.

Constructor Summary

Constructors
Constructor and Description

RealVector()

Constructors
Constructor and Description
`RealVector()`

Method Summary

Methods
Modifier and Type	Method and Description
`RealVector`	`add(RealVector v)` Compute the sum of this vector and `v`.
`void`	`addToEntry(int index, double increment)` Change an entry at the specified index.
`abstract RealVector`	`append(double d)` Construct a new vector by appending a double to this vector.
`abstract RealVector`	`append(RealVector v)` Construct a new vector by appending a vector to this vector.
`protected void`	`checkIndex(int index)` Check if an index is valid.
`protected void`	`checkIndices(int start, int end)` Checks that the indices of a subvector are valid.
`protected void`	`checkVectorDimensions(int n)` Check if instance dimension is equal to some expected value.
`protected void`	`checkVectorDimensions(RealVector v)` Check if instance and specified vectors have the same dimension.
`RealVector`	`combine(double a, double b, RealVector y)` Returns a new vector representing `a * this + b * y`, the linear combination of `this` and `y`.
`RealVector`	`combineToSelf(double a, double b, RealVector y)` Updates `this` with the linear combination of `this` and `y`.
`abstract RealVector`	`copy()` Returns a (deep) copy of this vector.
`double`	`cosine(RealVector v)` Computes the cosine of the angle between this vector and the argument.
`double`	`dotProduct(RealVector v)` Compute the dot product of this vector with `v`.
`abstract RealVector`	`ebeDivide(RealVector v)` Element-by-element division.
`abstract RealVector`	`ebeMultiply(RealVector v)` Element-by-element multiplication.
`boolean`	`equals(java.lang.Object other)` Test for the equality of two real vectors.
`abstract int`	`getDimension()` Returns the size of the vector.
`double`	`getDistance(RealVector v)` Distance between two vectors.
`abstract double`	`getEntry(int index)` Return the entry at the specified index.
`double`	`getL1Distance(RealVector v)` Distance between two vectors.
`double`	`getL1Norm()` Returns the L₁ norm of the vector.
`double`	`getLInfDistance(RealVector v)` Distance between two vectors.
`double`	`getLInfNorm()` Returns the L_∞ norm of the vector.
`int`	`getMaxIndex()` Get the index of the maximum entry.
`double`	`getMaxValue()` Get the value of the maximum entry.
`int`	`getMinIndex()` Get the index of the minimum entry.
`double`	`getMinValue()` Get the value of the minimum entry.
`double`	`getNorm()` Returns the L₂ norm of the vector.
`abstract RealVector`	`getSubVector(int index, int n)` Get a subvector from consecutive elements.
`int`	`hashCode()` .
`abstract boolean`	`isInfinite()` Check whether any coordinate of this vector is infinite and none are `NaN`.
`abstract boolean`	`isNaN()` Check whether any coordinate of this vector is `NaN`.
`java.util.Iterator<RealVector.Entry>`	`iterator()` Generic dense iterator.
`RealVector`	`map(UnivariateFunction function)` Acts as if implemented as:
`RealVector`	`mapAdd(double d)` Add a value to each entry.
`RealVector`	`mapAddToSelf(double d)` Add a value to each entry.
`RealVector`	`mapDivide(double d)` Divide each entry by the argument.
`RealVector`	`mapDivideToSelf(double d)` Divide each entry by the argument.
`RealVector`	`mapMultiply(double d)` Multiply each entry by the argument.
`RealVector`	`mapMultiplyToSelf(double d)` Multiply each entry.
`RealVector`	`mapSubtract(double d)` Subtract a value from each entry.
`RealVector`	`mapSubtractToSelf(double d)` Subtract a value from each entry.
`RealVector`	`mapToSelf(UnivariateFunction function)` Acts as if it is implemented as:
`RealMatrix`	`outerProduct(RealVector v)` Compute the outer product.
`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.
`abstract void`	`setEntry(int index, double value)` Set a single element.
`abstract void`	`setSubVector(int index, RealVector v)` Set a sequence of consecutive elements.
`java.util.Iterator<RealVector.Entry>`	`sparseIterator()` Create a sparse iterator over the vector, which may omit some entries.
`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.
`RealVector`	`unitVector()` Creates a unit vector pointing in the direction of this vector.
`static RealVector`	`unmodifiableRealVector(RealVector v)` Returns an unmodifiable view of the specified vector.
`double`	`walkInDefaultOrder(RealVectorChangingVisitor visitor)` Visits (and possibly alters) all entries of this vector in default order (increasing index).
`double`	`walkInDefaultOrder(RealVectorChangingVisitor visitor, int start, int end)` Visits (and possibly alters) some entries of this vector in default order (increasing index).
`double`	`walkInDefaultOrder(RealVectorPreservingVisitor visitor)` Visits (but does not alter) all entries of this vector in default order (increasing index).
`double`	`walkInDefaultOrder(RealVectorPreservingVisitor visitor, int start, int end)` Visits (but does not alter) some entries of this vector in default order (increasing index).
`double`	`walkInOptimizedOrder(RealVectorChangingVisitor visitor)` Visits (and possibly alters) all entries of this vector in optimized order.
`double`	`walkInOptimizedOrder(RealVectorChangingVisitor visitor, int start, int end)` Visits (and possibly change) some entries of this vector in optimized order.
`double`	`walkInOptimizedOrder(RealVectorPreservingVisitor visitor)` Visits (but does not alter) all entries of this vector in optimized order.
`double`	`walkInOptimizedOrder(RealVectorPreservingVisitor visitor, int start, int end)` Visits (but does not alter) some entries of this vector in optimized order.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - RealVector
```
public RealVector()
```
- Method Detail
  - getDimension
```
public abstract int getDimension()
```
    Returns the size of the vector.
    
    Returns:
    the size of this vector.
  - getEntry
```
public abstract double getEntry(int index)
                         throws OutOfRangeException
```
    Return the entry at 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, double)
  - setEntry
```
public abstract void setEntry(int index,
            double 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)
  - addToEntry
```
public void addToEntry(int index,
              double increment)
                throws OutOfRangeException
```
    Change an entry at the specified index.
    
    Parameters:
    index - Index location of entry to be set.
    increment - Value to add to the vector entry.
    
    Throws:
    
    OutOfRangeException - if the index is not valid.
    Since:
    
    3.0
  - append
```
public abstract RealVector append(RealVector v)
```
    Construct a new vector by appending a vector to this vector.
    
    Parameters:
    v - vector to append to this one.
    
    Returns:
    a new vector.
  - append
```
public abstract RealVector append(double d)
```
    Construct a new vector by appending a double to this vector.
    
    Parameters:
    d - double to append.
    
    Returns:
    a new vector.
  - getSubVector
```
public abstract RealVector getSubVector(int index,
                      int n)
                                 throws NotPositiveException,
                                        OutOfRangeException
```
    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 is not positive.
  - setSubVector
```
public abstract void setSubVector(int index,
                RealVector v)
                           throws OutOfRangeException
```
    Set a sequence 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.
  - isNaN
```
public abstract boolean isNaN()
```
    Check whether any coordinate of this vector is NaN.
    
    Returns:
    true if any coordinate of this vector is NaN, false otherwise.
  - isInfinite
```
public abstract boolean isInfinite()
```
    Check whether any coordinate of this vector is infinite and none are NaN.
    
    Returns:
    true if any coordinate of this vector is infinite and none are NaN, false otherwise.
  - checkVectorDimensions
```
protected void checkVectorDimensions(RealVector v)
                              throws DimensionMismatchException
```
    Check if instance and specified vectors have the same dimension.
    
    Parameters:
    v - Vector to compare instance with.
    
    Throws:
    
    DimensionMismatchException - if the vectors do not have the same dimension.
  - checkVectorDimensions
```
protected void checkVectorDimensions(int n)
                              throws DimensionMismatchException
```
    Check if instance dimension is equal to some expected value.
    
    Parameters:
    n - Expected dimension.
    
    Throws:
    
    DimensionMismatchException - if the dimension is inconsistent with the vector size.
  - checkIndex
```
protected void checkIndex(int index)
                   throws OutOfRangeException
```
    Check if an index is valid.
    
    Parameters:
    index - Index to check.
    
    Throws:
    
    OutOfRangeException - if index is not valid.
  - checkIndices
```
protected void checkIndices(int start,
                int end)
                     throws NumberIsTooSmallException,
                            OutOfRangeException
```
    Checks that the indices of a subvector are valid.
    
    Parameters:
    start - the index of the first entry of the subvector
    end - the index of the last entry of the subvector (inclusive)
    
    Throws:
    
    OutOfRangeException - if start of end are not valid
    
    NumberIsTooSmallException - if end < start
    Since:
    
    3.1
  - add
```
public RealVector add(RealVector v)
               throws DimensionMismatchException
```
    Compute the sum of this vector and v. Returns a new vector. Does not change instance data.
    
    Parameters:
    v - Vector to be added.
    
    Returns:
    this + v.
    
    Throws:
    
    DimensionMismatchException - if v is not the same size as this vector.
  - subtract
```
public RealVector subtract(RealVector v)
                    throws DimensionMismatchException
```
    Subtract v from this vector. Returns a new vector. Does not change instance data.
    
    Parameters:
    v - Vector to be subtracted.
    
    Returns:
    this - v.
    
    Throws:
    
    DimensionMismatchException - if v is not the same size as this vector.
  - mapAdd
```
public RealVector mapAdd(double d)
```
    Add a value to each entry. Returns a new vector. Does not change instance data.
    
    Parameters:
    d - Value to be added to each entry.
    
    Returns:
    this + d.
  - mapAddToSelf
```
public RealVector mapAddToSelf(double d)
```
    Add a value to each entry. The instance is changed in-place.
    
    Parameters:
    d - Value to be added to each entry.
    
    Returns:
    this.
  - copy
```
public abstract RealVector copy()
```
    Returns a (deep) copy of this vector.
    
    Returns:
    a vector copy.
  - dotProduct
```
public double dotProduct(RealVector v)
                  throws DimensionMismatchException
```
    Compute the dot product of this vector with v.
    
    Parameters:
    v - Vector with which dot product should be computed
    
    Returns:
    the scalar dot product between this instance and v.
    
    Throws:
    
    DimensionMismatchException - if v is not the same size as this vector.
  - cosine
```
public double cosine(RealVector v)
              throws DimensionMismatchException,
                     MathArithmeticException
```
    Computes the cosine of the angle between this vector and the argument.
    
    Parameters:
    v - Vector.
    
    Returns:
    the cosine of the angle between this vector and v.
    
    Throws:
    
    MathArithmeticException - if this or v is the null vector
    
    DimensionMismatchException - if the dimensions of this and v do not match
  - ebeDivide
```
public abstract RealVector ebeDivide(RealVector v)
                              throws DimensionMismatchException
```
    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 vector.
  - ebeMultiply
```
public abstract RealVector ebeMultiply(RealVector 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 vector.
  - getDistance
```
public double getDistance(RealVector v)
                   throws DimensionMismatchException
```
    Distance between two vectors.
    This method computes the distance consistent with the L₂ norm, i.e. the square root of the sum of element differences, or Euclidean distance.
    
    Parameters:
    v - Vector to which distance is requested.
    
    Returns:
    the distance between two vectors.
    
    Throws:
    
    DimensionMismatchException - if v is not the same size as this vector.
    See Also:
    getL1Distance(RealVector), getLInfDistance(RealVector), getNorm()
  - getNorm
```
public double getNorm()
```
    Returns the L₂ norm of the vector.
    The L₂ norm is the root of the sum of the squared elements.
    
    Returns:
    the norm.
    See Also:
    getL1Norm(), getLInfNorm(), getDistance(RealVector)
  - getL1Norm
```
public double getL1Norm()
```
    Returns the L₁ norm of the vector.
    The L₁ norm is the sum of the absolute values of the elements.
    
    Returns:
    the norm.
    See Also:
    getNorm(), getLInfNorm(), getL1Distance(RealVector)
  - getLInfNorm
```
public double getLInfNorm()
```
    Returns the L_∞ norm of the vector.
    The L_∞ norm is the max of the absolute values of the elements.
    
    Returns:
    the norm.
    See Also:
    getNorm(), getL1Norm(), getLInfDistance(RealVector)
  - getL1Distance
```
public double getL1Distance(RealVector v)
                     throws DimensionMismatchException
```
    Distance between two vectors.
    This method computes the distance consistent with L₁ norm, i.e. the sum of the absolute values of the elements differences.
    
    Parameters:
    v - Vector to which distance is requested.
    
    Returns:
    the distance between two vectors.
    
    Throws:
    
    DimensionMismatchException - if v is not the same size as this vector.
  - getLInfDistance
```
public double getLInfDistance(RealVector v)
                       throws DimensionMismatchException
```
    Distance between two vectors.
    This method computes the distance consistent with L_∞ norm, i.e. the max of the absolute values of element differences.
    
    Parameters:
    v - Vector to which distance is requested.
    
    Returns:
    the distance between two vectors.
    
    Throws:
    
    DimensionMismatchException - if v is not the same size as this vector.
    See Also:
    getDistance(RealVector), getL1Distance(RealVector), getLInfNorm()
  - getMinIndex
```
public int getMinIndex()
```
    Get the index of the minimum entry.
    
    Returns:
    the index of the minimum entry or -1 if vector length is 0 or all entries are NaN.
  - getMinValue
```
public double getMinValue()
```
    Get the value of the minimum entry.
    
    Returns:
    the value of the minimum entry or NaN if all entries are NaN.
  - getMaxIndex
```
public int getMaxIndex()
```
    Get the index of the maximum entry.
    
    Returns:
    the index of the maximum entry or -1 if vector length is 0 or all entries are NaN
  - getMaxValue
```
public double getMaxValue()
```
    Get the value of the maximum entry.
    
    Returns:
    the value of the maximum entry or NaN if all entries are NaN.
  - mapMultiply
```
public RealVector mapMultiply(double d)
```
    Multiply each entry by the argument. Returns a new vector. Does not change instance data.
    
    Parameters:
    d - Multiplication factor.
    
    Returns:
    this * d.
  - mapMultiplyToSelf
```
public RealVector mapMultiplyToSelf(double d)
```
    Multiply each entry. The instance is changed in-place.
    
    Parameters:
    d - Multiplication factor.
    
    Returns:
    this.
  - mapSubtract
```
public RealVector mapSubtract(double d)
```
    Subtract a value from each entry. Returns a new vector. Does not change instance data.
    
    Parameters:
    d - Value to be subtracted.
    
    Returns:
    this - d.
  - mapSubtractToSelf
```
public RealVector mapSubtractToSelf(double d)
```
    Subtract a value from each entry. The instance is changed in-place.
    
    Parameters:
    d - Value to be subtracted.
    
    Returns:
    this.
  - mapDivide
```
public RealVector mapDivide(double d)
```
    Divide each entry by the argument. Returns a new vector. Does not change instance data.
    
    Parameters:
    d - Value to divide by.
    
    Returns:
    this / d.
  - mapDivideToSelf
```
public RealVector mapDivideToSelf(double d)
```
    Divide each entry by the argument. The instance is changed in-place.
    
    Parameters:
    d - Value to divide by.
    
    Returns:
    this.
  - outerProduct
```
public RealMatrix outerProduct(RealVector v)
```
    Compute the outer product.
    
    Parameters:
    v - Vector with which outer product should be computed.
    
    Returns:
    the matrix outer product between this instance and v.
  - projection
```
public RealVector projection(RealVector v)
                      throws DimensionMismatchException,
                             MathArithmeticException
```
    Find the orthogonal projection of this vector onto another vector.
    
    Parameters:
    v - vector onto which instance must be projected.
    
    Returns:
    projection of the instance onto v.
    
    Throws:
    
    DimensionMismatchException - if v is not the same size as this vector.
    
    MathArithmeticException - if this or v is the null vector
  - set
```
public void set(double value)
```
    Set all elements to a single value.
    
    Parameters:
    value - Single value to set for all elements.
  - toArray
```
public double[] toArray()
```
    Convert the vector to an array of doubles. The array is independent from this vector data: the elements are copied.
    
    Returns:
    an array containing a copy of the vector elements.
  - unitVector
```
public RealVector unitVector()
                      throws MathArithmeticException
```
    Creates a unit vector pointing in the direction of this vector. The instance is not changed by this method.
    
    Returns:
    a unit vector pointing in direction of this vector.
    
    Throws:
    
    MathArithmeticException - if the norm is zero.
  - unitize
```
public void unitize()
             throws MathArithmeticException
```
    Converts this vector into a unit vector. The instance itself is changed by this method.
    
    Throws:
    
    MathArithmeticException - if the norm is zero.
  - sparseIterator
```
public java.util.Iterator<RealVector.Entry> sparseIterator()
```
    Create a sparse iterator over the vector, which may omit some entries. The ommitted entries are either exact zeroes (for dense implementations) or are the entries which are not stored (for real sparse vectors). No guarantees are made about order of iteration.
    Note: derived classes are required to return an Iterator that returns non-null RealVector.Entry objects as long as Iterator.hasNext() returns true.
    
    Returns:
    a sparse iterator.
  - iterator
```
public java.util.Iterator<RealVector.Entry> iterator()
```
    Generic dense iterator. Iteration is in increasing order of the vector index.
    Note: derived classes are required to return an Iterator that returns non-null RealVector.Entry objects as long as Iterator.hasNext() returns true.
    
    Returns:
    a dense iterator.
  - map
```
public RealVector map(UnivariateFunction function)
```
    Acts as if implemented as:
```
  return copy().mapToSelf(function);
 
```
    Returns a new vector. Does not change instance data.
    Parameters:
    function - Function to apply to each entry.
    
    Returns:
    a new vector.
  - mapToSelf
```
public RealVector mapToSelf(UnivariateFunction function)
```
    Acts as if it is implemented as:
```
  Entry e = null;
  for(Iterator it = iterator(); it.hasNext(); e = it.next()) {
      e.setValue(function.value(e.getValue()));
  }
 
```
    Entries of this vector are modified in-place by this method.
    Parameters:
    function - Function to apply to each entry.
    
    Returns:
    a reference to this vector.
  - combine
```
public RealVector combine(double a,
                 double b,
                 RealVector y)
                   throws DimensionMismatchException
```
    Returns a new vector representing a * this + b * y, the linear combination of this and y. Returns a new vector. Does not change instance data.
    
    Parameters:
    a - Coefficient of this.
    b - Coefficient of y.
    y - Vector with which this is linearly combined.
    
    Returns:
    a vector containing a * this[i] + b * y[i] for all i.
    
    Throws:
    
    DimensionMismatchException - if y is not the same size as this vector.
  - combineToSelf
```
public RealVector combineToSelf(double a,
                       double b,
                       RealVector y)
                         throws DimensionMismatchException
```
    Updates this with the linear combination of this and y.
    
    Parameters:
    a - Weight of this.
    b - Weight of y.
    y - Vector with which this is linearly combined.
    
    Returns:
    this, with components equal to a * this[i] + b * y[i] for all i.
    
    Throws:
    
    DimensionMismatchException - if y is not the same size as this vector.
  - walkInDefaultOrder
```
public double walkInDefaultOrder(RealVectorPreservingVisitor visitor)
```
    Visits (but does not alter) all entries of this vector in default order (increasing index).
    
    Parameters:
    visitor - the visitor to be used to process the entries of this vector
    
    Returns:
    the value returned by RealVectorPreservingVisitor.end() at the end of the walk
    Since:
    
    3.1
  - walkInDefaultOrder
```
public double walkInDefaultOrder(RealVectorPreservingVisitor visitor,
                        int start,
                        int end)
                          throws NumberIsTooSmallException,
                                 OutOfRangeException
```
    Visits (but does not alter) some entries of this vector in default order (increasing index).
    
    Parameters:
    visitor - visitor to be used to process the entries of this vector
    start - the index of the first entry to be visited
    end - the index of the last entry to be visited (inclusive)
    
    Returns:
    the value returned by RealVectorPreservingVisitor.end() at the end of the walk
    
    Throws:
    
    NumberIsTooSmallException - if end < start.
    
    OutOfRangeException - if the indices are not valid.
    Since:
    
    3.1
  - walkInOptimizedOrder
```
public double walkInOptimizedOrder(RealVectorPreservingVisitor visitor)
```
    Visits (but does not alter) all entries of this vector in optimized order. The order in which the entries are visited is selected so as to lead to the most efficient implementation; it might depend on the concrete implementation of this abstract class.
    
    Parameters:
    visitor - the visitor to be used to process the entries of this vector
    
    Returns:
    the value returned by RealVectorPreservingVisitor.end() at the end of the walk
    Since:
    
    3.1
  - walkInOptimizedOrder
```
public double walkInOptimizedOrder(RealVectorPreservingVisitor visitor,
                          int start,
                          int end)
                            throws NumberIsTooSmallException,
                                   OutOfRangeException
```
    Visits (but does not alter) some entries of this vector in optimized order. The order in which the entries are visited is selected so as to lead to the most efficient implementation; it might depend on the concrete implementation of this abstract class.
    
    Parameters:
    visitor - visitor to be used to process the entries of this vector
    start - the index of the first entry to be visited
    end - the index of the last entry to be visited (inclusive)
    
    Returns:
    the value returned by RealVectorPreservingVisitor.end() at the end of the walk
    
    Throws:
    
    NumberIsTooSmallException - if end < start.
    
    OutOfRangeException - if the indices are not valid.
    Since:
    
    3.1
  - walkInDefaultOrder
```
public double walkInDefaultOrder(RealVectorChangingVisitor visitor)
```
    Visits (and possibly alters) all entries of this vector in default order (increasing index).
    
    Parameters:
    visitor - the visitor to be used to process and modify the entries of this vector
    
    Returns:
    the value returned by RealVectorChangingVisitor.end() at the end of the walk
    Since:
    
    3.1
  - walkInDefaultOrder
```
public double walkInDefaultOrder(RealVectorChangingVisitor visitor,
                        int start,
                        int end)
                          throws NumberIsTooSmallException,
                                 OutOfRangeException
```
    Visits (and possibly alters) some entries of this vector in default order (increasing index).
    
    Parameters:
    visitor - visitor to be used to process the entries of this vector
    start - the index of the first entry to be visited
    end - the index of the last entry to be visited (inclusive)
    
    Returns:
    the value returned by RealVectorChangingVisitor.end() at the end of the walk
    
    Throws:
    
    NumberIsTooSmallException - if end < start.
    
    OutOfRangeException - if the indices are not valid.
    Since:
    
    3.1
  - walkInOptimizedOrder
```
public double walkInOptimizedOrder(RealVectorChangingVisitor visitor)
```
    Visits (and possibly alters) all entries of this vector in optimized order. The order in which the entries are visited is selected so as to lead to the most efficient implementation; it might depend on the concrete implementation of this abstract class.
    
    Parameters:
    visitor - the visitor to be used to process the entries of this vector
    
    Returns:
    the value returned by RealVectorChangingVisitor.end() at the end of the walk
    Since:
    
    3.1
  - walkInOptimizedOrder
```
public double walkInOptimizedOrder(RealVectorChangingVisitor visitor,
                          int start,
                          int end)
                            throws NumberIsTooSmallException,
                                   OutOfRangeException
```
    Visits (and possibly change) some entries of this vector in optimized order. The order in which the entries are visited is selected so as to lead to the most efficient implementation; it might depend on the concrete implementation of this abstract class.
    
    Parameters:
    visitor - visitor to be used to process the entries of this vector
    start - the index of the first entry to be visited
    end - the index of the last entry to be visited (inclusive)
    
    Returns:
    the value returned by RealVectorChangingVisitor.end() at the end of the walk
    
    Throws:
    
    NumberIsTooSmallException - if end < start.
    
    OutOfRangeException - if the indices are not valid.
    Since:
    
    3.1
  - equals
```
public boolean equals(java.lang.Object other)
               throws MathUnsupportedOperationException
```
    Test for the equality of two real vectors. If all coordinates of two real vectors are exactly the same, and none are NaN, the two real vectors are considered to be equal. NaN coordinates are considered to affect globally the vector and be equals to each other - i.e, if either (or all) coordinates of the real vector are equal to NaN, the real vector is equal to a vector with all NaN coordinates.
    
    This method must be overriden by concrete subclasses of RealVector (the current implementation throws an exception).
    
    Overrides:
    
    equals in class java.lang.Object
    
    Parameters:
    other - Object to test for equality.
    
    Returns:
    true if two vector objects are equal, false if other is null, not an instance of RealVector, or not equal to this RealVector instance.
    
    Throws:
    
    MathUnsupportedOperationException - if this method is not overridden.
  - hashCode
```
public int hashCode()
             throws MathUnsupportedOperationException
```
    . This method must be overriden by concrete subclasses of RealVector (current implementation throws an exception).
    
    Overrides:
    
    hashCode in class java.lang.Object
    
    Throws:
    
    MathUnsupportedOperationException - if this method is not overridden.
  - unmodifiableRealVector
```
public static RealVector unmodifiableRealVector(RealVector v)
```
    Returns an unmodifiable view of the specified vector. The returned vector has read-only access. An attempt to modify it will result in a MathUnsupportedOperationException. However, the returned vector is not immutable, since any modification of v will also change the returned view. For example, in the following piece of code
```
     RealVector v = new ArrayRealVector(2);
     RealVector w = RealVector.unmodifiableRealVector(v);
     v.setEntry(0, 1.2);
     v.setEntry(1, -3.4);
 
```
    the changes will be seen in the w view of v.
    Parameters:
    v - Vector for which an unmodifiable view is to be returned.
    
    Returns:
    an unmodifiable view of v.

Class RealVector

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

RealVector

Method Detail

getDimension

getEntry

setEntry

addToEntry

append

append

getSubVector

setSubVector

isNaN

isInfinite

checkVectorDimensions

checkVectorDimensions

checkIndex

checkIndices

add

subtract

mapAdd

mapAddToSelf

copy

dotProduct

cosine

ebeDivide

ebeMultiply

getDistance

getNorm

getL1Norm

getLInfNorm

getL1Distance

getLInfDistance

getMinIndex

getMinValue

getMaxIndex

getMaxValue

mapMultiply

mapMultiplyToSelf

mapSubtract

mapSubtractToSelf

mapDivide

mapDivideToSelf

outerProduct

projection

set

toArray

unitVector

unitize

sparseIterator

iterator

map

mapToSelf

combine

combineToSelf

walkInDefaultOrder

walkInDefaultOrder

walkInOptimizedOrder

walkInOptimizedOrder

walkInDefaultOrder

walkInDefaultOrder

walkInOptimizedOrder

walkInOptimizedOrder

equals

hashCode

unmodifiableRealVector