Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.apache.commons.math.linear
Class ArrayRealVector

    java.lang.Object
      org.apache.commons.math.linear.AbstractRealVector
          org.apache.commons.math.linear.ArrayRealVector

All Implemented Interfaces:
  java.io.Serializable, RealVector

    public class ArrayRealVector

extends AbstractRealVector
implements java.io.Serializable

This class implements the `RealVector` interface with a double array.

Since:
  2.0
Version:
  $Revision: 902203 $ $Date: 2010-01-22 13:27:41 -0500 (Fri, 22 Jan 2010) $
See Also:
  Serialized Form

Nested Class Summary

Nested classes/interfaces inherited from class org.apache.commons.math.linear.AbstractRealVector
`AbstractRealVector.EntryImpl, AbstractRealVector.SparseEntryIterator`

Nested classes/interfaces inherited from interface org.apache.commons.math.linear.RealVector
`RealVector.Entry`

Field Summary
`protected double[]` | `data` Entries of the vector.
`private static RealVectorFormat` | `DEFAULT_FORMAT` Default format.
`private static java.lang.String` | `NON_FITTING_POSITION_AND_SIZE_MESSAGE` Message for non fitting position and size.
`private static long` | `serialVersionUID` Serializable version identifier.

Constructor Summary
`ArrayRealVector()` Build a 0-length vector.
`ArrayRealVector(ArrayRealVector v)` Construct a vector from another vector, using a deep copy.
`ArrayRealVector(ArrayRealVector v1, ArrayRealVector v2)` Construct a vector by appending one vector to another vector.
`ArrayRealVector(ArrayRealVector v, boolean deep)` Construct a vector from another vector.
`ArrayRealVector(ArrayRealVector v1, double[] v2)` Construct a vector by appending one vector to another vector.
`ArrayRealVector(ArrayRealVector v1, RealVector v2)` Construct a vector by appending one vector to another vector.
`ArrayRealVector(double[] d)` Construct a vector from an array, copying the input array.
`ArrayRealVector(java.lang.Double[] d)` Construct a vector from an array.
`ArrayRealVector(double[] v1, ArrayRealVector v2)` Construct a vector by appending one vector to another vector.
`ArrayRealVector(double[] d, boolean copyArray)` Create a new ArrayRealVector using the input array as the underlying data array.
`ArrayRealVector(double[] v1, double[] v2)` Construct a vector by appending one vector to another vector.
`ArrayRealVector(double[] d, int pos, int size)` Construct a vector from part of a array.
`ArrayRealVector(java.lang.Double[] d, int pos, int size)` Construct a vector from part of a Double array
`ArrayRealVector(int size)` Construct a (size)-length vector of zeros.
`ArrayRealVector(int size, double preset)` Construct an (size)-length vector with preset values.
`ArrayRealVector(RealVector v)` Construct a vector from another vector, using a deep copy.
`ArrayRealVector(RealVector v1, ArrayRealVector v2)` Construct a vector by appending one vector to another vector.

