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

Fields
`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.
`private static long` `serialVersionUID` Serializable UID.
`private double` `x` Abscissa.
`static Vector1D` `ZERO` Origin (coordinates: 0).

### Constructor Summary

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

Methods
`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.

#### serialVersionUID

    private static final long serialVersionUID

Serializable UID.

See Also:
  Constant Field Values

#### x

    private final double x

Abscissa.

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