Package org.bukkit.util

# Class Vector

java.lang.Object
org.bukkit.util.Vector

All Implemented Interfaces:
  `Cloneable`, `ConfigurationSerializable`

Direct Known Subclasses:
  `BlockVector`

public class Vector extends Object implements Cloneable, ConfigurationSerializable
Represents a mutable vector. Because the components of Vectors are mutable, storing Vectors long term may be dangerous if passing code modifies the Vector later. If you want to keep around a Vector, it may be wise to call `clone()` in order to get a copy.

## Field Summary

Fields
Modifier and Type
Field
Description
`protected double`
`x`
`protected double`
`y`
`protected double`
`z`

## Constructor Summary

Constructors
Constructor
Description
`Vector()`
Construct the vector with all components as 0.
`Vector(double x, double y, double z)`
Construct the vector with provided double components.
`Vector(float x, float y, float z)`
Construct the vector with provided float components.
`Vector(int x, int y, int z)`
Construct the vector with provided integer components.

## Method Summary

Modifier and Type
Method
Description
`@NotNull Vector`
`add(@NotNull Vector vec)`
Adds a vector to this one
`float`
`angle(@NotNull Vector other)`
Gets the angle between this vector and another in radians.
`void`
`checkFinite()`
Check if each component of this Vector is finite.
`@NotNull Vector`
`clone()`
Get a new vector.
`@NotNull Vector`
`copy(@NotNull Vector vec)`
Copies another vector
`@NotNull Vector`
`crossProduct(@NotNull Vector o)`
Calculates the cross product of this vector with another.
`static @NotNull Vector`
`deserialize(@NotNull Map<String,Object> args)`
`double`
`distance(@NotNull Vector o)`
Get the distance between this vector and another.
`double`
`distanceSquared(@NotNull Vector o)`
Get the squared distance between this vector and another.
`@NotNull Vector`
`divide(@NotNull Vector vec)`
Divides the vector by another.
`double`
`dot(@NotNull Vector other)`
Calculates the dot product of this vector with another.
`boolean`
`equals(Object obj)`
Checks to see if two objects are equal.
`int`
`getBlockX()`
Gets the floored value of the X component, indicating the block that this vector is contained with.
`int`
`getBlockY()`
Gets the floored value of the Y component, indicating the block that this vector is contained with.
`int`
`getBlockZ()`
Gets the floored value of the Z component, indicating the block that this vector is contained with.
`@NotNull Vector`
`getCrossProduct(@NotNull Vector o)`
Calculates the cross product of this vector with another without mutating the original.
`static double`
`getEpsilon()`
Get the threshold used for equals().
`static @NotNull Vector`
`getMaximum(@NotNull Vector v1, @NotNull Vector v2)`
Gets the maximum components of two vectors.
`@NotNull Vector`
`getMidpoint(@NotNull Vector other)`
Gets a new midpoint vector between this vector and another.
`static @NotNull Vector`
`getMinimum(@NotNull Vector v1, @NotNull Vector v2)`
Gets the minimum components of two vectors.
`static @NotNull Vector`
`getRandom()`
Gets a random vector with components having a random value between 0 and 1.
`double`
`getX()`
Gets the X component.
`double`
`getY()`
Gets the Y component.
`double`
`getZ()`
Gets the Z component.
`int`
`hashCode()`
Returns a hash code for this vector
`boolean`
`isInAABB(@NotNull Vector min, @NotNull Vector max)`
Returns whether this vector is in an axis-aligned bounding box.
`boolean`
`isInSphere(@NotNull Vector origin, double radius)`
Returns whether this vector is within a sphere.
`boolean`
`isNormalized()`
Returns if a vector is normalized
`double`
`length()`
Gets the magnitude of the vector, defined as sqrt(x^2+y^2+z^2).
`double`
`lengthSquared()`
Gets the magnitude of the vector squared.
`@NotNull Vector`
`midpoint(@NotNull Vector other)`
Sets this vector to the midpoint between this vector and another.
`@NotNull Vector`
`multiply(double m)`
Performs scalar multiplication, multiplying all components with a scalar.
`@NotNull Vector`
`multiply(float m)`
Performs scalar multiplication, multiplying all components with a scalar.
`@NotNull Vector`
`multiply(int m)`
Performs scalar multiplication, multiplying all components with a scalar.
`@NotNull Vector`
`multiply(@NotNull Vector vec)`
Multiplies the vector by another.
`@NotNull Vector`
`normalize()`
Converts this vector to a unit vector (a vector with length of 1).
`@NotNull Vector`
`rotateAroundAxis(@NotNull Vector axis, double angle)`
Rotates the vector around a given arbitrary axis in 3 dimensional space.
`@NotNull Vector`
`rotateAroundNonUnitAxis(@NotNull Vector axis, double angle)`
Rotates the vector around a given arbitrary axis in 3 dimensional space.
`@NotNull Vector`
`rotateAroundX(double angle)`
Rotates the vector around the x axis.
`@NotNull Vector`
`rotateAroundY(double angle)`
Rotates the vector around the y axis.
`@NotNull Vector`
`rotateAroundZ(double angle)`
Rotates the vector around the z axis
`@NotNull Map<String,Object>`
`serialize()`
Creates a Map representation of this class.
`@NotNull Vector`
`setX(double x)`
Set the X component.
`@NotNull Vector`
`setX(float x)`
Set the X component.
`@NotNull Vector`
`setX(int x)`
Set the X component.
`@NotNull Vector`
`setY(double y)`
Set the Y component.
`@NotNull Vector`
`setY(float y)`
Set the Y component.
`@NotNull Vector`
`setY(int y)`
Set the Y component.
`@NotNull Vector`
`setZ(double z)`
Set the Z component.
`@NotNull Vector`
`setZ(float z)`
Set the Z component.
`@NotNull Vector`
`setZ(int z)`
Set the Z component.
`@NotNull Vector`
`subtract(@NotNull Vector vec)`
Subtracts a vector from this one.
`@NotNull BlockVector`
`toBlockVector()`
Get the block vector of this vector.
`@NotNull Location`
`toLocation(@NotNull World world)`
Gets a Location version of this vector with yaw and pitch being 0.
`@NotNull Location`
`toLocation(@NotNull World world, float yaw, float pitch)`
Gets a Location version of this vector.
`String`
`toString()`
Returns this vector's components as x,y,z.
`@NotNull Vector`
`zero()`
Zero this vector's components.

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

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

