java.lang.Object
- WildMagic.LibFoundation.Mathematics.Vector3d

All Implemented Interfaces:

java.io.Serializable, java.lang.Comparable<Vector3d>
```
public class Vector3d
extends java.lang.Object
implements java.lang.Comparable<Vector3d>, java.io.Serializable
```
3D Vector object.

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type	Field	Description
`static Vector3d`	`ONE`	One vector: (1,1,1)
`private static long`	`serialVersionUID`	Serialization support
`static Vector3d`	`UNIT_X`	Unit-X vector: (1,0,0)
`static Vector3d`	`UNIT_X_NEG`	negative unit-X vector: (-1,0,0)
`static Vector3d`	`UNIT_Y`	Unit-Y vector: (0,1,0)
`static Vector3d`	`UNIT_Y_NEG`	negative unit-Y vector: (0,-1,0)
`static Vector3d`	`UNIT_Z`	Unit-Z vector: (0,0,1)
`static Vector3d`	`UNIT_Z_NEG`	negative unit-Z vector: (0,0,-1)
`double`	`X`	Vector data:
`double`	`Y`
`double`	`Z`
`static Vector3d`	`ZERO`	Zero vector: (0,0,0)

Constructor Summary

Constructors
Constructor	Description
`Vector3d()`	construction, initialized to (0,0,0)
`Vector3d(double[] afTuple)`	construction
`Vector3d(double fX, double fY, double fZ)`	construction
`Vector3d(Vector3d rkV)`	copy construction

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`Vector3d`	`add(double fX, double fY, double fZ)`	Add the inputs to this, this = this + fX,fY,fZ
`Vector3d`	`add(Vector3d rkV)`	Add the input vector to this: this = this + rkV
`static Vector3d`	`add(Vector3d rkV1, Vector3d rkV2)`	Add the two input vectors, setting this: this = rkV1 + rkV2
`double`	`angle(Vector3d rkV1)`
`static double`	`angle(Vector3d rkV1, Vector3d rkV2)`
`int`	`compare(Vector3d arg0, Vector3d arg1)`	Sorting a list of Vector3d in order, where each element is a column when two Vector3d have equal X then the sort is by Y.
`int`	`compareTo(Vector3d arg0)`
`static void`	`computeExtremes(int iVQuantity, Vector3d[] akPoint, Vector3d rkMin, Vector3d rkMax)`	Computes the extremes: min, max for x,y,z from an array of Vector3d.
`Vector3d`	`copy(Vector3d rkV)`	copy into this vector.
`Vector3d`	`cross(Vector3d rkV)`	The cross products are computed using the right-handed rule.
`static Vector3d`	`cross(Vector3d kV1, Vector3d kV2)`	The cross products are computed using the right-handed rule.
`double`	`distance(Vector3d kV)`	Compute the distance from this vector to the input vector.
`Vector3d`	`div(double fScalar)`	Divide this vector by fScalar: this = this/fScalar
`static Vector3d`	`div(double fScalar, Vector3d kV)`	Divide the vector by fScalar, setting this: this = kV/fScalar
`double`	`dot(Vector3d rkV)`	Compute dot-product of this vector with input vector:
`boolean`	`equals(java.lang.Object kObject)`
`static void`	`generateComplementBasis(Vector3d rkU, Vector3d rkV, Vector3d rkW)`	Input W must be a unit-length vector.
`static void`	`generateOrthonormalBasis(Vector3d rkU, Vector3d rkV, Vector3d rkW)`	Input W must be a nonzero vector.
`int`	`hashCode()`
`Vector3d`	`invert()`	Invert this vector: this = 1/this;
`boolean`	`isEqual(Vector3d rkV)`	Return true if the input Vector3d is equal to this.
`boolean`	`isLessThan(Vector3d rkV)`	Return true if the input Vector3d is less than to this.
`double`	`length()`	Compute length this vector:
`Vector3d`	`max(Vector3d kV)`	Maximum function.
`Vector3d`	`min(Vector3d kV)`	Minimum function.
`Vector3d`	`mult(Vector3d rkV)`	Multiply the input vector to this: this = this * rkV
`static Vector3d`	`mult(Vector3d rkV1, Vector3d rkV2)`	Multiply the two input vectors, setting this: this = rkV1 * rkV2
`Vector3d`	`neg()`	Negate this vector: this = - this.
`static Vector3d`	`neg(Vector3d kV)`	Set this to the negative of the input vector: this = -kV.
`double`	`normalize()`	Normalize this vector, return original length:
`static double`	`normalize(Vector3d kV)`	Normalize this vector, return original length:
`Vector3d`	`scale(double fScalar)`	this = this * fScalar
`Vector3d`	`scale(double fX, double fY, double fZ)`	Scale this vector by input: this = this * fScalar.
`static Vector3d`	`scale(double fScalar, Vector3d rkV)`
`Vector3d`	`scaleAdd(double fScalar, Vector3d rkV1, Vector3d rkV2)`	Scale the input vector by the scalar, setting this: this = fScalar * rkV1 + rkV2.
`Vector3d`	`set(double fX, double fY, double fZ)`	construction
`double`	`squaredDistance(Vector3d kV)`	Compute the distance from this vector to the input vector.
`double`	`squaredLength()`	Compute squared-length this vector:
`Vector3d`	`sub(Vector3d rkV)`	this = this - rkV
`static Vector3d`	`sub(Vector3d rkV1, Vector3d rkV2)`	Subtract the two input vectors, setting this: this = rkV1 - rkV2
`double`	`sum()`	Sum the elements of the vector.
`java.lang.String`	`toString()`	Returns a string representation of the vector values.
`Vector3d`	`unitCross(Vector3d rkV)`	The cross products are computed using the right-handed rule.
`static Vector3d`	`unitCross(Vector3d kV1, Vector3d kV2)`	The cross products are computed using the right-handed rule.

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

