Vec3d (sim-math 1.6.0 API)

java.lang.Object
- com.simsilica.mathd.Vec3d

All Implemented Interfaces:

java.io.Serializable, java.lang.Cloneable
```
public class Vec3d
extends java.lang.Object
implements java.lang.Cloneable, java.io.Serializable
```
A vector composed of 3 double-precision components, used to represent locations, offsets, velocities, and directions in 3-dimensional space.
Methods with names ending in "Local" modify the current instance. They are used to avoid creating temporary vectors.
The conventional order of components is (X, Y, Z).

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static Vec3d`	`UNIT_X` Shared instance of the +X direction (1,0,0).
`static Vec3d`	`UNIT_Y` Shared instance of the +Y direction (0,1,0).
`static Vec3d`	`UNIT_Z` Shared instance of the +Z direction (0,0,1).
`double`	`x` The first (X) component.
`double`	`y` The 2nd (Y) component.
`double`	`z` The 3rd (Z) component.
`static Vec3d`	`ZERO` Shared instance of the all-zero vector (0,0,0).

Constructor Summary

Constructors
Constructor and Description
`Vec3d()` Instantiates an all-zero vector (0,0,0).
`Vec3d(double x, double y, double z)` Instantiates a vector with the specified components.
`Vec3d(Vec3d v)` Instantiates a copy of the argument.
`Vec3d(Vec3i v)`
`Vec3d(com.jme3.math.Vector3f v)` Instantiates a double-precision copy of the argument.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Vec3d`	`add(double vx, double vy, double vz)` Adds specified amounts to the vector's components and returns the sum as a new instance.
`Vec3d`	`add(Vec3d v)` Adds the argument and returns the sum as a new instance.
`Vec3d`	`add(Vec3i v)`
`Vec3d`	`addLocal(double vx, double vy, double vz)` Adds specified amounts to the vector's components and returns the (modified) current instance.
`Vec3d`	`addLocal(Vec3d v)` Adds the argument and returns the (modified) current instance.
`Vec3d`	`addLocal(Vec3i v)` Adds the Vec3i argument and returns the (modified) current instance.
`Vec3d`	`addScaledVectorLocal(Vec3d toAdd, double scale)`
`Vec3i`	`ceil()` Returns the Math.ceil() version of this Vec3d as a Vec3i.
`Vec3d`	`clone()` Creates a copy.
`Vec3d`	`cross(double vx, double vy, double vz)`
`Vec3d`	`cross(Vec3d v)` Calculates a cross product with the argument and returns the product as a new instance.
`Vec3d`	`crossLocal(Vec3d v)`
`double`	`distance(double vx, double vy, double vz)`
`double`	`distance(Vec3d v)`
`double`	`distanceSq(double vx, double vy, double vz)`
`double`	`distanceSq(Vec3d v)`
`double`	`distanceSq(Vec3i v)`
`Vec3d`	`divide(double s)` Divides by the scalar argument and returns the quotient as a new instance.
`Vec3d`	`divide(Vec3d v)` Divides component-wise by the argument and returns the quotient as a new instance.
`Vec3d`	`divide(Vec3i v)`
`Vec3d`	`divideLocal(double s)` Divides by the argument and returns the (modified) current instance.
`Vec3d`	`divideLocal(Vec3d v)` Divides component-wise by the argument and returns the (modified) current instance.
`double`	`dot(double vx, double vy, double vz)`
`double`	`dot(Vec3d v)` Returns the dot (or inner) product with the argument.
`double`	`dot(Vec3i v)`
`boolean`	`equals(java.lang.Object o)` Tests for exact equality with the argument, distinguishing -0 from 0.
`Vec3i`	`floor()` Returns the Math.floor() version of this Vec3d as a Vec3i.
`double`	`get(int i)` Returns the indexed component.
`int`	`hashCode()` Returns a hash code.
`Vec3d`	`interpolateLocal(Vec3d start, Vec3d end, double mix)` Sets the value of this Vec3d to be the linearly interpolated value of start and end using the mix value as the 0 to 1 position between start and end.
`boolean`	`isFinite()` Tests for finite components.
`boolean`	`isNaN()` Returns true if any of the x,y,z elements are NaN.
`boolean`	`isSimilar(Vec3d other, double epsilon)` Returns true if this Vec3d is similar to the specified Vec3d within some value of epsilon.
`double`	`length()` Returns the length (or magnitude).
`double`	`lengthSq()` Returns the square of the length.
`Vec3d`	`maxLocal(Vec3d v)`
`Vec3d`	`minLocal(Vec3d v)`
`Vec3d`	`mult(double s)` Multiplies with the scalar argument and returns the product as a new instance.
`Vec3d`	`mult(Vec3d v)` Multiplies component-wise with the argument and returns the product as a new instance.
`Vec3d`	`mult(Vec3i v)`
`Vec3d`	`multLocal(double s)` Multiplies by the scalar argument and returns the (modified) current instance.
`Vec3d`	`multLocal(Vec3d v)` Multiplies component-wise by the argument and returns the (modified) current instance.
`Vec3d`	`multLocal(Vec3i v)`
`Vec3d`	`normalize()`
`Vec3d`	`normalizeLocal()` Normalize this vector in place.
`Vec3d`	`set(double x, double y, double z)` Sets all 3 components to specified values.
`Vec3d`	`set(int i, double d)` Alters the indexed component.
`Vec3d`	`set(Vec3d v)` Copies all 3 components from the argument.
`Vec3d`	`set(Vec3i v)`
`Vec3d`	`set(com.jme3.math.Vector3f v)` Copies all 3 components from the argument, converting them to double precision.
`Vec3d`	`subtract(double vx, double vy, double vz)` Subtracts specified amounts from the vector's components and returns the difference as a new instance.
`Vec3d`	`subtract(Vec3d v)` Subtracts the argument and returns the difference as a new instance.
`Vec3d`	`subtract(Vec3i v)`
`Vec3d`	`subtractLocal(double vx, double vy, double vz)` Subtracts the specified amounts from the vector's components and returns the (modified) current instance.
`Vec3d`	`subtractLocal(Vec3d v)` Subtracts the argument and returns the (modified) current instance.
`Vec3d`	`subtractLocal(Vec3i v)`
`java.lang.String`	`toString()` Returns a string representation of the vector, which is unaffected.
`Vec3i`	`toVec3i()` Returns the raw (int) cast version of this Vec3d as a Vec3i.
`com.jme3.math.Vector3f`	`toVector3f()` Creates a single-precision copy of the current instance.
`Vec3d`	`xzy()`
`Vec3d`	`zeroEpsilon(double e)`

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

