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

## org.apache.commons.math3.geometry.euclidean.oned
Class Vector1D

    java.lang.Object
      org.apache.commons.math3.geometry.euclidean.oned.Vector1D

All Implemented Interfaces:
  Serializable, Vector<Euclidean1D>

    public class Vector1D

extends Object
implements Vector<Euclidean1D>

This class represents a 1D vector.

Instances of this class are guaranteed to be immutable.

Since:
  3.0
Version:
  $Id: Vector1D.java 1416643 2012-12-03 19:37:14Z tn $
See Also:
  Serialized Form

Field Summary
`static Vector1D` | `NaN` A vector with all coordinates set to NaN.
`static Vector1D` | `NEGATIVE_INFINITY` A vector with all coordinates set to negative infinity.
`static Vector1D` | `ONE` Unit (coordinates: 1).
`static Vector1D` | `POSITIVE_INFINITY` A vector with all coordinates set to positive infinity.
`static Vector1D` | `ZERO` Origin (coordinates: 0).

Constructor Summary
`Vector1D(double x)` Simple constructor.
`Vector1D(double a, Vector1D u)` Multiplicative constructor Build a vector from another one and a scale factor.
`Vector1D(double a1, Vector1D u1, double a2, Vector1D u2)` Linear constructor Build a vector from two other ones and corresponding scale factors.
`Vector1D(double a1, Vector1D u1, double a2, Vector1D u2, double a3, Vector1D u3)` Linear constructor Build a vector from three other ones and corresponding scale factors.
`Vector1D(double a1, Vector1D u1, double a2, Vector1D u2, double a3, Vector1D u3, double a4, Vector1D u4)` Linear constructor Build a vector from four other ones and corresponding scale factors.

Method Summary
`Vector1D` | `add(double factor, Vector<Euclidean1D> v)` Add a scaled vector to the instance.
`Vector1D` | `add(Vector<Euclidean1D> v)` Add a vector to the instance.
`double` | `distance(Vector<Euclidean1D> p)` Compute the distance between the instance and another vector according to the L2 norm.
`static double` | `distance(Vector1D p1, Vector1D p2)` Compute the distance between two vectors according to the L2 norm.
`double` | `distance1(Vector<Euclidean1D> p)` Compute the distance between the instance and another vector according to the L1 norm.
`double` | `distanceInf(Vector<Euclidean1D> p)` Compute the distance between the instance and another vector according to the L∞ norm.
`static double` | `distanceInf(Vector1D p1, Vector1D p2)` Compute the distance between two vectors according to the L∞ norm.
`double` | `distanceSq(Vector<Euclidean1D> p)` Compute the square of the distance between the instance and another vector.
`static double` | `distanceSq(Vector1D p1, Vector1D p2)` Compute the square of the distance between two vectors.
`double` | `dotProduct(Vector<Euclidean1D> v)` Compute the dot-product of the instance and another vector.
`boolean` | `equals(Object other)` Test for the equality of two 1D vectors.
`double` | `getNorm()` Get the L2 norm for the vector.
`double` | `getNorm1()` Get the L1 norm for the vector.
`double` | `getNormInf()` Get the L∞ norm for the vector.
`double` | `getNormSq()` Get the square of the norm for the vector.
`Space` | `getSpace()` Get the space to which the vector belongs.
`double` | `getX()` Get the abscissa of the vector.
`Vector1D` | `getZero()` Get the null vector of the vectorial space or origin point of the affine space.
`int` | `hashCode()` Get a hashCode for the 1D 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
`Vector1D` | `negate()` Get the opposite of the instance.
`Vector1D` | `normalize()` Get a normalized vector aligned with the instance.
`Vector1D` | `scalarMultiply(double a)` Multiply the instance by a scalar.
`Vector1D` | `subtract(double factor, Vector<Euclidean1D> v)` Subtract a scaled vector from the instance.
`Vector1D` | `subtract(Vector<Euclidean1D> p)` Subtract a vector from the instance.
`String` | `toString()` Get a string representation of this vector.
`String` | `toString(NumberFormat format)` Get a string representation of this vector.

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

Field Detail

### ZERO

    public static final Vector1D ZERO

  Origin (coordinates: 0).

### ONE

    public static final Vector1D ONE

  Unit (coordinates: 1).

### NaN

    public static final Vector1D NaN

  A vector with all coordinates set to NaN.

### POSITIVE_INFINITY

    public static final Vector1D POSITIVE_INFINITY

  A vector with all coordinates set to positive infinity.

### NEGATIVE_INFINITY

    public static final Vector1D NEGATIVE_INFINITY

  A vector with all coordinates set to negative infinity.

Constructor Detail