- Field Detail
  - serialVersionUID
```
private static final long serialVersionUID
```
    Serialization support
    
    See Also:
    
    Constant Field Values
  - ZERO
```
public static final transient Vector3d ZERO
```
    Zero vector: (0,0,0)
  - UNIT_X
```
public static final transient Vector3d UNIT_X
```
    Unit-X vector: (1,0,0)
  - UNIT_Y
```
public static final transient Vector3d UNIT_Y
```
    Unit-Y vector: (0,1,0)
  - UNIT_Z
```
public static final transient Vector3d UNIT_Z
```
    Unit-Z vector: (0,0,1)
  - UNIT_X_NEG
```
public static final transient Vector3d UNIT_X_NEG
```
    negative unit-X vector: (-1,0,0)
  - UNIT_Y_NEG
```
public static final transient Vector3d UNIT_Y_NEG
```
    negative unit-Y vector: (0,-1,0)
  - UNIT_Z_NEG
```
public static final transient Vector3d UNIT_Z_NEG
```
    negative unit-Z vector: (0,0,-1)
  - ONE
```
public static final transient Vector3d ONE
```
    One vector: (1,1,1)
  - X
```
public double X
```
    Vector data:
  - Y
```
public double Y
```
  - Z
```
public double Z
```
- Constructor Detail
  - Vector3d
```
public Vector3d()
```
    construction, initialized to (0,0,0)
  - Vector3d
```
public Vector3d(double fX,
                double fY,
                double fZ)
```
    construction
    
    Parameters:
    
    fX - x-value
    
    fY - y-value
    
    fZ - z-value
  - Vector3d
```
public Vector3d(double[] afTuple)
```
    construction
    
    Parameters:
    
    afTuple - x,y,z values
  - Vector3d
```
public Vector3d(Vector3d rkV)
```
    copy construction
    
    Parameters:
    
    rkV - vector to copy.
- Method Detail
  - angle
```
public static double angle(Vector3d rkV1,
                           Vector3d rkV2)
```
    Parameters:
    
    rkV1 -
    
    rkV2 -
    
    Returns:
  - computeExtremes
```
public static void computeExtremes(int iVQuantity,
                                   Vector3d[] akPoint,
                                   Vector3d rkMin,
                                   Vector3d rkMax)
```
    Computes the extremes: min, max for x,y,z from an array of Vector3d.
    
    Parameters:
    
    iVQuantity - the number of Vector3d in the array
    
    akPoint - the array of Vector3d to compute the extremes for.
    
    rkMin - set to minimum (x,y,z) of all the Vectors in the array.
    
    rkMax - set to maximum (x,y,z) of all the Vectors in the array.
  - generateComplementBasis
```
public static void generateComplementBasis(Vector3d rkU,
                                           Vector3d rkV,
                                           Vector3d rkW)
```
    Input W must be a unit-length vector. The output vectors {U,V} are unit length and mutually perpendicular, and {U,V,W} is an orthonormal basis.
    
    Parameters:
    
    rkU - U
    
    rkV - V
    
    rkW - W, input and output
  - generateOrthonormalBasis
```
public static void generateOrthonormalBasis(Vector3d rkU,
                                            Vector3d rkV,
                                            Vector3d rkW)
```
    Input W must be a nonzero vector. The output is an orthonormal basis {U,V,W}. The input W is normalized by this function. If you know W is already unit length, use GenerateComplementBasis to compute U and V.
    
    Parameters:
    
    rkU - U
    
    rkV - V
    
    rkW - W, input and output
  - add