## Field Details

### x

protected double x

### y

protected double y

### z

protected double z

## Constructor Details

### Vector

public Vector()
Construct the vector with all components as 0.

### Vector

public Vector(int x, int y, int z)
Construct the vector with provided integer components.

Parameters:
  `x` - X component
  `y` - Y component
  `z` - Z component

### Vector

public Vector(double x, double y, double z)
Construct the vector with provided double components.

Parameters:
  `x` - X component
  `y` - Y component
  `z` - Z component

### Vector

public Vector(float x, float y, float z)
Construct the vector with provided float components.

Parameters:
  `x` - X component
  `y` - Y component
  `z` - Z component

## Method Details

### add

@NotNull public @NotNull Vector add(@NotNull @NotNull Vector vec)
Adds a vector to this one

Parameters:
  `vec` - The other vector
Returns:
  the same vector

### subtract

@NotNull public @NotNull Vector subtract(@NotNull @NotNull Vector vec)
Subtracts a vector from this one.

Parameters:
  `vec` - The other vector
Returns:
  the same vector

### multiply

@NotNull public @NotNull Vector multiply(@NotNull @NotNull Vector vec)
Multiplies the vector by another.

Parameters:
  `vec` - The other vector
Returns:
  the same vector

### divide

@NotNull public @NotNull Vector divide(@NotNull @NotNull Vector vec)
Divides the vector by another.

Parameters:
  `vec` - The other vector
Returns:
  the same vector

### copy

@NotNull public @NotNull Vector copy(@NotNull @NotNull Vector vec)
Copies another vector