### Vector1D

    public Vector1D(double x)

  Simple constructor. Build a vector from its coordinates

  Parameters:
    `x` - abscissa
  See Also:
    `getX()`

### Vector1D

    public Vector1D(double a,
                    Vector1D u)

  Multiplicative constructor Build a vector from another one and a scale factor. The vector built will be a * u

  Parameters:
    `a` - scale factor
    `u` - base (unscaled) vector

### Vector1D

    public Vector1D(double a1,
                    Vector1D u1,
                    double a2,
                    Vector1D u2)

  Linear constructor Build a vector from two other ones and corresponding scale factors. The vector built will be a1 * u1 + a2 * u2

  Parameters:
    `a1` - first scale factor
    `u1` - first base (unscaled) vector
    `a2` - second scale factor
    `u2` - second base (unscaled) vector

### Vector1D

    public Vector1D(double a1,
                    Vector1D u1,
                    double a2,
                    Vector1D u2,
                    double a3,
                    Vector1D u3)

  Linear constructor Build a vector from three other ones and corresponding scale factors. The vector built will be a1 * u1 + a2 * u2 + a3 * u3

  Parameters:
    `a1` - first scale factor
    `u1` - first base (unscaled) vector
    `a2` - second scale factor
    `u2` - second base (unscaled) vector
    `a3` - third scale factor
    `u3` - third base (unscaled) vector

### Vector1D

    public Vector1D(double a1,
                    Vector1D u1,
                    double a2,
                    Vector1D u2,
                    double a3,
                    Vector1D u3,
                    double a4,
                    Vector1D u4)

  Linear constructor Build a vector from four other ones and corresponding scale factors. The vector built will be a1 * u1 + a2 * u2 + a3 * u3 + a4 * u4

  Parameters:
    `a1` - first scale factor
    `u1` - first base (unscaled) vector
    `a2` - second scale factor
    `u2` - second base (unscaled) vector
    `a3` - third scale factor
    `u3` - third base (unscaled) vector
    `a4` - fourth scale factor
    `u4` - fourth base (unscaled) vector

Method Detail

### getX

    public double getX()

  Get the abscissa of the vector.

  Returns:
    abscissa of the vector
  See Also:
    `Vector1D(double)`

### getSpace

    public Space getSpace()

  Get the space to which the vector belongs.

  Specified by:
    `getSpace` in interface `Vector<Euclidean1D>`
  Returns:
    containing space

### getZero

    public Vector1D getZero()

  Get the null vector of the vectorial space or origin point of the affine space.

  Specified by:
    `getZero` in interface `Vector<Euclidean1D>`
  Returns:
    null vector of the vectorial space or origin point of the affine space

### getNorm1

    public double getNorm1()

  Get the L1 norm for the vector.

  Specified by:
    `getNorm1` in interface `Vector<Euclidean1D>`
  Returns:
    L1 norm for the vector

### getNorm

    public double getNorm()

  Get the L2 norm for the vector.

  Specified by:
    `getNorm` in interface `Vector<Euclidean1D>`
  Returns:
    Euclidean norm for the vector

### getNormSq

    public double getNormSq()

  Get the square of the norm for the vector.

  Specified by:
    `getNormSq` in interface `Vector<Euclidean1D>`
  Returns:
    square of the Euclidean norm for the vector

### getNormInf

    public double getNormInf()

  Get the L∞ norm for the vector.

  Specified by:
    `getNormInf` in interface `Vector<Euclidean1D>`
  Returns:
    L∞ norm for the vector

### add

    public Vector1D add(Vector<Euclidean1D> v)

  Add a vector to the instance.

  Specified by:
    `add` in interface `Vector<Euclidean1D>`
  Parameters:
    `v` - vector to add
  Returns:
    a new vector

### add

    public Vector1D add(double factor,
                        Vector<Euclidean1D> v)

  Add a scaled vector to the instance.

  Specified by:
    `add` in interface `Vector<Euclidean1D>`
  Parameters:
    `factor` - scale factor to apply to v before adding it
    `v` - vector to add
  Returns:
    a new vector

### subtract

    public Vector1D subtract(Vector<Euclidean1D> p)

  Subtract a vector from the instance.

  Specified by:
    `subtract` in interface `Vector<Euclidean1D>`
  Parameters:
    `p` - vector to subtract
  Returns:
    a new vector

### subtract

    public Vector1D subtract(double factor,
                             Vector<Euclidean1D> v)

  Subtract a scaled vector from the instance.

  Specified by:
    `subtract` in interface `Vector<Euclidean1D>`
  Parameters:
    `factor` - scale factor to apply to v before subtracting it
    `v` - vector to subtract
  Returns:
    a new vector