- Field Detail
  - UNIT_X
```
public static final Vec3d UNIT_X
```
    Shared instance of the +X direction (1,0,0). Do not modify!
  - UNIT_Y
```
public static final Vec3d UNIT_Y
```
    Shared instance of the +Y direction (0,1,0). Do not modify!
  - UNIT_Z
```
public static final Vec3d UNIT_Z
```
    Shared instance of the +Z direction (0,0,1). Do not modify!
  - ZERO
```
public static final Vec3d ZERO
```
    Shared instance of the all-zero vector (0,0,0). Do not modify!
  - x
```
public double x
```
    The first (X) component.
  - y
```
public double y
```
    The 2nd (Y) component.
  - z
```
public double z
```
    The 3rd (Z) component.
- Constructor Detail
  - Vec3d
```
public Vec3d()
```
    Instantiates an all-zero vector (0,0,0).
  - Vec3d
```
public Vec3d(double x,
             double y,
             double z)
```
    Instantiates a vector with the specified components.
    
    Parameters:
    
    x - the desired X component
    
    y - the desired Y component
    
    z - the desired Z component
  - Vec3d
```
public Vec3d(Vec3d v)
```
    Instantiates a copy of the argument.
    
    Parameters:
    
    v - the Vec3d to copy (not null, unaffected)
  - Vec3d
```
public Vec3d(Vec3i v)
```
  - Vec3d
```
public Vec3d(com.jme3.math.Vector3f v)
```
    Instantiates a double-precision copy of the argument.
    
    Parameters:
    
    v - the input Vector3f (not null, unaffected)
- Method Detail
  - toVector3f
```
public com.jme3.math.Vector3f toVector3f()
```
    Creates a single-precision copy of the current instance.
    
    Returns:
    
    a new Vector3f
  - isNaN
```
public boolean isNaN()
```
    Returns true if any of the x,y,z elements are NaN.
    
    Returns:
    
    true if there are NaNs, otherwise false
  - hashCode