Method Summary
`ArrayRealVector` | `add(ArrayRealVector v)` Compute the sum of this and v.
`RealVector` | `add(double[] v)` Compute the sum of this and v.
`RealVector` | `add(RealVector v)` Compute the sum of this and v.
`ArrayRealVector` | `append(ArrayRealVector v)` Construct a vector by appending a vector to this vector.
`RealVector` | `append(double in)` Construct a vector by appending a double to this vector.
`RealVector` | `append(double[] in)` Construct a vector by appending a double array to this vector.
`RealVector` | `append(RealVector v)` Construct a vector by appending a vector to this vector.
`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.
`AbstractRealVector` | `copy()` Returns a (deep) copy of this.
`double` | `dotProduct(ArrayRealVector v)` Compute the dot product.
`double` | `dotProduct(double[] v)` Compute the dot product.
`double` | `dotProduct(RealVector v)` Compute the dot product.
`ArrayRealVector` | `ebeDivide(ArrayRealVector v)` Element-by-element division.
`RealVector` | `ebeDivide(double[] v)` Element-by-element division.
`RealVector` | `ebeDivide(RealVector v)` Element-by-element division.
`ArrayRealVector` | `ebeMultiply(ArrayRealVector v)` Element-by-element multiplication.
`RealVector` | `ebeMultiply(double[] v)` Element-by-element multiplication.
`RealVector` | `ebeMultiply(RealVector v)` Element-by-element multiplication.
`boolean` | `equals(java.lang.Object other)` Test for the equality of two real vectors.
`double[]` | `getData()` Returns vector entries as a double array.
`double[]` | `getDataRef()` Returns a reference to the underlying data array.
`int` | `getDimension()` Returns the size of the vector.
`double` | `getDistance(ArrayRealVector v)` Distance between two vectors.
`double` | `getDistance(double[] v)` Distance between two vectors.
`double` | `getDistance(RealVector v)` Distance between two vectors.
`double` | `getEntry(int index)` Returns the entry in the specified index.
`double` | `getL1Distance(ArrayRealVector v)` Distance between two vectors.
`double` | `getL1Distance(double[] v)` Distance between two vectors.
`double` | `getL1Distance(RealVector v)` Distance between two vectors.
`double` | `getL1Norm()` Returns the L1 norm of the vector.
`double` | `getLInfDistance(ArrayRealVector v)` Distance between two vectors.
`double` | `getLInfDistance(double[] v)` Distance between two vectors.
`double` | `getLInfDistance(RealVector v)` Distance between two vectors.
`double` | `getLInfNorm()` Returns the L∞ norm of the vector.
`double` | `getNorm()` Returns the L2 norm of the vector.
`RealVector` | `getSubVector(int index, int n)` Get a subvector from consecutive elements.
`int` | `hashCode()` Get a hashCode for the real vector.
`boolean` | `isInfinite()` Returns true if any coordinate of this vector is infinite and none are NaN; false otherwise
`boolean` | `isNaN()` Returns true if any coordinate of this vector is NaN; false otherwise
`RealVector` | `mapAbsToSelf()` Map the `Math.abs(double)` function to each entry.
`RealVector` | `mapAcosToSelf()` Map the `Math.acos(double)` function to each entry.
`RealVector` | `mapAddToSelf(double d)` Map an addition operation to each entry.
`RealVector` | `mapAsinToSelf()` Map the `Math.asin(double)` function to each entry.
`RealVector` | `mapAtanToSelf()` Map the `Math.atan(double)` function to each entry.
`RealVector` | `mapCbrtToSelf()` Map the `Math.cbrt(double)` function to each entry.
`RealVector` | `mapCeilToSelf()` Map the `Math.ceil(double)` function to each entry.
`RealVector` | `mapCoshToSelf()` Map the `Math.cosh(double)` function to each entry.
`RealVector` | `mapCosToSelf()` Map the `Math.cos(double)` function to each entry.
`RealVector` | `mapDivideToSelf(double d)` Map a division operation to each entry.
`RealVector` | `mapExpm1ToSelf()` Map the `Math.expm1(double)` function to each entry.
`RealVector` | `mapExpToSelf()` Map the `Math.exp(double)` function to each entry.
`RealVector` | `mapFloorToSelf()` Map the `Math.floor(double)` function to each entry.
`RealVector` | `mapInvToSelf()` Map the 1/x function to each entry.
`RealVector` | `mapLog10ToSelf()` Map the `Math.log10(double)` function to each entry.
`RealVector` | `mapLog1pToSelf()` Map the `Math.log1p(double)` function to each entry.
`RealVector` | `mapLogToSelf()` Map the `Math.log(double)` function to each entry.
`RealVector` | `mapMultiplyToSelf(double d)` Map a multiplication operation to each entry.
`RealVector` | `mapPowToSelf(double d)` Map a power operation to each entry.
`RealVector` | `mapRintToSelf()` Map the `Math.rint(double)` function to each entry.
`RealVector` | `mapSignumToSelf()` Map the `Math.signum(double)` function to each entry.
`RealVector` | `mapSinhToSelf()` Map the `Math.sinh(double)` function to each entry.
`RealVector` | `mapSinToSelf()` Map the `Math.sin(double)` function to each entry.
`RealVector` | `mapSqrtToSelf()` Map the `Math.sqrt(double)` function to each entry.
`RealVector` | `mapSubtractToSelf(double d)` Map a subtraction operation to each entry.
`RealVector` | `mapTanhToSelf()` Map the `Math.tanh(double)` function to each entry.
`RealVector` | `mapTanToSelf()` Map the `Math.tan(double)` function to each entry.
`RealVector` | `mapUlpToSelf()` Map the `Math.ulp(double)` function to each entry.
`RealMatrix` | `outerProduct(ArrayRealVector v)` Compute the outer product.
`RealMatrix` | `outerProduct(double[] v)` Compute the outer product.
`RealMatrix` | `outerProduct(RealVector v)` Compute the outer product.
`ArrayRealVector` | `projection(ArrayRealVector v)` Find the orthogonal projection of this vector onto another vector.
`RealVector` | `projection(double[] v)` Find the orthogonal projection of this vector onto another vector.
`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` | `set(int index, ArrayRealVector v)` Set a set of consecutive elements.
`void` | `setEntry(int index, double value)` Set a single element.
`void` | `setSubVector(int index, double[] v)` Set a set of consecutive elements.
`void` | `setSubVector(int index, RealVector v)` Set a set of consecutive elements.
`ArrayRealVector` | `subtract(ArrayRealVector v)` Compute this minus v.
`RealVector` | `subtract(double[] v)` Compute this minus v.
`RealVector` | `subtract(RealVector v)` Compute this minus v.
`double[]` | `toArray()` Convert the vector to a double array.
`java.lang.String` | `toString()`
`void` | `unitize()` Converts this vector into a unit vector.
`RealVector` | `unitVector()` Creates a unit vector pointing in the direction of this vector.

Methods inherited from class org.apache.commons.math.linear.AbstractRealVector
`checkIndex, getMaxIndex, getMaxValue, getMinIndex, getMinValue, iterator, map, mapAbs, mapAcos, mapAdd, mapAsin, mapAtan, mapCbrt, mapCeil, mapCos, mapCosh, mapDivide, mapExp, mapExpm1, mapFloor, mapInv, mapLog, mapLog10, mapLog1p, mapMultiply, mapPow, mapRint, mapSignum, mapSin, mapSinh, mapSqrt, mapSubtract, mapTan, mapTanh, mapToSelf, mapUlp, sparseIterator`

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

Field Detail

### NON_FITTING_POSITION_AND_SIZE_MESSAGE

    private static final java.lang.String NON_FITTING_POSITION_AND_SIZE_MESSAGE

  Message for non fitting position and size.

  See Also:
    Constant Field Values

### serialVersionUID

    private static final long serialVersionUID

  Serializable version identifier.

  See Also:
    Constant Field Values

### DEFAULT_FORMAT

    private static final RealVectorFormat DEFAULT_FORMAT

  Default format.

### data

    protected double[] data

  Entries of the vector.

Constructor Detail

### ArrayRealVector

    public ArrayRealVector()

  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 `ArrayRealVector(ArrayRealVector, ArrayRealVector)` constructor or one of the `append` method (`append(double)`, `append(double[])`, `append(ArrayRealVector)`) to gather data into this vector.

### ArrayRealVector

    public ArrayRealVector(int size)

  Construct a (size)-length vector of zeros.

  Parameters:
    `size` - size of the vector

### ArrayRealVector

    public ArrayRealVector(int size,
                           double preset)

  Construct an (size)-length vector with preset values.

  Parameters:
    `size` - size of the vector
    `preset` - fill the vector with this scalar value

### ArrayRealVector

    public ArrayRealVector(double[] d)

  Construct a vector from an array, copying the input array.

  Parameters:
    `d` - array of doubles.

### ArrayRealVector

    public ArrayRealVector(double[] d,
                           boolean copyArray)
                    throws java.lang.NullPointerException,
                           java.lang.IllegalArgumentException

  Create a new ArrayRealVector using the input array as the underlying data array.

  If an array is built specially in order to be embedded in a ArrayRealVector and not used directly, the `copyArray` may be set to `false`

  Parameters:
    `d` - data for new vector
    `copyArray` - if true, the input array will be copied, otherwise it will be referenced
  Throws:
    `java.lang.IllegalArgumentException` - if `d` is empty
    `java.lang.NullPointerException` - if `d` is null
  See Also:
    `ArrayRealVector(double[])`

### ArrayRealVector

    public ArrayRealVector(double[] d,
                           int pos,
                           int size)

  Construct a vector from part of a array.

  Parameters:
    `d` - array of doubles.
    `pos` - position of first entry
    `size` - number of entries to copy

### ArrayRealVector

    public ArrayRealVector(java.lang.Double[] d)

  Construct a vector from an array.

  Parameters:
    `d` - array of Doubles.

### ArrayRealVector

    public ArrayRealVector(java.lang.Double[] d,
                           int pos,
                           int size)

  Construct a vector from part of a Double array

  Parameters:
    `d` - array of Doubles.
    `pos` - position of first entry
    `size` - number of entries to copy

### ArrayRealVector

    public ArrayRealVector(RealVector v)

  Construct a vector from another vector, using a deep copy.

  Parameters:
    `v` - vector to copy

### ArrayRealVector

    public ArrayRealVector(ArrayRealVector v)

  Construct a vector from another vector, using a deep copy.

  Parameters:
    `v` - vector to copy

### ArrayRealVector

    public ArrayRealVector(ArrayRealVector v,
                           boolean deep)

  Construct a vector from another vector.

  Parameters:
    `v` - vector to copy
    `deep` - if true perform a deep copy otherwise perform a shallow copy

### ArrayRealVector

    public ArrayRealVector(ArrayRealVector v1,
                           ArrayRealVector v2)

  Construct a vector by appending one vector to another vector.

  Parameters:
    `v1` - first vector (will be put in front of the new vector)
    `v2` - second vector (will be put at back of the new vector)

### ArrayRealVector

    public ArrayRealVector(ArrayRealVector v1,
                           RealVector v2)

  Construct a vector by appending one vector to another vector.

  Parameters:
    `v1` - first vector (will be put in front of the new vector)
    `v2` - second vector (will be put at back of the new vector)

### ArrayRealVector

    public ArrayRealVector(RealVector v1,
                           ArrayRealVector v2)

  Construct a vector by appending one vector to another vector.

  Parameters:
    `v1` - first vector (will be put in front of the new vector)
    `v2` - second vector (will be put at back of the new vector)

### ArrayRealVector

    public ArrayRealVector(ArrayRealVector v1,
                           double[] v2)

  Construct a vector by appending one vector to another vector.

  Parameters:
    `v1` - first vector (will be put in front of the new vector)
    `v2` - second vector (will be put at back of the new vector)

### ArrayRealVector

    public ArrayRealVector(double[] v1,
                           ArrayRealVector v2)

  Construct a vector by appending one vector to another vector.

  Parameters:
    `v1` - first vector (will be put in front of the new vector)
    `v2` - second vector (will be put at back of the new vector)

### ArrayRealVector

    public ArrayRealVector(double[] v1,
                           double[] v2)

  Construct a vector by appending one vector to another vector.

  Parameters:
    `v1` - first vector (will be put in front of the new vector)
    `v2` - second vector (will be put at back of the new vector)

Method Detail

### copy

    public AbstractRealVector copy()

  Returns a (deep) copy of this.

  Specified by:
    `copy` in interface `RealVector`
  Specified by:
    `copy` in class `AbstractRealVector`
  Returns:
    vector copy

### add

    public RealVector add(RealVector v)
                   throws java.lang.IllegalArgumentException

  Compute the sum of this and v.

  Specified by:
    `add` in interface `RealVector`
  Overrides:
    `add` in class `AbstractRealVector`
  Parameters:
    `v` - vector to be added
  Returns:
    this + v
  Throws:
    `java.lang.IllegalArgumentException` - if v is not the same size as this

### add

    public RealVector add(double[] v)
                   throws java.lang.IllegalArgumentException

  Compute the sum of this and v.

  Specified by:
    `add` in interface `RealVector`
  Overrides:
    `add` in class `AbstractRealVector`
  Parameters:
    `v` - vector to be added
  Returns:
    this + v
  Throws:
    `java.lang.IllegalArgumentException` - if v is not the same size as this

### add

    public ArrayRealVector add(ArrayRealVector v)
                        throws java.lang.IllegalArgumentException

  Compute the sum of this and v.

  Parameters:
    `v` - vector to be added
  Returns:
    this + v
  Throws:
    `java.lang.IllegalArgumentException` - if v is not the same size as this

### subtract

    public RealVector subtract(RealVector v)
                        throws java.lang.IllegalArgumentException

  Compute this minus v.

  Specified by:
    `subtract` in interface `RealVector`
  Overrides:
    `subtract` in class `AbstractRealVector`
  Parameters:
    `v` - vector to be subtracted
  Returns:
    this + v
  Throws:
    `java.lang.IllegalArgumentException` - if v is not the same size as this

### subtract

    public RealVector subtract(double[] v)
                        throws java.lang.IllegalArgumentException

  Compute this minus v.

  Specified by:
    `subtract` in interface `RealVector`
  Overrides:
    `subtract` in class `AbstractRealVector`
  Parameters:
    `v` - vector to be subtracted
  Returns:
    this + v
  Throws:
    `java.lang.IllegalArgumentException` - if v is not the same size as this

### subtract

    public ArrayRealVector subtract(ArrayRealVector v)
                             throws java.lang.IllegalArgumentException

  Compute this minus v.

  Parameters:
    `v` - vector to be subtracted
  Returns:
    this + v
  Throws:
    `java.lang.IllegalArgumentException` - if v is not the same size as this

### mapAddToSelf

    public RealVector mapAddToSelf(double d)

  Map an addition operation to each entry.

  The instance is changed by this method.

  Specified by:
    `mapAddToSelf` in interface `RealVector`
  Overrides:
    `mapAddToSelf` in class `AbstractRealVector`
  Parameters:
    `d` - value to be added to each entry
  Returns:
    for convenience, return this

### mapSubtractToSelf

    public RealVector mapSubtractToSelf(double d)

  Map a subtraction operation to each entry.

  The instance is changed by this method.

  Specified by:
    `mapSubtractToSelf` in interface `RealVector`
  Overrides:
    `mapSubtractToSelf` in class `AbstractRealVector`
  Parameters:
    `d` - value to be subtracted to each entry
  Returns:
    for convenience, return this

### mapMultiplyToSelf

    public RealVector mapMultiplyToSelf(double d)

  Map a multiplication operation to each entry.

  The instance is changed by this method.

  Specified by:
    `mapMultiplyToSelf` in interface `RealVector`
  Overrides:
    `mapMultiplyToSelf` in class `AbstractRealVector`
  Parameters:
    `d` - value to multiply all entries by
  Returns:
    for convenience, return this

### mapDivideToSelf

    public RealVector mapDivideToSelf(double d)

  Map a division operation to each entry.

  The instance is changed by this method.

  Specified by:
    `mapDivideToSelf` in interface `RealVector`
  Overrides:
    `mapDivideToSelf` in class `AbstractRealVector`
  Parameters:
    `d` - value to divide all entries by
  Returns:
    for convenience, return this

### mapPowToSelf

    public RealVector mapPowToSelf(double d)

  Map a power operation to each entry.

  The instance is changed by this method.

  Specified by:
    `mapPowToSelf` in interface `RealVector`
  Overrides:
    `mapPowToSelf` in class `AbstractRealVector`
  Parameters:
    `d` - value to raise all entries to
  Returns:
    for convenience, return this

### mapExpToSelf

    public RealVector mapExpToSelf()

  Map the `Math.exp(double)` function to each entry.

  The instance is changed by this method.

  Specified by:
    `mapExpToSelf` in interface `RealVector`
  Overrides:
    `mapExpToSelf` in class `AbstractRealVector`
  Returns:
    for convenience, return this

### mapExpm1ToSelf

    public RealVector mapExpm1ToSelf()

  Map the `Math.expm1(double)` function to each entry.

  The instance is changed by this method.

  Specified by:
    `mapExpm1ToSelf` in interface `RealVector`
  Overrides:
    `mapExpm1ToSelf` in class `AbstractRealVector`
  Returns:
    for convenience, return this

### mapLogToSelf

    public RealVector mapLogToSelf()

  Map the `Math.log(double)` function to each entry.

  The instance is changed by this method.

  Specified by:
    `mapLogToSelf` in interface `RealVector`
  Overrides:
    `mapLogToSelf` in class `AbstractRealVector`
  Returns:
    for convenience, return this

### mapLog10ToSelf

    public RealVector mapLog10ToSelf()

  Map the `Math.log10(double)` function to each entry.

  The instance is changed by this method.

  Specified by:
    `mapLog10ToSelf` in interface `RealVector`
  Overrides:
    `mapLog10ToSelf` in class `AbstractRealVector`
  Returns:
    for convenience, return this

### mapLog1pToSelf

    public RealVector mapLog1pToSelf()

  Map the `Math.log1p(double)` function to each entry.

  The instance is changed by this method.

  Specified by:
    `mapLog1pToSelf` in interface `RealVector`
  Overrides:
    `mapLog1pToSelf` in class `AbstractRealVector`
  Returns:
    for convenience, return this

### mapCoshToSelf

    public RealVector mapCoshToSelf()

  Map the `Math.cosh(double)` function to each entry.

  The instance is changed by this method.

  Specified by:
    `mapCoshToSelf` in interface `RealVector`
  Overrides:
    `mapCoshToSelf` in class `AbstractRealVector`
  Returns:
    for convenience, return this

### mapSinhToSelf

    public RealVector mapSinhToSelf()

  Map the `Math.sinh(double)` function to each entry.

  The instance is changed by this method.

  Specified by:
    `mapSinhToSelf` in interface `RealVector`
  Overrides:
    `mapSinhToSelf` in class `AbstractRealVector`
  Returns:
    for convenience, return this

### mapTanhToSelf

    public RealVector mapTanhToSelf()

  Map the `Math.tanh(double)` function to each entry.

  The instance is changed by this method.

  Specified by:
    `mapTanhToSelf` in interface `RealVector`
  Overrides:
    `mapTanhToSelf` in class `AbstractRealVector`
  Returns:
    for convenience, return this

### mapCosToSelf

    public RealVector mapCosToSelf()

  Map the `Math.cos(double)` function to each entry.

  The instance is changed by this method.

  Specified by:
    `mapCosToSelf` in interface `RealVector`
  Overrides:
    `mapCosToSelf` in class `AbstractRealVector`
  Returns:
    for convenience, return this

### mapSinToSelf

    public RealVector mapSinToSelf()

  Map the `Math.sin(double)` function to each entry.

  The instance is changed by this method.

  Specified by:
    `mapSinToSelf` in interface `RealVector`
  Overrides:
    `mapSinToSelf` in class `AbstractRealVector`
  Returns:
    for convenience, return this

### mapTanToSelf

    public RealVector mapTanToSelf()

  Map the `Math.tan(double)` function to each entry.

  The instance is changed by this method.

  Specified by:
    `mapTanToSelf` in interface `RealVector`
  Overrides:
    `mapTanToSelf` in class `AbstractRealVector`
  Returns:
    for convenience, return this

### mapAcosToSelf

    public RealVector mapAcosToSelf()

  Map the `Math.acos(double)` function to each entry.

  The instance is changed by this method.

  Specified by:
    `mapAcosToSelf` in interface `RealVector`
  Overrides:
    `mapAcosToSelf` in class `AbstractRealVector`
  Returns:
    for convenience, return this

### mapAsinToSelf

    public RealVector mapAsinToSelf()

  Map the `Math.asin(double)` function to each entry.

  The instance is changed by this method.

  Specified by:
    `mapAsinToSelf` in interface `RealVector`
  Overrides:
    `mapAsinToSelf` in class `AbstractRealVector`
  Returns:
    for convenience, return this

### mapAtanToSelf

    public RealVector mapAtanToSelf()

  Map the `Math.atan(double)` function to each entry.

  The instance is changed by this method.

  Specified by:
    `mapAtanToSelf` in interface `RealVector`
  Overrides:
    `mapAtanToSelf` in class `AbstractRealVector`
  Returns:
    for convenience, return this

### mapInvToSelf

    public RealVector mapInvToSelf()

  Map the 1/x function to each entry.

  The instance is changed by this method.

  Specified by:
    `mapInvToSelf` in interface `RealVector`
  Overrides:
    `mapInvToSelf` in class `AbstractRealVector`
  Returns:
    for convenience, return this

### mapAbsToSelf

    public RealVector mapAbsToSelf()

  Map the `Math.abs(double)` function to each entry.

  The instance is changed by this method.

  Specified by:
    `mapAbsToSelf` in interface `RealVector`
  Overrides:
    `mapAbsToSelf` in class `AbstractRealVector`
  Returns:
    for convenience, return this

### mapSqrtToSelf

    public RealVector mapSqrtToSelf()

  Map the `Math.sqrt(double)` function to each entry.

  The instance is changed by this method.

  Specified by:
    `mapSqrtToSelf` in interface `RealVector`
  Overrides:
    `mapSqrtToSelf` in class `AbstractRealVector`
  Returns:
    for convenience, return this

### mapCbrtToSelf

    public RealVector mapCbrtToSelf()

  Map the `Math.cbrt(double)` function to each entry.

  The instance is changed by this method.

  Specified by:
    `mapCbrtToSelf` in interface `RealVector`
  Overrides:
    `mapCbrtToSelf` in class `AbstractRealVector`
  Returns:
    for convenience, return this

### mapCeilToSelf

    public RealVector mapCeilToSelf()

  Map the `Math.ceil(double)` function to each entry.

  The instance is changed by this method.

  Specified by:
    `mapCeilToSelf` in interface `RealVector`
  Overrides:
    `mapCeilToSelf` in class `AbstractRealVector`
  Returns:
    for convenience, return this

### mapFloorToSelf

    public RealVector mapFloorToSelf()

  Map the `Math.floor(double)` function to each entry.

  The instance is changed by this method.

  Specified by:
    `mapFloorToSelf` in interface `RealVector`
  Overrides:
    `mapFloorToSelf` in class `AbstractRealVector`
  Returns:
    for convenience, return this

### mapRintToSelf

    public RealVector mapRintToSelf()

  Map the `Math.rint(double)` function to each entry.

  The instance is changed by this method.

  Specified by:
    `mapRintToSelf` in interface `RealVector`
  Overrides:
    `mapRintToSelf` in class `AbstractRealVector`
  Returns:
    for convenience, return this

### mapSignumToSelf

    public RealVector mapSignumToSelf()

  Map the `Math.signum(double)` function to each entry.

  The instance is changed by this method.

  Specified by:
    `mapSignumToSelf` in interface `RealVector`
  Overrides:
    `mapSignumToSelf` in class `AbstractRealVector`
  Returns:
    for convenience, return this

### mapUlpToSelf

    public RealVector mapUlpToSelf()

  Map the `Math.ulp(double)` function to each entry.

  The instance is changed by this method.

  Specified by:
    `mapUlpToSelf` in interface `RealVector`
  Overrides:
    `mapUlpToSelf` in class `AbstractRealVector`
  Returns:
    for convenience, return this

### ebeMultiply

    public RealVector ebeMultiply(RealVector v)
                           throws java.lang.IllegalArgumentException

  Element-by-element multiplication.

  Specified by:
    `ebeMultiply` in interface `RealVector`
  Parameters:
    `v` - vector by which instance elements must be multiplied
  Returns:
    a vector containing this[i] * v[i] for all i
  Throws:
    `java.lang.IllegalArgumentException` - if v is not the same size as this

### ebeMultiply

    public RealVector ebeMultiply(double[] v)
                           throws java.lang.IllegalArgumentException

  Element-by-element multiplication.

  Specified by:
    `ebeMultiply` in interface `RealVector`
  Overrides:
    `ebeMultiply` in class `AbstractRealVector`
  Parameters:
    `v` - vector by which instance elements must be multiplied
  Returns:
    a vector containing this[i] * v[i] for all i
  Throws:
    `java.lang.IllegalArgumentException` - if v is not the same size as this

### ebeMultiply

    public ArrayRealVector ebeMultiply(ArrayRealVector v)
                                throws java.lang.IllegalArgumentException

  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:
    `java.lang.IllegalArgumentException` - if v is not the same size as this

### ebeDivide

    public RealVector ebeDivide(RealVector v)
                         throws java.lang.IllegalArgumentException

  Element-by-element division.

  Specified by:
    `ebeDivide` in interface `RealVector`
  Parameters:
    `v` - vector by which instance elements must be divided
  Returns:
    a vector containing this[i] / v[i] for all i
  Throws:
    `java.lang.IllegalArgumentException` - if v is not the same size as this

### ebeDivide

    public RealVector ebeDivide(double[] v)
                         throws java.lang.IllegalArgumentException

  Element-by-element division.

  Specified by:
    `ebeDivide` in interface `RealVector`
  Overrides:
    `ebeDivide` in class `AbstractRealVector`
  Parameters:
    `v` - vector by which instance elements must be divided
  Returns:
    a vector containing this[i] / v[i] for all i
  Throws:
    `java.lang.IllegalArgumentException` - if v is not the same size as this

### ebeDivide

    public ArrayRealVector ebeDivide(ArrayRealVector v)
                              throws java.lang.IllegalArgumentException

  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:
    `java.lang.IllegalArgumentException` - if v is not the same size as this

### getData

    public double[] getData()

  Returns vector entries as a double array.

  Specified by:
    `getData` in interface `RealVector`
  Overrides:
    `getData` in class `AbstractRealVector`
  Returns:
    double array of entries

### getDataRef

    public double[] getDataRef()

  Returns a reference to the underlying data array.

  Does not make a fresh copy of the underlying data.

  Returns:
    array of entries

### dotProduct

    public double dotProduct(RealVector v)
                      throws java.lang.IllegalArgumentException

  Compute the dot product.

  Specified by:
    `dotProduct` in interface `RealVector`
  Overrides:
    `dotProduct` in class `AbstractRealVector`
  Parameters:
    `v` - vector with which dot product should be computed
  Returns:
    the scalar dot product between instance and v
  Throws:
    `java.lang.IllegalArgumentException` - if v is not the same size as this

### dotProduct

    public double dotProduct(double[] v)
                      throws java.lang.IllegalArgumentException

  Compute the dot product.

  Specified by:
    `dotProduct` in interface `RealVector`
  Overrides:
    `dotProduct` in class `AbstractRealVector`
  Parameters:
    `v` - vector with which dot product should be computed
  Returns:
    the scalar dot product between instance and v
  Throws:
    `java.lang.IllegalArgumentException` - if v is not the same size as this

### dotProduct

    public double dotProduct(ArrayRealVector v)
                      throws java.lang.IllegalArgumentException

  Compute the dot product.

  Parameters:
    `v` - vector with which dot product should be computed
  Returns:
    the scalar dot product between instance and v
  Throws:
    `java.lang.IllegalArgumentException` - if v is not the same size as this

### getNorm

    public double getNorm()

  Returns the L2 norm of the vector.

  The L2 norm is the root of the sum of the squared elements.

  Specified by:
    `getNorm` in interface `RealVector`
  Overrides:
    `getNorm` in class `AbstractRealVector`
  Returns:
    norm
  See Also:
    `RealVector.getL1Norm()`, `RealVector.getLInfNorm()`, `RealVector.getDistance(RealVector)`

### getL1Norm

    public double getL1Norm()

  Returns the L1 norm of the vector.

  The L1 norm is the sum of the absolute values of elements.

  Specified by:
    `getL1Norm` in interface `RealVector`
  Overrides:
    `getL1Norm` in class `AbstractRealVector`
  Returns:
    norm
  See Also:
    `RealVector.getNorm()`, `RealVector.getLInfNorm()`, `RealVector.getL1Distance(RealVector)`

### getLInfNorm

    public double getLInfNorm()

  Returns the L∞ norm of the vector.

  The L∞ norm is the max of the absolute values of elements.

  Specified by:
    `getLInfNorm` in interface `RealVector`
  Overrides:
    `getLInfNorm` in class `AbstractRealVector`
  Returns:
    norm
  See Also:
    `RealVector.getNorm()`, `RealVector.getL1Norm()`, `RealVector.getLInfDistance(RealVector)`

### getDistance

    public double getDistance(RealVector v)
                       throws java.lang.IllegalArgumentException

  Distance between two vectors.

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

  Specified by:
    `getDistance` in interface `RealVector`
  Overrides:
    `getDistance` in class `AbstractRealVector`
  Parameters:
    `v` - vector to which distance is requested
  Returns:
    distance between two vectors.
  Throws:
    `java.lang.IllegalArgumentException` - if v is not the same size as this
  See Also:
    `RealVector.getL1Distance(RealVector)`, `RealVector.getLInfDistance(RealVector)`, `RealVector.getNorm()`

### getDistance

    public double getDistance(double[] v)
                       throws java.lang.IllegalArgumentException

  Distance between two vectors.

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

  Specified by:
    `getDistance` in interface `RealVector`
  Overrides:
    `getDistance` in class `AbstractRealVector`
  Parameters:
    `v` - vector to which distance is requested
  Returns:
    distance between two vectors.
  Throws:
    `java.lang.IllegalArgumentException` - if v is not the same size as this
  See Also:
    `RealVector.getL1Distance(double[])`, `RealVector.getLInfDistance(double[])`, `RealVector.getNorm()`

### getDistance

    public double getDistance(ArrayRealVector v)
                       throws java.lang.IllegalArgumentException

  Distance between two vectors.

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

  Parameters:
    `v` - vector to which distance is requested
  Returns:
    distance between two vectors.
  Throws:
    `java.lang.IllegalArgumentException` - if v is not the same size as this
  See Also:
    `getDistance(RealVector)`, `getL1Distance(ArrayRealVector)`, `getLInfDistance(ArrayRealVector)`, `getNorm()`

### getL1Distance

    public double getL1Distance(RealVector v)
                         throws java.lang.IllegalArgumentException

  Distance between two vectors.

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

  Specified by:
    `getL1Distance` in interface `RealVector`
  Overrides:
    `getL1Distance` in class `AbstractRealVector`
  Parameters:
    `v` - vector to which distance is requested
  Returns:
    distance between two vectors.
  Throws:
    `java.lang.IllegalArgumentException` - if v is not the same size as this
  See Also:
    `RealVector.getDistance(RealVector)`, `RealVector.getLInfDistance(RealVector)`, `RealVector.getL1Norm()`

### getL1Distance

    public double getL1Distance(double[] v)
                         throws java.lang.IllegalArgumentException

  Distance between two vectors.

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

  Specified by:
    `getL1Distance` in interface `RealVector`
  Overrides:
    `getL1Distance` in class `AbstractRealVector`
  Parameters:
    `v` - vector to which distance is requested
  Returns:
    distance between two vectors.
  Throws:
    `java.lang.IllegalArgumentException` - if v is not the same size as this
  See Also:
    `RealVector.getDistance(double[])`, `RealVector.getLInfDistance(double[])`, `RealVector.getL1Norm()`

### getL1Distance

    public double getL1Distance(ArrayRealVector v)
                         throws java.lang.IllegalArgumentException

  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 two vectors.
  Throws:
    `java.lang.IllegalArgumentException` - if v is not the same size as this
  See Also:
    `getDistance(RealVector)`, `getL1Distance(ArrayRealVector)`, `getLInfDistance(ArrayRealVector)`, `getNorm()`

### getLInfDistance

    public double getLInfDistance(RealVector v)
                           throws java.lang.IllegalArgumentException

  Distance between two vectors.

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

  Specified by:
    `getLInfDistance` in interface `RealVector`
  Overrides:
    `getLInfDistance` in class `AbstractRealVector`
  Parameters:
    `v` - vector to which distance is requested
  Returns:
    distance between two vectors.
  Throws:
    `java.lang.IllegalArgumentException` - if v is not the same size as this
  See Also:
    `RealVector.getDistance(RealVector)`, `RealVector.getL1Distance(RealVector)`, `RealVector.getLInfNorm()`

### getLInfDistance

    public double getLInfDistance(double[] v)
                           throws java.lang.IllegalArgumentException

  Distance between two vectors.

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

  Specified by:
    `getLInfDistance` in interface `RealVector`
  Overrides:
    `getLInfDistance` in class `AbstractRealVector`
  Parameters:
    `v` - vector to which distance is requested
  Returns:
    distance between two vectors.
  Throws:
    `java.lang.IllegalArgumentException` - if v is not the same size as this
  See Also:
    `RealVector.getDistance(double[])`, `RealVector.getL1Distance(double[])`, `RealVector.getLInfNorm()`

### getLInfDistance

    public double getLInfDistance(ArrayRealVector v)
                           throws java.lang.IllegalArgumentException

  Distance between two vectors.

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

  Parameters:
    `v` - vector to which distance is requested
  Returns:
    distance between two vectors.
  Throws:
    `java.lang.IllegalArgumentException` - if v is not the same size as this
  See Also:
    `getDistance(RealVector)`, `getL1Distance(ArrayRealVector)`, `getLInfDistance(ArrayRealVector)`, `getNorm()`

### unitVector

    public RealVector unitVector()
                          throws java.lang.ArithmeticException

  Creates a unit vector pointing in the direction of this vector.

  The instance is not changed by this method.

  Specified by:
    `unitVector` in interface `RealVector`
  Overrides:
    `unitVector` in class `AbstractRealVector`
  Returns:
    a unit vector pointing in direction of this vector
  Throws:
    `java.lang.ArithmeticException` - if the norm is null

### unitize

    public void unitize()
                 throws java.lang.ArithmeticException

  Converts this vector into a unit vector.

  The instance itself is changed by this method.

  Specified by:
    `unitize` in interface `RealVector`
  Overrides:
    `unitize` in class `AbstractRealVector`
  Throws:
    `java.lang.ArithmeticException` - if the norm is null

### projection

    public RealVector projection(RealVector v)

  Find the orthogonal projection of this vector onto another vector.

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

### projection

    public RealVector projection(double[] v)

  Find the orthogonal projection of this vector onto another vector.

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

### projection

    public ArrayRealVector projection(ArrayRealVector v)

  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:
    `java.lang.IllegalArgumentException` - if v is not the same size as this

### outerProduct

    public RealMatrix outerProduct(RealVector v)
                            throws java.lang.IllegalArgumentException

  Compute the outer product.

  Specified by:
    `outerProduct` in interface `RealVector`
  Overrides:
    `outerProduct` in class `AbstractRealVector`
  Parameters:
    `v` - vector with which outer product should be computed
  Returns:
    the square matrix outer product between instance and v
  Throws:
    `java.lang.IllegalArgumentException` - if v is not the same size as this

### outerProduct

    public RealMatrix outerProduct(ArrayRealVector v)
                            throws java.lang.IllegalArgumentException

  Compute the outer product.

  Parameters:
    `v` - vector with which outer product should be computed
  Returns:
    the square matrix outer product between instance and v
  Throws:
    `java.lang.IllegalArgumentException` - if v is not the same size as this

### outerProduct

    public RealMatrix outerProduct(double[] v)
                            throws java.lang.IllegalArgumentException

  Compute the outer product.

  Specified by:
    `outerProduct` in interface `RealVector`
  Overrides:
    `outerProduct` in class `AbstractRealVector`
  Parameters:
    `v` - vector with which outer product should be computed
  Returns:
    the square matrix outer product between instance and v
  Throws:
    `java.lang.IllegalArgumentException` - if v is not the same size as this

### getEntry

    public double getEntry(int index)
                    throws MatrixIndexException

  Returns the entry in the specified index.

  The index start at 0 and must be lesser than the size, otherwise a `MatrixIndexException` is thrown.

  Specified by:
    `getEntry` in interface `RealVector`
  Parameters:
    `index` - index location of entry to be fetched
  Returns:
    vector entry at index
  Throws:
    `MatrixIndexException` - if the index is not valid
  See Also:
    `RealVector.setEntry(int, double)`

### getDimension

    public int getDimension()

  Returns the size of the vector.

  Specified by:
    `getDimension` in interface `RealVector`
  Returns:
    size

### append

    public RealVector append(RealVector v)

  Construct a vector by appending a vector to this vector.

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

### append

    public ArrayRealVector append(ArrayRealVector v)

  Construct a vector by appending a vector to this vector.

  Parameters:
    `v` - vector to append to this one.
  Returns:
    a new vector

### append

    public RealVector append(double in)

  Construct a vector by appending a double to this vector.

  Specified by:
    `append` in interface `RealVector`
  Parameters:
    `in` - double to append.
  Returns:
    a new vector

### append

    public RealVector append(double[] in)

  Construct a vector by appending a double array to this vector.

  Specified by:
    `append` in interface `RealVector`
  Parameters:
    `in` - double array to append.
  Returns:
    a new vector

### getSubVector

    public RealVector getSubVector(int index,
                                   int n)

  Get a subvector from consecutive elements.

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

### setEntry

    public void setEntry(int index,
                         double value)

  Set a single element.

  Specified by:
    `setEntry` in interface `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 set of consecutive elements.

  Specified by:
    `setSubVector` in interface `RealVector`
  Overrides:
    `setSubVector` in class `AbstractRealVector`
  Parameters:
    `index` - index of first element to be set.
    `v` - vector containing the values to set.
  See Also:
    `RealVector.setSubVector(int, double[])`