Parameters:
  `vec` - The other vector
Returns:
  the same vector

### length

public double length()
Gets the magnitude of the vector, defined as sqrt(x^2+y^2+z^2). The value of this method is not cached and uses a costly square-root function, so do not repeatedly call this method to get the vector's magnitude. NaN will be returned if the inner result of the sqrt() function overflows, which will be caused if the length is too long.

Returns:
  the magnitude

### lengthSquared

public double lengthSquared()
Gets the magnitude of the vector squared.

Returns:
  the magnitude

### distance

public double distance(@NotNull @NotNull Vector o)
Get the distance between this vector and another. The value of this method is not cached and uses a costly square-root function, so do not repeatedly call this method to get the vector's magnitude. NaN will be returned if the inner result of the sqrt() function overflows, which will be caused if the distance is too long.

Parameters:
  `o` - The other vector
Returns:
  the distance

### distanceSquared

public double distanceSquared(@NotNull @NotNull Vector o)
Get the squared distance between this vector and another.

Parameters:
  `o` - The other vector
Returns:
  the distance

### angle

public float angle(@NotNull @NotNull Vector other)
Gets the angle between this vector and another in radians.

Parameters:
  `other` - The other vector
Returns:
  angle in radians

### midpoint

@NotNull public @NotNull Vector midpoint(@NotNull @NotNull Vector other)
Sets this vector to the midpoint between this vector and another.

Parameters:
  `other` - The other vector
Returns:
  this same vector (now a midpoint)

### getMidpoint

@NotNull public @NotNull Vector getMidpoint(@NotNull @NotNull Vector other)
Gets a new midpoint vector between this vector and another.

Parameters:
  `other` - The other vector
Returns:
  a new midpoint vector

### multiply

@NotNull public @NotNull Vector multiply(int m)
Performs scalar multiplication, multiplying all components with a scalar.

Parameters:
  `m` - The factor
Returns:
  the same vector

### multiply

@NotNull public @NotNull Vector multiply(double m)
Performs scalar multiplication, multiplying all components with a scalar.

Parameters:
  `m` - The factor
Returns:
  the same vector

### multiply

@NotNull public @NotNull Vector multiply(float m)
Performs scalar multiplication, multiplying all components with a scalar.

Parameters:
  `m` - The factor
Returns:
  the same vector

### dot

public double dot(@NotNull @NotNull Vector other)
Calculates the dot product of this vector with another. The dot product is defined as x1*x2+y1*y2+z1*z2. The returned value is a scalar.

Parameters:
  `other` - The other vector
Returns:
  dot product

### crossProduct

@NotNull public @NotNull Vector crossProduct(@NotNull @NotNull Vector o)
Calculates the cross product of this vector with another. The cross product is defined as:

- x = y1 * z2 - y2 * z1
- y = z1 * x2 - z2 * x1
- z = x1 * y2 - x2 * y1

Parameters:
  `o` - The other vector
Returns:
  the same vector

### getCrossProduct

@NotNull public @NotNull Vector getCrossProduct(@NotNull @NotNull Vector o)
Calculates the cross product of this vector with another without mutating the original. The cross product is defined as:

- x = y1 * z2 - y2 * z1
- y = z1 * x2 - z2 * x1
- z = x1 * y2 - x2 * y1

Parameters:
  `o` - The other vector
Returns:
  a new vector

### normalize

@NotNull public @NotNull Vector normalize()
Converts this vector to a unit vector (a vector with length of 1).

Returns:
  the same vector

### zero

@NotNull public @NotNull Vector zero()
Zero this vector's components.

Returns:
  the same vector

### isInAABB

public boolean isInAABB(@NotNull @NotNull Vector min, @NotNull @NotNull Vector max)
Returns whether this vector is in an axis-aligned bounding box.

The minimum and maximum vectors given must be truly the minimum and maximum X, Y and Z components.

Parameters:
  `min` - Minimum vector
  `max` - Maximum vector
Returns:
  whether this vector is in the AABB

### isInSphere

