Vector1D (Apache Commons Geometry Euclidean 1.0 API)

java.lang.Object
- org.apache.commons.geometry.euclidean.EuclideanVector<Vector1D>
- - org.apache.commons.geometry.euclidean.oned.Vector1D

All Implemented Interfaces:

Point<Vector1D>, Spatial, Vector<Vector1D>

Direct Known Subclasses:

Vector1D.Unit
```
public class Vector1D
extends EuclideanVector<Vector1D>
```
This class represents vectors and points in one-dimensional Euclidean space. Instances of this class are guaranteed to be immutable.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class Vector1D.Sum
Class used to create high-accuracy sums of vectors.

static class Vector1D.Unit
Represent unit vectors.

Nested Classes
Modifier and Type	Class and Description
`static class`	`Vector1D.Sum` Class used to create high-accuracy sums of vectors.
`static class`	`Vector1D.Unit` Represent unit vectors.

Field Summary

Fields
Modifier and Type	Field and Description
`static Comparator<Vector1D>`	`COORDINATE_ASCENDING_ORDER` Comparator that sorts vectors in component-wise ascending order.
`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`	`POSITIVE_INFINITY` A vector with all coordinates set to positive infinity.
`static Vector1D`	`ZERO` Zero vector (coordinates: 0).

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Vector1D`	`add(double factor, Vector1D v)`
`Vector1D`	`add(Vector1D v)`
`double`	`angle(Vector1D v)`
`Vector1D.Unit`	`directionTo(Vector1D v)` Return the unit vector representing the direction of displacement from this vector to the given vector.
`double`	`distance(Vector1D v)`
`double`	`distanceSq(Vector1D v)`
`double`	`dot(Vector1D v)`
`boolean`	`eq(Vector1D vec, Precision.DoubleEquivalence precision)` Return true if the current instance and given vector are considered equal as evaluated by the given precision context.
`boolean`	`equals(Object other)` Test for the equality of two vectors.
`int`	`getDimension()`
`double`	`getX()` Returns the abscissa (coordinate value) of the instance.
`Vector1D`	`getZero()`
`int`	`hashCode()` Get a hashCode for the vector.
`boolean`	`isFinite()`
`boolean`	`isInfinite()`
`boolean`	`isNaN()`
`Vector1D`	`lerp(Vector1D p, double t)` Get a vector constructed by linearly interpolating between this vector and the given vector.
`Vector1D`	`multiply(double a)`
`Vector1D`	`negate()`
`double`	`norm()`
`Vector1D.Unit`	`normalize()`
`Vector1D.Unit`	`normalizeOrNull()`
`double`	`normSq()`
`static Vector1D`	`of(double x)` Returns a vector with the given coordinate value.
`static Vector1D`	`parse(String str)` Parses the given string and returns a new vector instance.
`Vector1D`	`subtract(double factor, Vector1D v)`
`Vector1D`	`subtract(Vector1D v)`
`String`	`toString()`
`Vector1D`	`transform(UnaryOperator<Vector1D> fn)` Convenience method to apply a function to this vector.
`Vector1D`	`vectorTo(Vector1D v)` Return the vector representing the displacement from this vector to the given vector.
`Vector1D`	`withNorm(double magnitude)`

Methods inherited from class org.apache.commons.geometry.euclidean.EuclideanVector
getCheckedNorm, isZero

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

- Field Detail
  - ZERO
```
public static final Vector1D ZERO
```
    Zero vector (coordinates: 0).
  - 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.
  - COORDINATE_ASCENDING_ORDER
```
public static final Comparator<Vector1D> COORDINATE_ASCENDING_ORDER
```
    Comparator that sorts vectors in component-wise ascending order. Vectors are only considered equal if their coordinates match exactly. Null arguments are evaluated as being greater than non-null arguments.
- Method Detail
  - getX
```
public double getX()
```
    Returns the abscissa (coordinate value) of the instance.
    
    Returns:
    
    the abscissa value
  - getDimension
```
public int getDimension()
```
  - isNaN
```
public boolean isNaN()
```
  - isInfinite
```
public boolean isInfinite()
```
  - isFinite
```
public boolean isFinite()
```
  - vectorTo
```
public Vector1D vectorTo(Vector1D v)
```
    Return the vector representing the displacement from this vector to the given vector. This is exactly equivalent to v.subtract(thisVector) but with a method name that is much easier to visualize.
    
    Specified by:
    
    vectorTo in class EuclideanVector<Vector1D>
    
    Parameters:
    
    v - the vector that the returned vector will be directed toward
    
    Returns:
    
    vector representing the displacement from this vector to the given vector
  - directionTo
```
public Vector1D.Unit directionTo(Vector1D v)
```
    Return the unit vector representing the direction of displacement from this vector to the given vector. This is exactly equivalent to v.subtract(thisVector).normalize() but without the intermediate vector instance.
    
    Specified by:
    
    directionTo in class EuclideanVector<Vector1D>
    
    Parameters:
    
    v - the vector that the returned vector will be directed toward
    
    Returns:
    
    unit vector representing the direction of displacement from this vector to the given vector
  - lerp
```
public Vector1D lerp(Vector1D p,
                     double t)