### setSubVector

    public void setSubVector(int index,
                             double[] v)

  Set a set of consecutive elements.

  Specified by:
    `setSubVector` in interface `RealVector`
  Overrides:
    `setSubVector` in class `AbstractRealVector`
  Parameters:
    `index` - index of first element to be set.
    `v` - vector containing the values to set.
  See Also:
    `RealVector.setSubVector(int, RealVector)`

### set

    public void set(int index,
                    ArrayRealVector v)
             throws MatrixIndexException

  Set a set of consecutive elements.

  Parameters:
    `index` - index of first element to be set.
    `v` - vector containing the values to set.
  Throws:
    `MatrixIndexException` - if the index is inconsistent with vector size

### set

    public void set(double value)

  Set all elements to a single value.

  Specified by:
    `set` in interface `RealVector`
  Overrides:
    `set` in class `AbstractRealVector`
  Parameters:
    `value` - single value to set for all elements

### toArray

    public double[] toArray()

  Convert the vector to a double array.

  The array is independent from vector data, it's elements are copied.

  Specified by:
    `toArray` in interface `RealVector`
  Overrides:
    `toArray` in class `AbstractRealVector`
  Returns:
    array containing a copy of vector elements

### toString

    public java.lang.String toString()

  Overrides:
    `toString` in class `java.lang.Object`