```
public int hashCode()
```
    Returns a hash code. If two vectors have identical values, they will have the same hash code. The current instance is unaffected.
    
    Overrides:
    
    hashCode in class java.lang.Object
    
    Returns:
    
    a 32-bit value for use in hashing
  - equals
```
public boolean equals(java.lang.Object o)
```
    Tests for exact equality with the argument, distinguishing -0 from 0. If o is null, false is returned. Either way, the current instance is unaffected.
    
    Overrides:
    
    equals in class java.lang.Object
    
    Parameters:
    
    o - the object to compare (may be null, unaffected)
    
    Returns:
    
    true if this and o have identical values, otherwise false
  - isSimilar
```
public boolean isSimilar(Vec3d other,
                         double epsilon)
```
    Returns true if this Vec3d is similar to the specified Vec3d within some value of epsilon.
    
    Parameters:
    
    other - the Vec3d to compare (may be null, unaffected)
    
    epsilon - the tolerance for comparison
    
    Returns:
    
    true if all components are sufficiently similar, otherwise false
  - isFinite
```
public boolean isFinite()
```
    Tests for finite components. The vector is unaffected.
    
    Returns:
    
    false if any component is infinite or NaN, otherwise true
  - set
```
public final Vec3d set(double x,
                       double y,
                       double z)
```
    Sets all 3 components to specified values.
    
    Parameters:
    
    x - the desired X component
    
    y - the desired Y component
    
    z - the desired Z component
    
    Returns:
    
    the (modified) current instance (for chaining)
  - set
```
public final Vec3d set(Vec3d v)
```
    Copies all 3 components from the argument.
    
    Parameters:
    
    v - the Vec3d to copy (not null, unaffected)
    
    Returns:
    
    the (modified) current instance (for chaining)
  - set
```
public final Vec3d set(Vec3i v)
```
  - set
```
public final Vec3d set(com.jme3.math.Vector3f v)
```
    Copies all 3 components from the argument, converting them to double precision.
    
    Parameters:
    
    v - the Vector3f to copy (not null, unaffected)
    
    Returns:
    
    the (modified) current instance (for chaining)
  - toVec3i
```
public final Vec3i toVec3i()
```
    Returns the raw (int) cast version of this Vec3d as a Vec3i.
    
    Returns:
    
    a new Vec3i instance
  - floor
```
public final Vec3i floor()
```
    Returns the Math.floor() version of this Vec3d as a Vec3i.
    
    Returns:
    
    a new Vec3i instance
  - ceil
```
public final Vec3i ceil()
```
    Returns the Math.ceil() version of this Vec3d as a Vec3i.
    
    Returns:
    
    a new Vec3i instance
  - clone
```
public final Vec3d clone()
```
    Creates a copy. The current instance is unaffected.
    
    Overrides:
    
    clone in class java.lang.Object
    
    Returns:
    
    a new instance, equivalent to the current one
  - get
```
public double get(int i)
```
    Returns the indexed component. The vector is unaffected.
    
    Parameters:
    
    i - 0, 1, or 2
    
    Returns:
    
    the X component if i=0, the Y component if i=1, or the Z component if i=2
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if i is not 0, 1, or 2
  - set
```
public Vec3d set(int i,
                 double d)
```
    Alters the indexed component.
    
    Parameters:
    
    i - which component to set: 0 → the X component, 1 → the Y component, 2 → the Z component
    
    d - the desired component value
    
    Returns:
    
    the (modified) current instance (for chaining)
    
    Throws:
    
    java.lang.IllegalArgumentException - if i is not 0, 1, or 2
  - add
```
public final Vec3d add(Vec3d v)
```
    Adds the argument and returns the sum as a new instance. The current instance is unaffected.
    
    Parameters:
    
    v - the vector to add (not null, unaffected)
    
    Returns:
    
    a new Vec3d
  - add
```
public final Vec3d add(Vec3i v)
```
  - add
```
public final Vec3d add(double vx,
                       double vy,
                       double vz)
```
    Adds specified amounts to the vector's components and returns the sum as a new instance. The current instance is unaffected.
    
    Parameters:
    
    vx - the amount to add to the X component
    
    vy - the amount to add to the Y component
    
    vz - the amount to add to the Z component
    
    Returns:
    
    a new Vec3d
  - subtract
