## Class RealVector

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

- Direct Known Subclasses:
- ArrayRealVector, SparseRealVector

public abstract class RealVectorextends 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));

### Constructor Summary

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.`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)**Deprecated.***As of version 3.1, this method is deprecated, and will be removed in version 4.0. This decision follows the discussion reported in MATH-803. Uses of this method involving sparse implementations of*`RealVector`

might lead to wrong results. Since there is no satisfactory correction to this bug, this method is deprecated. Users who want to preserve this feature are advised to implement`RealVectorPreservingVisitor`

(possibly ignoring corner cases for the sake of efficiency).`abstract RealVector`

**ebeMultiply**(RealVector v)**Deprecated.***As of version 3.1, this method is deprecated, and will be removed in version 4.0. This decision follows the discussion reported in MATH-803. Uses of this method involving sparse implementations of*`RealVector`

might lead to wrong results. Since there is no satisfactory correction to this bug, this method is deprecated. Users who want to preserve this feature are advised to implement`RealVectorPreservingVisitor`

(possibly ignoring corner cases for the sake of efficiency).`boolean`

**equals**(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_{1}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_{2}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`

.`Iterator<org.apache.commons.math3.linear.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.`Iterator<org.apache.commons.math3.linear.RealVector.Entry>`

**sparseIterator**()**Deprecated.***As of 3.1, this method is deprecated, because its interface is too confusing (see JIRA MATH-875). This method will be completely removed in 4.0.*`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.

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

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

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

@Deprecatedpublic abstract RealVector ebeDivide(RealVector v) throws DimensionMismatchException

Deprecated.*As of version 3.1, this method is deprecated, and will be removed in version 4.0. This decision follows the discussion reported in MATH-803. Uses of this method involving sparse implementations of*`RealVector`

might lead to wrong results. Since there is no satisfactory correction to this bug, this method is deprecated. Users who want to preserve this feature are advised to implement`RealVectorPreservingVisitor`

(possibly ignoring corner cases for the sake of efficiency).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

@Deprecatedpublic abstract RealVector ebeMultiply(RealVector v) throws DimensionMismatchException

Deprecated.`RealVector`

might lead to wrong results. Since there is no satisfactory correction to this bug, this method is deprecated. Users who want to preserve this feature are advised to implement`RealVectorPreservingVisitor`

(possibly ignoring corner cases for the sake of efficiency).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

_{2}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_{2}norm of the vector.The L

_{2}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_{1}norm of the vector.The L

_{1}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

_{1}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`double`

s. 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

@Deprecatedpublic Iterator<org.apache.commons.math3.linear.RealVector.Entry> sparseIterator()

Deprecated.*As of 3.1, this method is deprecated, because its interface is too confusing (see JIRA MATH-875). This method will be completely removed in 4.0.*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`iterator()`

.Note: derived classes are required to return an

`Iterator`

that returns non-null`Entry`

objects as long as`Iterator.hasNext()`

returns`true`

.- Returns:
- a sparse iterator.

#### iterator

public Iterator<org.apache.commons.math3.linear.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`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

Entries of this vector are modified in-place by this method.it = iterator(); it.hasNext(); e = it.next()) { e.setValue(function.value(e.getValue())); } - 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

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

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

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

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

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

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

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

#### equals

public boolean equals(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`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`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 codeRealVector 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`

.

**SCaVis 1.8 © jWork.org**