Vector (Lucene 10.5.0 spatial3d API)
Description: declaration: package: org.apache.lucene.spatial3d.geom, class: Vector

Package org.apache.lucene.spatial3d.geom

# Class Vector

java.lang.Object
org.apache.lucene.spatial3d.geom.Vector

Direct Known Subclasses:
  `GeoPoint`, `Plane`

public class Vector extends Object
A 3d vector in space, not necessarily going through the origin.

WARNING: This API is experimental and might change in incompatible ways in the next release.

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `static final double`
  `MINIMUM_ANGULAR_RESOLUTION`
  Angular version of minimum resolution.
  `static final double`
  `MINIMUM_RESOLUTION`
  Values that are all considered to be essentially zero have a magnitude less than this.
  `static final double`
  `MINIMUM_RESOLUTION_CUBED`
  For cubed quantities, cube the bound.
  `static final double`
  `MINIMUM_RESOLUTION_SQUARED`
  For squared quantities, the bound is squared too.
  `final double`
  `x`
  The x value
  `final double`
  `y`
  The y value
  `final double`
  `z`
  The z value

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `Vector(double x, double y, double z)`
  Construct from (U.S.) x,y,z coordinates.
  `Vector(double AX, double AY, double AZ, double BX, double BY, double BZ)`
  Construct a vector that is perpendicular to two other (non-zero) vectors.
  `Vector(Vector A, double BX, double BY, double BZ)`
  Construct a vector that is perpendicular to two other (non-zero) vectors.
  `Vector(Vector A, Vector B)`
  Construct a vector that is perpendicular to two other (non-zero) vectors.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `static boolean`
  `crossProductEvaluateIsZero(Vector A, Vector B, Vector point)`
  Evaluate the cross product of two vectors against a point.
  `double`
  `dotProduct(double x, double y, double z)`
  Do a dot product.
  `double`
  `dotProduct(Vector v)`
  Do a dot product.
  `boolean`
  `equals(Object o)`
  `int`
  `hashCode()`
  `boolean`
  `isNumericallyIdentical(double otherX, double otherY, double otherZ)`
  Compute whether two vectors are numerically identical.
  `boolean`
  `isNumericallyIdentical(Vector other)`
  Compute whether two vectors are numerically identical.
  `boolean`
  `isParallel(double otherX, double otherY, double otherZ)`
  Compute whether two vectors are parallel.
  `boolean`
  `isParallel(Vector other)`
  Compute whether two vectors are numerically identical.
  `boolean`
  `isWithin(Membership[] bounds, Membership... moreBounds)`
  Determine if this vector, taken from the origin, describes a point within a set of planes.
  `double`
  `linearDistance(double x, double y, double z)`
  Compute the straight-line distance to a point described by the vector taken from the origin.
  `double`
  `linearDistance(Vector v)`
  Compute the straight-line distance to a point described by the vector taken from the origin.
  `double`
  `linearDistanceSquared(double x, double y, double z)`
  Compute the square of a straight-line distance to a point described by the vector taken from the origin.
  `double`
  `linearDistanceSquared(Vector v)`
  Compute the square of a straight-line distance to a point described by the vector taken from the origin.
  `double`
  `magnitude()`
  Compute the magnitude of this vector.
  `static double`
  `magnitude(double x, double y, double z)`
  Compute a magnitude of an x,y,z value.
  `double`
  `normalDistance(double x, double y, double z)`
  Compute the normal (perpendicular) distance to a vector described by a vector taken from the origin.
  `double`
  `normalDistance(Vector v)`
  Compute the normal (perpendicular) distance to a vector described by a vector taken from the origin.
  `double`
  `normalDistanceSquared(double x, double y, double z)`
  Compute the square of the normal distance to a vector described by a vector taken from the origin.
  `double`
  `normalDistanceSquared(Vector v)`
  Compute the square of the normal distance to a vector described by a vector taken from the origin.
  `Vector`
  `normalize()`
  Compute a normalized unit vector based on the current vector.
  `Vector`
  `rotateXY(double angle)`
  Rotate vector counter-clockwise in x-y by an angle.
  `Vector`
  `rotateXY(double sinAngle, double cosAngle)`
  Rotate vector counter-clockwise in x-y by an angle, expressed as sin and cos.
  `Vector`
  `rotateXZ(double angle)`
  Rotate vector counter-clockwise in x-z by an angle.
  `Vector`
  `rotateXZ(double sinAngle, double cosAngle)`
  Rotate vector counter-clockwise in x-z by an angle, expressed as sin and cos.
  `Vector`
  `rotateZY(double angle)`
  Rotate vector counter-clockwise in z-y by an angle.
  `Vector`
  `rotateZY(double sinAngle, double cosAngle)`
  Rotate vector counter-clockwise in z-y by an angle, expressed as sin and cos.
  `String`
  `toString()`
  `Vector`
  `translate(double xOffset, double yOffset, double zOffset)`
  Translate vector.

  ### Methods inherited from class java.lang.Object

  `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

- ## Field Details

  - ### MINIMUM_RESOLUTION

    public static final double MINIMUM_RESOLUTION
    Values that are all considered to be essentially zero have a magnitude less than this.
    See Also:
      - Constant Field Values

  - ### MINIMUM_ANGULAR_RESOLUTION

    public static final double MINIMUM_ANGULAR_RESOLUTION
    Angular version of minimum resolution.
    See Also:
      - Constant Field Values

  - ### MINIMUM_RESOLUTION_SQUARED

    public static final double MINIMUM_RESOLUTION_SQUARED
    For squared quantities, the bound is squared too.
    See Also:
      - Constant Field Values

  - ### MINIMUM_RESOLUTION_CUBED

    public static final double MINIMUM_RESOLUTION_CUBED
    For cubed quantities, cube the bound.
    See Also:
      - Constant Field Values

  - ### x

    public final double x
    The x value

  - ### y

    public final double y
    The y value

  - ### z

    public final double z
    The z value

- ## Constructor Details

  - ### Vector

    public Vector(double x, double y, double z)
    Construct from (U.S.) x,y,z coordinates.
    Parameters:
      `x` - is the x value.
      `y` - is the y value.
      `z` - is the z value.

  - ### Vector

    public Vector(Vector A, double BX, double BY, double BZ)
    Construct a vector that is perpendicular to two other (non-zero) vectors. If the vectors are parallel, IllegalArgumentException will be thrown. Produces a normalized final vector.
    Parameters:
      `A` - is the first vector
      `BX` - is the X value of the second
      `BY` - is the Y value of the second
      `BZ` - is the Z value of the second

  - ### Vector

    public Vector(double AX, double AY, double AZ, double BX, double BY, double BZ)
    Construct a vector that is perpendicular to two other (non-zero) vectors. If the vectors are parallel, IllegalArgumentException will be thrown. Produces a normalized final vector.
    Parameters:
      `AX` - is the X value of the first
      `AY` - is the Y value of the first
      `AZ` - is the Z value of the first
      `BX` - is the X value of the second
      `BY` - is the Y value of the second
      `BZ` - is the Z value of the second

  - ### Vector

    public Vector(Vector A, Vector B)
    Construct a vector that is perpendicular to two other (non-zero) vectors. If the vectors are parallel, IllegalArgumentException will be thrown. Produces a normalized final vector.
    Parameters:
      `A` - is the first vector
      `B` - is the second

- ## Method Details

  - ### magnitude

    public static double magnitude(double x, double y, double z)
    Compute a magnitude of an x,y,z value.

  - ### normalize

    public Vector normalize()
    Compute a normalized unit vector based on the current vector.
    Returns:
      the normalized vector, or null if the current vector has a magnitude of zero.

  - ### crossProductEvaluateIsZero

    public static boolean crossProductEvaluateIsZero(Vector A, Vector B, Vector point)
    Evaluate the cross product of two vectors against a point. If the dot product of the resultant vector resolves to "zero", then return true.
    Parameters:
      `A` - is the first vector to use for the cross product.
      `B` - is the second vector to use for the cross product.
      `point` - is the point to evaluate.
    Returns:
      true if we get a zero dot product.

  - ### dotProduct

    public double dotProduct(Vector v)
    Do a dot product.
    Parameters:
      `v` - is the vector to multiply.
    Returns:
      the result.

  - ### dotProduct

    public double dotProduct(double x, double y, double z)
    Do a dot product.
    Parameters:
      `x` - is the x value of the vector to multiply.
      `y` - is the y value of the vector to multiply.
      `z` - is the z value of the vector to multiply.
    Returns:
      the result.

  - ### isWithin

    public boolean isWithin(Membership[] bounds, Membership... moreBounds)
    Determine if this vector, taken from the origin, describes a point within a set of planes.
    Parameters:
      `bounds` - is the first part of the set of planes.
      `moreBounds` - is the second part of the set of planes.
    Returns:
      true if the point is within the bounds.

  - ### translate

    public Vector translate(double xOffset, double yOffset, double zOffset)
    Translate vector.

  - ### rotateXY

    public Vector rotateXY(double angle)
    Rotate vector counter-clockwise in x-y by an angle.

  - ### rotateXY

    public Vector rotateXY(double sinAngle, double cosAngle)
    Rotate vector counter-clockwise in x-y by an angle, expressed as sin and cos.

  - ### rotateXZ

    public Vector rotateXZ(double angle)
    Rotate vector counter-clockwise in x-z by an angle.

  - ### rotateXZ

    public Vector rotateXZ(double sinAngle, double cosAngle)
    Rotate vector counter-clockwise in x-z by an angle, expressed as sin and cos.

  - ### rotateZY

    public Vector rotateZY(double angle)
    Rotate vector counter-clockwise in z-y by an angle.

  - ### rotateZY

    public Vector rotateZY(double sinAngle, double cosAngle)
    Rotate vector counter-clockwise in z-y by an angle, expressed as sin and cos.

  - ### linearDistanceSquared

    public double linearDistanceSquared(Vector v)
    Compute the square of a straight-line distance to a point described by the vector taken from the origin. Monotonically increasing for arc distances up to PI.
    Parameters:
      `v` - is the vector to compute a distance to.
    Returns:
      the square of the linear distance.

  - ### linearDistanceSquared

    public double linearDistanceSquared(double x, double y, double z)
    Compute the square of a straight-line distance to a point described by the vector taken from the origin. Monotonically increasing for arc distances up to PI.
    Parameters:
      `x` - is the x part of the vector to compute a distance to.
      `y` - is the y part of the vector to compute a distance to.
      `z` - is the z part of the vector to compute a distance to.
    Returns:
      the square of the linear distance.

  - ### linearDistance

    public double linearDistance(Vector v)
    Compute the straight-line distance to a point described by the vector taken from the origin. Monotonically increasing for arc distances up to PI.
    Parameters:
      `v` - is the vector to compute a distance to.
    Returns:
      the linear distance.

  - ### linearDistance

    public double linearDistance(double x, double y, double z)
    Compute the straight-line distance to a point described by the vector taken from the origin. Monotonically increasing for arc distances up to PI.
    Parameters:
      `x` - is the x part of the vector to compute a distance to.
      `y` - is the y part of the vector to compute a distance to.
      `z` - is the z part of the vector to compute a distance to.
    Returns:
      the linear distance.

  - ### normalDistanceSquared

    public double normalDistanceSquared(Vector v)
    Compute the square of the normal distance to a vector described by a vector taken from the origin. Monotonically increasing for arc distances up to PI/2.
    Parameters:
      `v` - is the vector to compute a distance to.
    Returns:
      the square of the normal distance.

  - ### normalDistanceSquared

    public double normalDistanceSquared(double x, double y, double z)
    Compute the square of the normal distance to a vector described by a vector taken from the origin. Monotonically increasing for arc distances up to PI/2.
    Parameters:
      `x` - is the x part of the vector to compute a distance to.
      `y` - is the y part of the vector to compute a distance to.
      `z` - is the z part of the vector to compute a distance to.
    Returns:
      the square of the normal distance.

  - ### normalDistance

    public double normalDistance(Vector v)
    Compute the normal (perpendicular) distance to a vector described by a vector taken from the origin. Monotonically increasing for arc distances up to PI/2.
    Parameters:
      `v` - is the vector to compute a distance to.
    Returns:
      the normal distance.

  - ### normalDistance

    public double normalDistance(double x, double y, double z)
    Compute the normal (perpendicular) distance to a vector described by a vector taken from the origin. Monotonically increasing for arc distances up to PI/2.
    Parameters:
      `x` - is the x part of the vector to compute a distance to.
      `y` - is the y part of the vector to compute a distance to.
      `z` - is the z part of the vector to compute a distance to.
    Returns:
      the normal distance.

  - ### magnitude

    public double magnitude()
    Compute the magnitude of this vector.
    Returns:
      the magnitude.

  - ### isNumericallyIdentical

    public boolean isNumericallyIdentical(double otherX, double otherY, double otherZ)
    Compute whether two vectors are numerically identical.
    Parameters:
      `otherX` - is the other vector X.
      `otherY` - is the other vector Y.
      `otherZ` - is the other vector Z.
    Returns:
      true if they are numerically identical.

  - ### isNumericallyIdentical

    public boolean isNumericallyIdentical(Vector other)
    Compute whether two vectors are numerically identical.
    Parameters:
      `other` - is the other vector.
    Returns:
      true if they are numerically identical.

  - ### isParallel

    public boolean isParallel(double otherX, double otherY, double otherZ)
    Compute whether two vectors are parallel.
    Parameters:
      `otherX` - is the other vector X.
      `otherY` - is the other vector Y.
      `otherZ` - is the other vector Z.
    Returns:
      true if they are parallel.

  - ### isParallel

    public boolean isParallel(Vector other)
    Compute whether two vectors are numerically identical.
    Parameters:
      `other` - is the other vector.
    Returns:
      true if they are parallel.

  - ### equals

    public boolean equals(Object o)
    Overrides:
      `equals` in class `Object`

  - ### hashCode

    public int hashCode()
    Overrides:
      `hashCode` in class `Object`

  - ### toString

    public String toString()
    Overrides:
      `toString` in class `Object`