```
public final Vec3d subtract(Vec3d v)
```
    Subtracts the argument and returns the difference as a new instance. The current instance is unaffected.
    
    Parameters:
    
    v - the vector to subtract (not null, unaffected)
    
    Returns:
    
    a new Vec3d
  - subtract
```
public final Vec3d subtract(Vec3i v)
```
  - subtract
```
public final Vec3d subtract(double vx,
                            double vy,
                            double vz)
```
    Subtracts specified amounts from the vector's components and returns the difference as a new instance. The current instance is unaffected.
    
    Parameters:
    
    vx - the amount to add to the X component
    
    vy - the amount to add to the Y component
    
    vz - the amount to add to the Z component
    
    Returns:
    
    a new Vec3d
  - mult
```
public final Vec3d mult(double s)
```
    Multiplies with the scalar argument and returns the product as a new instance. The current instance is unaffected.
    
    Parameters:
    
    s - the scaling factor
    
    Returns:
    
    a new Vec3d
  - mult
```
public final Vec3d mult(Vec3d v)
```
    Multiplies component-wise with the argument and returns the product as a new instance. The current instance is unaffected.
    
    Parameters:
    
    v - the scale vector (not null, unaffected)
    
    Returns:
    
    a new Vec3d
  - mult
```
public final Vec3d mult(Vec3i v)
```
  - divide
```
public final Vec3d divide(double s)
```
    Divides by the scalar argument and returns the quotient as a new instance. The current instance is unaffected.
    
    Parameters:
    
    s - the divisor
    
    Returns:
    
    a new Vec3d
  - divide
```
public final Vec3d divide(Vec3d v)
```
    Divides component-wise by the argument and returns the quotient as a new instance. The current instance is unaffected.
    
    Parameters:
    
    v - the inverse scale vector (not null, unaffected)
    
    Returns:
    
    a new Vec3d
  - divide
```
public final Vec3d divide(Vec3i v)
```
  - addLocal