### normalize

    public Vector1D normalize()
                       throws MathArithmeticException

  Get a normalized vector aligned with the instance.

  Specified by:
    `normalize` in interface `Vector<Euclidean1D>`
  Returns:
    a new normalized vector
  Throws:
    `MathArithmeticException` - if the norm is zero

### negate

    public Vector1D negate()

  Get the opposite of the instance.

  Specified by:
    `negate` in interface `Vector<Euclidean1D>`
  Returns:
    a new vector which is opposite to the instance

### scalarMultiply

    public Vector1D scalarMultiply(double a)

  Multiply the instance by a scalar.

  Specified by:
    `scalarMultiply` in interface `Vector<Euclidean1D>`
  Parameters:
    `a` - scalar
  Returns:
    a new vector

### isNaN

    public boolean isNaN()

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

  Specified by:
    `isNaN` in interface `Vector<Euclidean1D>`
  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 `Vector<Euclidean1D>`
  Returns:
    true if any coordinate of this vector is infinite and none are NaN; false otherwise

### distance1

    public double distance1(Vector<Euclidean1D> p)

  Compute the distance between the instance and another vector according to the L1 norm.

  Calling this method is equivalent to calling: `q.subtract(p).getNorm1()` except that no intermediate vector is built

  Specified by:
    `distance1` in interface `Vector<Euclidean1D>`
  Parameters:
    `p` - second vector
  Returns:
    the distance between the instance and p according to the L1 norm

### distance

    public double distance(Vector<Euclidean1D> p)

  Compute the distance between the instance and another vector according to the L2 norm.

  Calling this method is equivalent to calling: `q.subtract(p).getNorm()` except that no intermediate vector is built

  Specified by:
    `distance` in interface `Vector<Euclidean1D>`
  Parameters:
    `p` - second vector
  Returns:
    the distance between the instance and p according to the L2 norm

### distanceInf

    public double distanceInf(Vector<Euclidean1D> p)

  Compute the distance between the instance and another vector according to the L∞ norm.

  Calling this method is equivalent to calling: `q.subtract(p).getNormInf()` except that no intermediate vector is built

  Specified by:
    `distanceInf` in interface `Vector<Euclidean1D>`
  Parameters:
    `p` - second vector
  Returns:
    the distance between the instance and p according to the L∞ norm

### distanceSq

    public double distanceSq(Vector<Euclidean1D> p)

  Compute the square of the distance between the instance and another vector.

  Calling this method is equivalent to calling: `q.subtract(p).getNormSq()` except that no intermediate vector is built

  Specified by:
    `distanceSq` in interface `Vector<Euclidean1D>`
  Parameters:
    `p` - second vector
  Returns:
    the square of the distance between the instance and p

### dotProduct

    public double dotProduct(Vector<Euclidean1D> v)

  Compute the dot-product of the instance and another vector.

  Specified by:
    `dotProduct` in interface `Vector<Euclidean1D>`
  Parameters:
    `v` - second vector
  Returns:
    the dot product this.v

### distance

    public static double distance(Vector1D p1,
                                  Vector1D p2)

  Compute the distance between two vectors according to the L2 norm.

  Calling this method is equivalent to calling: `p1.subtract(p2).getNorm()` except that no intermediate vector is built

  Parameters:
    `p1` - first vector
    `p2` - second vector
  Returns:
    the distance between p1 and p2 according to the L2 norm

### distanceInf

    public static double distanceInf(Vector1D p1,
                                     Vector1D p2)

  Compute the distance between two vectors according to the L∞ norm.

  Calling this method is equivalent to calling: `p1.subtract(p2).getNormInf()` except that no intermediate vector is built

  Parameters:
    `p1` - first vector
    `p2` - second vector
  Returns:
    the distance between p1 and p2 according to the L∞ norm

### distanceSq

    public static double distanceSq(Vector1D p1,
                                    Vector1D p2)

  Compute the square of the distance between two vectors.

  Calling this method is equivalent to calling: `p1.subtract(p2).getNormSq()` except that no intermediate vector is built

  Parameters:
    `p1` - first vector
    `p2` - second vector
  Returns:
    the square of the distance between p1 and p2

### equals

    public boolean equals(Object other)

  Test for the equality of two 1D vectors.

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

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

### hashCode

    public int hashCode()

  Get a hashCode for the 1D vector.

  All NaN values have the same hash code.

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

### toString

    public String toString()

  Get a string representation of this vector.

  Overrides:
    `toString` in class `Object`
  Returns:
    a string representation of this vector

### toString

    public String toString(NumberFormat format)

  Get a string representation of this vector.

  Specified by:
    `toString` in interface `Vector<Euclidean1D>`
  Parameters:
    `format` - the custom format for components
  Returns:
    a string representation of this vector

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

Copyright © 2003-2013 The Apache Software Foundation. All Rights Reserved.