```
public Vector3d add(double fX,
                    double fY,
                    double fZ)
```
    Add the inputs to this, this = this + fX,fY,fZ
    
    Parameters:
    
    fX - x-value
    
    fY - y-value
    
    fZ - z-value
  - add
```
public Vector3d add(Vector3d rkV)
```
    Add the input vector to this: this = this + rkV
    
    Parameters:
    
    rkV -
    
    Returns:
    
    this
  - add
```
public static Vector3d add(Vector3d rkV1,
                           Vector3d rkV2)
```
    Add the two input vectors, setting this: this = rkV1 + rkV2
    
    Parameters:
    
    rkV1 - first input vector
    
    rkV2 - second input vector
  - angle
```
public double angle(Vector3d rkV1)
```
  - copy
```
public Vector3d copy(Vector3d rkV)
```
    copy into this vector.
    
    Parameters:
    
    rkV - vector to copy.
  - cross
```
public Vector3d cross(Vector3d rkV)
```
    The cross products are computed using the right-handed rule. Be aware that some graphics APIs use a left-handed rule. If you have to compute a cross product with these functions and send the result to the API that expects left-handed, you will need to change sign on the vector (replace each component value c by -c). this = this ^ kV
    
    Parameters:
    
    rkV - vector to cross with this
  - cross
```
public static Vector3d cross(Vector3d kV1,
                             Vector3d kV2)
```
    The cross products are computed using the right-handed rule. Be aware that some graphics APIs use a left-handed rule. If you have to compute a cross product with these functions and send the result to the API that expects left-handed, you will need to change sign on the vector (replace each component value c by -c). this = kV1 ^ kV2
    
    Parameters:
    
    kV1 - first vector
    
    kV2 - second vector
  - distance
```
public double distance(Vector3d kV)
```
    Compute the distance from this vector to the input vector.
    
    Parameters:
    
    kV - vector to calculate distance to.
    
    Returns:
    
    distance from this vector to the input vector.
  - div
```
public Vector3d div(double fScalar)
```
    Divide this vector by fScalar: this = this/fScalar
    
    Parameters:
    
    fScalar - scale value
  - div
```
public static Vector3d div(double fScalar,
                           Vector3d kV)
```
    Divide the vector by fScalar, setting this: this = kV/fScalar
    
    Parameters:
    
    fScalar - scale value
    
    kV - input vector
  - dot
```
public double dot(Vector3d rkV)
```
    Compute dot-product of this vector with input vector:
    
    Returns:
    
    dot-product of this vector with input vector:
  - equals
```
public boolean equals(java.lang.Object kObject)
```
    Overrides:
    
    equals in class java.lang.Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - invert
```
public Vector3d invert()
```
    Invert this vector: this = 1/this;
  - isEqual
```
public boolean isEqual(Vector3d rkV)
```
    Return true if the input Vector3d is equal to this.
    
    Parameters:
    
    rkV - input vector to compare to this
    
    Returns:
    
    true if the input Vector3d is equal to this, false otherwise.
  - isLessThan
```
public boolean isLessThan(Vector3d rkV)
```
    Return true if the input Vector3d is less than to this.
    
    Parameters:
    
    rkV - input vector to compare to this
    
    Returns:
    
    true if the input Vector3d is less than to this, false otherwise.
  - length
```
public double length()
```
    Compute length this vector:
    
    Returns:
    
    length this vector
  - max
```
public Vector3d max(Vector3d kV)
```
    Maximum function. Sets this to be the maximum of this and the input vector: this = max( this, kV ).
    
    Parameters:
    
    kV - input vector.
  - min
```
public Vector3d min(Vector3d kV)
```
    Minimum function. Sets this to be the minimum of this and the input vector: this = min( this, kV ).
    
    Parameters:
    
    kV - input vector.
  - mult
```
public Vector3d mult(Vector3d rkV)
```
    Multiply the input vector to this: this = this * rkV
    
    Parameters:
    
    rkV - input vector to multiply to this
  - mult
```
public static Vector3d mult(Vector3d rkV1,
                            Vector3d rkV2)
```
    Multiply the two input vectors, setting this: this = rkV1 * rkV2
    
    Parameters:
    
    rkV1 - first input vector
    
    rkV2 - second input vector
  - neg
```
public Vector3d neg()
```
    Negate this vector: this = - this.
  - neg
```
public static Vector3d neg(Vector3d kV)
```
    Set this to the negative of the input vector: this = -kV.
    
    Parameters:
    
    kV - input vector.
  - normalize