```
public final Vec3d addLocal(Vec3d v)
```
    Adds the argument and returns the (modified) current instance.
    It IS safe for v and this to be the same object.
    
    Parameters:
    
    v - the vector to add (not null, unaffected unless it's this)
    
    Returns:
    
    the (modified) current instance (for chaining)
  - addLocal
```
public final Vec3d addLocal(Vec3i v)
```
    Adds the Vec3i argument and returns the (modified) current instance.
    
    Parameters:
    
    v - the vector to add (not null, unaffected)
    
    Returns:
    
    the (modified) current instance (for chaining)
  - addLocal
```
public final Vec3d addLocal(double vx,
                            double vy,
                            double vz)
```
    Adds specified amounts to the vector's components and returns the (modified) current instance.
    
    Parameters:
    
    vx - the amount to add to the X component
    
    vy - the amount to add to the Y component
    
    vz - the amount to add to the Z component
    
    Returns:
    
    the (modified) current instance (for chaining)
  - subtractLocal
```
public final Vec3d subtractLocal(Vec3d v)
```
    Subtracts the argument and returns the (modified) current instance.
    It IS safe for v and this to be the same object.
    
    Parameters:
    
    v - the vector to subtract (not null, unaffected unless it's this)
    
    Returns:
    
    the (modified) current instance (for chaining)
  - subtractLocal
```
public final Vec3d subtractLocal(Vec3i v)
```
  - subtractLocal
```
public final Vec3d subtractLocal(double vx,
                                 double vy,
                                 double vz)
```
    Subtracts the specified amounts from the vector's components and returns the (modified) current instance.
    
    Parameters:
    
    vx - the amount to subtract from the X component
    
    vy - the amount to subtract from the Y component
    
    vz - the amount to subtract from the Z component
    
    Returns:
    
    the (modified) current instance (for chaining)
  - multLocal
```
public final Vec3d multLocal(double s)
```
    Multiplies by the scalar argument and returns the (modified) current instance.
    
    Parameters:
    
    s - the scaling factor
    
    Returns:
    
    the (modified) current instance (for chaining)
  - multLocal
```
public final Vec3d multLocal(Vec3d v)
```
    Multiplies component-wise by the argument and returns the (modified) current instance.
    It IS safe for v and this to be the same object.
    
    Parameters:
    
    v - the scale vector (not null, unaffected unless it's this)
    
    Returns:
    
    the (modified) current instance (for chaining)
  - multLocal
```
public final Vec3d multLocal(Vec3i v)
```
  - divideLocal
```
public final Vec3d divideLocal(double s)
```
    Divides by the argument and returns the (modified) current instance.
    
    Parameters:
    
    s - the divisor
    
    Returns:
    
    the (modified) current instance (for chaining)
  - divideLocal
```
public final Vec3d divideLocal(Vec3d v)
```
    Divides component-wise by the argument and returns the (modified) current instance.
    It IS safe for v and this to be the same object.
    
    Parameters:
    
    v - the divisor (not null, unaffected unless it's this)
    
    Returns:
    
    the (modified) current instance (for chaining)
  - lengthSq
```
public final double lengthSq()
```
    Returns the square of the length. The current instance is unaffected.
    
    Returns:
    
    the sum of the squared components (not negative)
  - length
```
public final double length()
```
    Returns the length (or magnitude). The current instance is unaffected.
    
    Returns:
    
    the root-sum of the squared components (not negative)
  - distanceSq
```
public final double distanceSq(Vec3d v)
```
  - distanceSq
```
public final double distanceSq(Vec3i v)
```
  - distance
```
public final double distance(Vec3d v)
```
  - distanceSq
```
public final double distanceSq(double vx,
                               double vy,
                               double vz)
```
  - distance
```
public final double distance(double vx,
                             double vy,
                             double vz)
```
  - normalize
```
public final Vec3d normalize()
```
  - normalizeLocal
```
public final Vec3d normalizeLocal()
```
    Normalize this vector in place. For a zero vector, the result is undefined.
    
    Returns:
    
    the (normalized) current instance (for chaining)
  - dot
```
public final double dot(Vec3d v)
```
    Returns the dot (or inner) product with the argument. The current instance is unaffected.
    
    Parameters:
    
    v - the vector to multiply (not null, unaffected)
    
    Returns:
    
    the dot product
  - dot
```
public final double dot(Vec3i v)
```
  - dot
```
public final double dot(double vx,
                        double vy,
                        double vz)
```
  - cross
```
public final Vec3d cross(Vec3d v)
```
    Calculates a cross product with the argument and returns the product as a new instance. The current instance is unaffected.
    
    Parameters:
    
    v - the right factor (not null, unaffected)
    
    Returns:
    
    this cross v (a new Vec3d)
  - cross
```
public final Vec3d cross(double vx,
                         double vy,
                         double vz)
```
  - crossLocal
```
public final Vec3d crossLocal(Vec3d v)
```
  - addScaledVectorLocal
```
public final Vec3d addScaledVectorLocal(Vec3d toAdd,
                                        double scale)
```
  - minLocal
```
public final Vec3d minLocal(Vec3d v)
```
  - maxLocal
```
public final Vec3d maxLocal(Vec3d v)
```
  - zeroEpsilon
```
public final Vec3d zeroEpsilon(double e)
```
  - interpolateLocal
```
public final Vec3d interpolateLocal(Vec3d start,
                                    Vec3d end,
                                    double mix)
```
    Sets the value of this Vec3d to be the linearly interpolated value of start and end using the mix value as the 0 to 1 position between start and end. Basically, this = (1 - min) * start + mix * end.
  - xzy
```
public final Vec3d xzy()
```
  - toString
```
public java.lang.String toString()
```
    Returns a string representation of the vector, which is unaffected. For example, the +X direction vector is represented by:
```
 Vec3d[1.0, 0.0, 0.0]
 
```
    Overrides:
    
    toString in class java.lang.Object
    
    Returns:
    
    the string representation (not null, not empty)

Class Vec3d

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

UNIT_X

UNIT_Y

UNIT_Z

ZERO

x

y

z

Constructor Detail

Vec3d

Vec3d

Vec3d

Vec3d

Vec3d

Method Detail

toVector3f

isNaN

hashCode

equals

isSimilar

isFinite

set

set

set

set

toVec3i

floor

ceil

clone

get

set

add

add

add

subtract

subtract

subtract

mult

mult

mult

divide

divide

divide

addLocal

addLocal

addLocal

subtractLocal

subtractLocal

subtractLocal

multLocal

multLocal

multLocal

divideLocal

divideLocal

lengthSq

length

distanceSq

distanceSq

distance

distanceSq

distance

normalize

normalizeLocal

dot

dot

dot

cross

cross

crossLocal

addScaledVectorLocal

minLocal

maxLocal

zeroEpsilon

interpolateLocal

xzy