public boolean isInSphere(@NotNull @NotNull Vector origin, double radius)
Returns whether this vector is within a sphere.

Parameters:
  `origin` - Sphere origin.
  `radius` - Sphere radius
Returns:
  whether this vector is in the sphere

### isNormalized

public boolean isNormalized()
Returns if a vector is normalized

Returns:
  whether the vector is normalised

### rotateAroundX

@NotNull public @NotNull Vector rotateAroundX(double angle)
Rotates the vector around the x axis.

This piece of math is based on the standard rotation matrix for vectors in three dimensional space. This matrix can be found here: Rotation Matrix.

Parameters:
  `angle` - the angle to rotate the vector about. This angle is passed in radians
Returns:
  the same vector

### rotateAroundY

@NotNull public @NotNull Vector rotateAroundY(double angle)
Rotates the vector around the y axis.

This piece of math is based on the standard rotation matrix for vectors in three dimensional space. This matrix can be found here: Rotation Matrix.

Parameters:
  `angle` - the angle to rotate the vector about. This angle is passed in radians
Returns:
  the same vector

### rotateAroundZ

@NotNull public @NotNull Vector rotateAroundZ(double angle)
Rotates the vector around the z axis

This piece of math is based on the standard rotation matrix for vectors in three dimensional space. This matrix can be found here: Rotation Matrix.

Parameters:
  `angle` - the angle to rotate the vector about. This angle is passed in radians
Returns:
  the same vector

### rotateAroundAxis

@NotNull public @NotNull Vector rotateAroundAxis(@NotNull @NotNull Vector axis, double angle) throws IllegalArgumentException
Rotates the vector around a given arbitrary axis in 3 dimensional space.

Rotation will follow the general Right-Hand-Rule, which means rotation will be counterclockwise when the axis is pointing towards the observer.

This method will always make sure the provided axis is a unit vector, to not modify the length of the vector when rotating. If you are experienced with the scaling of a non-unit axis vector, you can use `rotateAroundNonUnitAxis(Vector, double)`.

Parameters:
  `axis` - the axis to rotate the vector around. If the passed vector is not of length 1, it gets copied and normalized before using it for the rotation. Please use `normalize()` on the instance before passing it to this method
  `angle` - the angle to rotate the vector around the axis
Returns:
  the same vector
Throws:
  `IllegalArgumentException` - if the provided axis vector instance is null

### rotateAroundNonUnitAxis

@NotNull public @NotNull Vector rotateAroundNonUnitAxis(@NotNull @NotNull Vector axis, double angle) throws IllegalArgumentException
Rotates the vector around a given arbitrary axis in 3 dimensional space.

Rotation will follow the general Right-Hand-Rule, which means rotation will be counterclockwise when the axis is pointing towards the observer.

Note that the vector length will change accordingly to the axis vector length. If the provided axis is not a unit vector, the rotated vector will not have its previous length. The scaled length of the resulting vector will be related to the axis vector. If you are not perfectly sure about the scaling of the vector, use `rotateAroundAxis(Vector, double)`

Parameters:
  `axis` - the axis to rotate the vector around.
  `angle` - the angle to rotate the vector around the axis
Returns:
  the same vector
Throws:
  `IllegalArgumentException` - if the provided axis vector instance is null

### getX

public double getX()
Gets the X component.

Returns:
  The X component.

### getBlockX

public int getBlockX()
Gets the floored value of the X component, indicating the block that this vector is contained with.

Returns:
  block X

### getY

public double getY()
Gets the Y component.

Returns:
  The Y component.

### getBlockY

public int getBlockY()
Gets the floored value of the Y component, indicating the block that this vector is contained with.

Returns:
  block y

### getZ

public double getZ()
Gets the Z component.

Returns:
  The Z component.

### getBlockZ

public int getBlockZ()
Gets the floored value of the Z component, indicating the block that this vector is contained with.

Returns:
  block z

### setX

@NotNull public @NotNull Vector setX(int x)
Set the X component.

Parameters:
  `x` - The new X component.
Returns:
  This vector.

### setX