### checkVectorDimensions

    protected void checkVectorDimensions(RealVector v)
                                  throws java.lang.IllegalArgumentException

  Check if instance and specified vectors have the same dimension.

  Overrides:
    `checkVectorDimensions` in class `AbstractRealVector`
  Parameters:
    `v` - vector to compare instance with
  Throws:
    `java.lang.IllegalArgumentException` - if the vectors do not have the same dimension

### checkVectorDimensions

    protected void checkVectorDimensions(int n)
                                  throws java.lang.IllegalArgumentException

  Check if instance dimension is equal to some expected value.

  Overrides:
    `checkVectorDimensions` in class `AbstractRealVector`
  Parameters:
    `n` - expected dimension.
  Throws:
    `java.lang.IllegalArgumentException` - if the dimension is inconsistent with vector size

### isNaN

    public boolean isNaN()

  Returns true if any coordinate of this vector is NaN; false otherwise

  Specified by:
    `isNaN` in interface `RealVector`
  Returns:
    true if any coordinate of this vector is NaN; false otherwise

### isInfinite

    public boolean isInfinite()

  Returns true if any coordinate of this vector is infinite and none are NaN; false otherwise

  Specified by:
    `isInfinite` in interface `RealVector`
  Returns:
    true if any coordinate of this vector is infinite and none are NaN; false otherwise

### equals

    public boolean equals(java.lang.Object other)

  Test for the equality of two real vectors.

  If all coordinates of two real vectors are exactly the same, and none are `Double.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 `Double.NaN`, the real vector is equal to a vector with all `Double.NaN` coordinates.

  Overrides:
    `equals` in class `java.lang.Object`
  Parameters:
    `other` - Object to test for equality to this
  Returns:
    true if two vector objects are equal, false if object is null, not an instance of RealVector, or not equal to this RealVector instance

### hashCode

    public int hashCode()

  Get a hashCode for the real vector.

  All NaN values have the same hash code.

  Overrides:
    `hashCode` in class `java.lang.Object`
  Returns:
    a hash code value for this object

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright (c) 2003-2011 Apache Software Foundation