```
    Get a vector constructed by linearly interpolating between this vector and the given vector. The vector coordinates are generated by the equation V = (1 - t)*A + t*B, where A is the current vector and B is the given vector. This means that if t = 0, a vector equal to the current vector will be returned. If t = 1, a vector equal to the argument will be returned. The t parameter is not constrained to the range [0, 1], meaning that linear extrapolation can also be performed with this method.
    
    Specified by:
    
    lerp in class EuclideanVector<Vector1D>
    
    Parameters:
    
    p - other vector
    
    t - interpolation parameter
    
    Returns:
    
    interpolated or extrapolated vector
  - getZero
```
public Vector1D getZero()
```
  - norm
```
public double norm()
```
  - normSq
```
public double normSq()
```
  - withNorm
```
public Vector1D withNorm(double magnitude)
```
  - add
```
public Vector1D add(Vector1D v)
```
  - add
```
public Vector1D add(double factor,
                    Vector1D v)
```
  - subtract
```
public Vector1D subtract(Vector1D v)
```
  - subtract
```
public Vector1D subtract(double factor,
                         Vector1D v)
```
  - negate
```
public Vector1D negate()
```
  - normalize
```
public Vector1D.Unit normalize()
```
  - normalizeOrNull
```
public Vector1D.Unit normalizeOrNull()
```
  - multiply
```
public Vector1D multiply(double a)
```
  - distance
```
public double distance(Vector1D v)
```
  - distanceSq
```
public double distanceSq(Vector1D v)
```
  - dot
```
public double dot(Vector1D v)
```
  - angle
```
public double angle(Vector1D v)
```
    For the one-dimensional case, this method returns 0 if the vector x values have the same sign and pi if they are opposite.
  - transform
```
public Vector1D transform(UnaryOperator<Vector1D> fn)
```
    Convenience method to apply a function to this vector. This can be used to transform the vector inline with other methods.
    
    Parameters:
    
    fn - the function to apply
    
    Returns:
    
    the transformed vector
  - eq
```
public boolean eq(Vector1D vec,
                  Precision.DoubleEquivalence precision)
```
    Return true if the current instance and given vector are considered equal as evaluated by the given precision context.
    Equality is determined by comparing each pair of components in turn from the two vectors. If all components evaluate as equal, then the vectors are considered equal. If any are not equal, then the vectors are not considered equal. Note that this approach means that the calculated distance between two "equal" vectors may be as much as √(n * eps²), where n is the number of components in the vector and eps is the maximum epsilon value allowed by the precision context.
    
    Specified by:
    
    eq in class EuclideanVector<Vector1D>
    
    Parameters:
    
    vec - vector to check for equality
    
    precision - precision context used to determine floating point equality
    
    Returns:
    
    true if the current instance is considered equal to the given vector when using the given precision context; otherwise false
  - hashCode
```
public int hashCode()
```
    Get a hashCode for the vector.
    All NaN values have the same hash code.
    
    Overrides:
    
    hashCode in class Object
    
    Returns:
    
    a hash code value for this object
  - equals
```
public boolean equals(Object other)
```
    Test for the equality of two vectors.
    If all coordinates of two vectors are exactly the same, and none are Double.NaN, the two vectors are considered to be equal.
    
    NaN coordinates are considered to globally affect the vector and be equal to each other - i.e, if either (or all) coordinates of the vector are equal to Double.NaN, the vector is equal to NaN.
    
    Overrides:
    
    equals in class 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 Vector1D, or not equal to this Vector1D instance
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - of
```
public static Vector1D of(double x)
```
    Returns a vector with the given coordinate value.
    
    Parameters:
    
    x - vector coordinate
    
    Returns:
    
    vector instance
  - parse
```
public static Vector1D parse(String str)
```
    Parses the given string and returns a new vector instance. The expected string format is the same as that returned by toString().
    
    Parameters:
    
    str - the string to parse
    
    Returns:
    
    vector instance represented by the string
    
    Throws:
    
    IllegalArgumentException - if the given string has an invalid format

Class Vector1D

Nested Class Summary

Field Summary

Method Summary

Methods inherited from class org.apache.commons.geometry.euclidean.EuclideanVector

Methods inherited from class java.lang.Object

Field Detail

ZERO

NaN

POSITIVE_INFINITY

NEGATIVE_INFINITY

COORDINATE_ASCENDING_ORDER

Method Detail

getX

getDimension

isNaN

isInfinite

isFinite

vectorTo

directionTo

lerp

getZero

norm

normSq

withNorm

add

add

subtract

subtract

negate

normalize

normalizeOrNull

multiply

distance

distanceSq

dot

angle

transform

eq

hashCode

equals

toString

of

parse