@NotNull public @NotNull Vector setX(double x)
Set the X component.

Parameters:
  `x` - The new X component.
Returns:
  This vector.

### setX

@NotNull public @NotNull Vector setX(float x)
Set the X component.

Parameters:
  `x` - The new X component.
Returns:
  This vector.

### setY

@NotNull public @NotNull Vector setY(int y)
Set the Y component.

Parameters:
  `y` - The new Y component.
Returns:
  This vector.

### setY

@NotNull public @NotNull Vector setY(double y)
Set the Y component.

Parameters:
  `y` - The new Y component.
Returns:
  This vector.

### setY

@NotNull public @NotNull Vector setY(float y)
Set the Y component.

Parameters:
  `y` - The new Y component.
Returns:
  This vector.

### setZ

@NotNull public @NotNull Vector setZ(int z)
Set the Z component.

Parameters:
  `z` - The new Z component.
Returns:
  This vector.

### setZ

@NotNull public @NotNull Vector setZ(double z)
Set the Z component.

Parameters:
  `z` - The new Z component.
Returns:
  This vector.

### setZ

@NotNull public @NotNull Vector setZ(float z)
Set the Z component.

Parameters:
  `z` - The new Z component.
Returns:
  This vector.

### equals

public boolean equals(Object obj)
Checks to see if two objects are equal.

Only two Vectors can ever return true. This method uses a fuzzy match to account for floating point errors. The epsilon can be retrieved with epsilon.

Overrides:
  `equals` in class `Object`

### hashCode

public int hashCode()
Returns a hash code for this vector

Overrides:
  `hashCode` in class `Object`
Returns:
  hash code

### clone

@NotNull public @NotNull Vector clone()
Get a new vector.

Overrides:
  `clone` in class `Object`
Returns:
  vector

### toString

public String toString()
Returns this vector's components as x,y,z.

Overrides:
  `toString` in class `Object`

### toLocation

@NotNull public @NotNull Location toLocation(@NotNull @NotNull World world)
Gets a Location version of this vector with yaw and pitch being 0.

Parameters:
  `world` - The world to link the location to.
Returns:
  the location

### toLocation

@NotNull public @NotNull Location toLocation(@NotNull @NotNull World world, float yaw, float pitch)
Gets a Location version of this vector.

Parameters:
  `world` - The world to link the location to.
  `yaw` - The desired yaw.
  `pitch` - The desired pitch.
Returns:
  the location

### toBlockVector

@NotNull public @NotNull BlockVector toBlockVector()
Get the block vector of this vector.

Returns:
  A block vector.

### checkFinite

public void checkFinite() throws IllegalArgumentException
Check if each component of this Vector is finite.

Throws:
  `IllegalArgumentException` - if any component is not finite

### getEpsilon

public static double getEpsilon()
Get the threshold used for equals().

Returns:
  The epsilon.

### getMinimum

@NotNull public static @NotNull Vector getMinimum(@NotNull @NotNull Vector v1, @NotNull @NotNull Vector v2)
Gets the minimum components of two vectors.

Parameters:
  `v1` - The first vector.
  `v2` - The second vector.
Returns:
  minimum

### getMaximum

@NotNull public static @NotNull Vector getMaximum(@NotNull @NotNull Vector v1, @NotNull @NotNull Vector v2)
Gets the maximum components of two vectors.

Parameters:
  `v1` - The first vector.
  `v2` - The second vector.
Returns:
  maximum

### getRandom

@NotNull public static @NotNull Vector getRandom()
Gets a random vector with components having a random value between 0 and 1.

Returns:
  A random vector.

### serialize

@NotNull public @NotNull Map<String,Object> serialize()
Description copied from interface: `ConfigurationSerializable`
Creates a Map representation of this class.

This class must provide a method to restore this class, as defined in the `ConfigurationSerializable` interface javadocs.

Specified by:
  `serialize` in interface `ConfigurationSerializable`
Returns:
  Map containing the current state of this class

### deserialize

@NotNull public static @NotNull Vector deserialize(@NotNull @NotNull Map<String,Object> args)