```
public double normalize()
```
    Normalize this vector, return original length:
    
    Returns:
    
    original length:
  - normalize
```
public static double normalize(Vector3d kV)
```
    Normalize this vector, return original length:
    
    Returns:
    
    original length:
  - scale
```
public Vector3d scale(double fScalar)
```
    this = this * fScalar
    
    Parameters:
    
    fScalar -
    
    Returns:
    
    this
  - scale
```
public Vector3d scale(double fX,
                      double fY,
                      double fZ)
```
    Scale this vector by input: this = this * fScalar.
    
    Parameters:
    
    fX - scale X value
    
    fY - scale Y value
    
    fZ - scale Z value
  - scale
```
public static Vector3d scale(double fScalar,
                             Vector3d rkV)
```
    Parameters:
    
    fScalar -
    
    rkV -
    
    Returns:
    
    fScalar * rkV
  - scaleAdd
```
public Vector3d scaleAdd(double fScalar,
                         Vector3d rkV1,
                         Vector3d rkV2)
```
    Scale the input vector by the scalar, setting this: this = fScalar * rkV1 + rkV2.
    
    Parameters:
    
    fScalar - scale value
    
    rkV1 - input vector
    
    rkV2 - input vector
  - set
```
public Vector3d set(double fX,
                    double fY,
                    double fZ)
```
    construction
    
    Parameters:
    
    fX - x-value
    
    fY - y-value
    
    fZ - z-value
  - squaredDistance
```
public double squaredDistance(Vector3d kV)
```
    Compute the distance from this vector to the input vector.
    
    Parameters:
    
    kV - vector to calculate distance to.
    
    Returns:
    
    distance from this vector to the input vector.
  - squaredLength
```
public double squaredLength()
```
    Compute squared-length this vector:
    
    Returns:
    
    squared-length this vector
  - sub
```
public Vector3d sub(Vector3d rkV)
```
    this = this - rkV
    
    Parameters:
    
    rkV -
    
    Returns:
    
    this
  - sub
```
public static Vector3d sub(Vector3d rkV1,
                           Vector3d rkV2)
```
    Subtract the two input vectors, setting this: this = rkV1 - rkV2
    
    Parameters:
    
    rkV1 - first input vector
    
    rkV2 - second input vector
  - sum
```
public double sum()
```
    Sum the elements of the vector.
    
    Returns:
    
    vector sum
  - toString
```
public java.lang.String toString()
```
    Returns a string representation of the vector values.
    
    Overrides:
    
    toString in class java.lang.Object
    
    Returns:
    
    string representation of the vector values.
  - unitCross
```
public Vector3d unitCross(Vector3d rkV)
```
    The cross products are computed using the right-handed rule. Be aware that some graphics APIs use a left-handed rule. If you have to compute a cross product with these functions and send the result to the API that expects left-handed, you will need to change sign on the vector (replace each component value c by -c). this = this ^ kV Normalize(this)
    
    Parameters:
    
    rkV - vector to cross with this
  - unitCross
```
public static Vector3d unitCross(Vector3d kV1,
                                 Vector3d kV2)
```
    The cross products are computed using the right-handed rule. Be aware that some graphics APIs use a left-handed rule. If you have to compute a cross product with these functions and send the result to the API that expects left-handed, you will need to change sign on the vector (replace each component value c by -c). this = kV1 ^ kV2 Normalize(this)
    
    Parameters:
    
    kV1 - first vector
    
    kV2 - second vector
  - compare
```
public int compare(Vector3d arg0,
                   Vector3d arg1)
```
    Sorting a list of Vector3d in order, where each element is a column when two Vector3d have equal X then the sort is by Y.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
  - compareTo
```
public int compareTo(Vector3d arg0)
```
    Specified by:
    
    compareTo in interface java.lang.Comparable<Vector3d>

Class Vector3d

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

serialVersionUID

ZERO

UNIT_X

UNIT_Y

UNIT_Z

UNIT_X_NEG

UNIT_Y_NEG

UNIT_Z_NEG

ONE

X

Y

Z

Constructor Detail

Vector3d

Vector3d

Vector3d

Vector3d

Method Detail

angle

computeExtremes

generateComplementBasis

generateOrthonormalBasis

add

add

add

angle

copy

cross

cross

distance

div

div

dot

equals

hashCode

invert

isEqual

isLessThan

length

max

min

mult

mult

neg

neg

normalize

normalize

scale

scale

scale

scaleAdd

set

squaredDistance

squaredLength

sub

sub

sum

toString

unitCross

unitCross

compare

compareTo