QuaternionM4D (io7m-jtensors-documentation 6.0.0 API)

java.lang.Object
- com.io7m.jtensors.QuaternionM4D

All Implemented Interfaces:

QuaternionReadable4DType, QuaternionWritable4DType, VectorReadable2DType, VectorReadable3DType, VectorReadable4DType, VectorWritable2DType, VectorWritable3DType, VectorWritable4DType
```
public class QuaternionM4D
extends Object
implements QuaternionReadable4DType, QuaternionWritable4DType
```
A four-dimensional mutable quaternion type with double precision elements.
Values of this type cannot be accessed safely from multiple threads without explicit synchronization.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`QuaternionM4D.Context` The Context type contains the minimum storage required for all of the functions of the `QuaternionM4D` class.

Constructor Summary

Constructors
Constructor and Description
`QuaternionM4D()` Default constructor, initializing the quaternion with values `[0.0, 0.0, 0.0, 1.0]`
`QuaternionM4D(double in_x, double in_y, double in_z, double in_w)` Construct a quaternion initialized with the given values.
`QuaternionM4D(QuaternionReadable4DType q)` Construct a quaternion initialized with the values given in `q`.

Method Summary

Methods
Modifier and Type	Method and Description
`static QuaternionM4D`	`add(QuaternionReadable4DType q0, QuaternionReadable4DType q1, QuaternionM4D out)` Calculate the element-wise sum of the quaternions `q0` and `q1`, saving the result to `qr`.
`static QuaternionM4D`	`addInPlace(QuaternionM4D q0, QuaternionReadable4DType q1)` Calculate the element-wise sum of the quaternions `q0` and `q1`, saving the result to `q0`.
`static boolean`	`almostEqual(com.io7m.jequality.AlmostEqualDouble.ContextRelative context, QuaternionReadable4DType qa, QuaternionReadable4DType qb)` Determine whether or not the quaternions `qa` and `qb` are equal to within the degree of error given in `context`.
`static QuaternionM4D`	`conjugate(QuaternionReadable4DType q, QuaternionM4D out)` Calculate the conjugate of the input quaternion `q`, saving the result to `out`.
`static QuaternionM4D`	`conjugateInPlace(QuaternionM4D q)` Calculate the conjugate of the input quaternion `q`, modifying `q` in place.
`static QuaternionM4D`	`copy(QuaternionReadable4DType q, QuaternionM4D out)` Copy the contents of the quaternion `q` to `out`.
`void`	`copyFrom2D(VectorReadable2DType in_v)` Set the current vector to the contents of the input vector.
`void`	`copyFrom3D(VectorReadable3DType in_v)` Set the current vector to the contents of the input vector.
`void`	`copyFrom4D(VectorReadable4DType in_v)` Set the current vector to the contents of the input vector.
`static double`	`dotProduct(QuaternionReadable4DType q0, QuaternionReadable4DType q1)` Calculate the scalar product of the quaternions `q0` and `q1`.
`boolean`	`equals(Object obj)`
`double`	`getWD()`
`double`	`getXD()`
`double`	`getYD()`
`double`	`getZD()`
`int`	`hashCode()`
`static QuaternionM4D`	`interpolateLinear(QuaternionReadable4DType q0, QuaternionReadable4DType q1, double alpha, QuaternionM4D r)` Linearly interpolate between `q0` and `q1` by the amount `alpha`, such that: `interpolateLinear(q0, q1, 0.0, r) -> r = q0` `interpolateLinear(q0, q1, 1.0, r) -> r = q1`
`static boolean`	`isNegationOf(com.io7m.jequality.AlmostEqualDouble.ContextRelative context, QuaternionReadable4DType qa, QuaternionReadable4DType qb)` Return `true` iff `qa` is the negation of `qb`.
`static QuaternionM4D`	`lookAtWithContext(QuaternionM4D.Context context, VectorReadable3DType origin, VectorReadable3DType target, VectorReadable3DType up, QuaternionM4D q)` Produce a quaternion that represents a rotation that "looks at" the point at `target` assuming the viewer is at `origin`, using `up` as the "up" vector, saving the result to `q`.
`static double`	`magnitude(QuaternionReadable4DType q)` Calculate the magnitude of the quaternion `q`.
`static double`	`magnitudeSquared(QuaternionReadable4DType q)` Calculate the squared magnitude of the quaternion `q`.
`static QuaternionM4D`	`makeFromAxisAngle(VectorReadable3DType axis, double angle, QuaternionM4D out)` Produce a quaternion that represents a rotation of `angle` degrees around the axis specified by `axis`, saving the result to `out`.
`static QuaternionM4D`	`makeFromRotationMatrix3x3(MatrixReadable3x3DType m, QuaternionM4D out)` Produce a quaternion equivalent to the rotation matrix `m`, writing the result to `out`.
`static QuaternionM4D`	`makeFromRotationMatrix4x4(MatrixReadable4x4DType m, QuaternionM4D out)` Produce a quaternion equivalent to the rotation matrix `m`, writing the result to `out`.
`static MatrixM3x3D`	`makeRotationMatrix3x3(QuaternionReadable4DType q, MatrixM3x3D m)` Produce a rotation matrix from the quaternion `q`, saving the result to `m`.
`static MatrixM4x4D`	`makeRotationMatrix4x4(QuaternionReadable4DType q, MatrixM4x4D m)` Produce a rotation matrix from the quaternion `q`, saving the result to `m`.
`static QuaternionM4D`	`multiply(QuaternionReadable4DType q0, QuaternionReadable4DType q1, QuaternionM4D qr)` Multiply the quaternion `q0` by the quaternion `q1` , saving the result to `qr`.
`static QuaternionM4D`	`multiplyInPlace(QuaternionM4D q0, QuaternionReadable4DType q1)` Multiply the quaternion `q0` by the quaternion `q1` , saving the result to `q0`.
`static QuaternionM4D`	`negate(QuaternionReadable4DType qa, QuaternionM4D out)` Negate the elements of `qa`, writing the resulting quaternion to `out`.
`static QuaternionM4D`	`negateInPlace(QuaternionM4D q)` Negate the elements of `q`, modifying the quaternion in-place.
`static QuaternionM4D`	`normalize(QuaternionReadable4DType q, QuaternionM4D out)` Returns a quaternion with the same orientation as `q` but with magnitude equal to `1.0` in `out`.
`static QuaternionM4D`	`normalizeInPlace(QuaternionM4D q)` Returns a quaternion with the same orientation as `q` but with magnitude equal to `1.0` in `q`.
`static QuaternionM4D`	`scale(QuaternionReadable4DType q, double r, QuaternionM4D out)` Scale the quaternion `q` by the scalar `r`, saving the result to `out`.
`static QuaternionM4D`	`scaleInPlace(QuaternionM4D q, double r)` Scale the quaternion `q` by the scalar `r`, saving the result to `q`.
`void`	`set2D(double in_x, double in_y)` Set the current `x` and `y` values of the current vector.
`void`	`set3D(double in_x, double in_y, double in_z)` Set the current `x`, `y` and `z` values of the current vector.
`void`	`set4D(double in_x, double in_y, double in_z, double in_w)` Set the current `x`, `y`, `z` and `w` values of the current vector.
`void`	`setWD(double in_w)` Set the current `w` value of the current vector.
`void`	`setXD(double in_x)` Set the current `x` value of the current vector.
`void`	`setYD(double in_y)` Set the current `y` value of the current vector.
`void`	`setZD(double in_z)` Set the current `z` value of the current vector.
`static QuaternionM4D`	`subtract(QuaternionReadable4DType q0, QuaternionReadable4DType q1, QuaternionM4D out)` Subtract the quaternion `q0` from the quaternion `q1`, saving the result to `out`.
`static QuaternionM4D`	`subtractInPlace(QuaternionM4D q0, QuaternionReadable4DType q1)` Subtract the quaternion `q0` from the quaternion `q1`, saving the result to `q0`.
`String`	`toString()`

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

- Constructor Detail
  - QuaternionM4D
```
public QuaternionM4D()
```
    Default constructor, initializing the quaternion with values [0.0, 0.0, 0.0, 1.0]
  - QuaternionM4D
```
public QuaternionM4D(double in_x,
             double in_y,
             double in_z,
             double in_w)
```
    Construct a quaternion initialized with the given values.
    
    Parameters:
    in_x - The x value
    in_y - The y value
    in_z - The z value
    in_w - The w value
  - QuaternionM4D
```
public QuaternionM4D(QuaternionReadable4DType q)
```
    Construct a quaternion initialized with the values given in q.
    
    Parameters:
    q - The source quaternion
- Method Detail
  - add
```
public static final QuaternionM4D add(QuaternionReadable4DType q0,
                QuaternionReadable4DType q1,
                QuaternionM4D out)
```
    Calculate the element-wise sum of the quaternions q0 and q1, saving the result to qr.
    
    Parameters:
    q0 - The left input quaternion
    q1 - The right input quaternion
    out - The output quaternion
    
    Returns:
    (q0.x + q1.x, q0.y + q1.y, q0.z + q1.z, q0.w + q1.w)
  - addInPlace
```
public static final QuaternionM4D addInPlace(QuaternionM4D q0,
                       QuaternionReadable4DType q1)
```
    Calculate the element-wise sum of the quaternions q0 and q1, saving the result to q0.
    
    Parameters:
    q0 - The left input quaternion
    q1 - The right input quaternion
    
    Returns:
    (q0.x + q1.x, q0.y + q1.y, q0.z + q1.z, q0.w + q1.w)
  - almostEqual
```
public static final boolean almostEqual(com.io7m.jequality.AlmostEqualDouble.ContextRelative context,
                  QuaternionReadable4DType qa,
                  QuaternionReadable4DType qb)
```
    Determine whether or not the quaternions qa and qb are equal to within the degree of error given in context.
    
    Parameters:
    context - The equality context
    qa - The left input quaternion
    qb - The right input quaternion
    
    Returns:
    true if the quaternions are almost equal
    Since:
    
    5.0.0
    
    See Also:
    AlmostEqualDouble.almostEqual(ContextRelative, double, double)
  - conjugate
```
public static final QuaternionM4D conjugate(QuaternionReadable4DType q,
                      QuaternionM4D out)
```
    Calculate the conjugate of the input quaternion q, saving the result to out.
    
    Parameters:
    q - The input quaternion
    out - The output quaternion
    
    Returns:
    out
  - conjugateInPlace
```
public static final QuaternionM4D conjugateInPlace(QuaternionM4D q)
```
    Calculate the conjugate of the input quaternion q, modifying q in place.
    
    Parameters:
    q - The input quaternion
    
    Returns:
    q
  - copy
```
public static final QuaternionM4D copy(QuaternionReadable4DType q,
                 QuaternionM4D out)
```
    Copy the contents of the quaternion q to out.
    
    Parameters:
    q - The input quaternion
    out - The output quaternion
    
    Returns:
    out
  - dotProduct
```
public static final double dotProduct(QuaternionReadable4DType q0,
                QuaternionReadable4DType q1)
```
    Calculate the scalar product of the quaternions q0 and q1.
    
    Parameters:
    q0 - The left input quaternion
    q1 - The right input quaternion
    
    Returns:
    The scalar product of the two quaternions
  - interpolateLinear
```
public static final QuaternionM4D interpolateLinear(QuaternionReadable4DType q0,
                              QuaternionReadable4DType q1,
                              double alpha,
                              QuaternionM4D r)
```
    Linearly interpolate between q0 and q1 by the amount alpha, such that:
    - interpolateLinear(q0, q1, 0.0, r) -> r = q0
    - interpolateLinear(q0, q1, 1.0, r) -> r = q1
    Parameters:
    q0 - The left input quaternion
    q1 - The right input quaternion
    alpha - The interpolation value, between 0.0 and 1.0
    r - The output quaternion
    
    Returns:
    (1 - alpha) * q0 + alpha * q1
  - isNegationOf
```
public static final boolean isNegationOf(com.io7m.jequality.AlmostEqualDouble.ContextRelative context,
                   QuaternionReadable4DType qa,
                   QuaternionReadable4DType qb)
```
    Return true iff qa is the negation of qb.
    Each element is compared with AlmostEqualDouble.almostEqual(ContextRelative, double, double).
    
    Parameters:
    context - The equality context
    qa - The left quaternion
    qb - The right quaternion
    
    Returns:
    true iff qa is the negation of qb
    Since:
    
    5.0.0
  - lookAtWithContext
```
public static final QuaternionM4D lookAtWithContext(QuaternionM4D.Context context,
                              VectorReadable3DType origin,
                              VectorReadable3DType target,
                              VectorReadable3DType up,
                              QuaternionM4D q)
```
    Produce a quaternion that represents a rotation that "looks at" the point at target assuming the viewer is at origin, using up as the "up" vector, saving the result to q.
    The function uses storage preallocated in context to avoid any new allocations.
    
    Parameters:
    context - Preallocated storage
    q - The output quaternion
    origin - The origin point
    target - The target point
    up - The up vector
    
    Returns:
    q
    Since:
    
    5.0.0
  - magnitude
```
public static final double magnitude(QuaternionReadable4DType q)
```
    Calculate the magnitude of the quaternion q. Correspondingly, magnitude(normalize(q)) == 1.0.
    
    Parameters:
    q - The input quaternion
    
    Returns:
    The magnitude of the input quaternion
  - magnitudeSquared
```
public static final double magnitudeSquared(QuaternionReadable4DType q)
```
    Calculate the squared magnitude of the quaternion q.
    
    Parameters:
    q - The input quaternion
    
    Returns:
    The squared magnitude of the input quaternion
  - makeFromAxisAngle
```
public static final QuaternionM4D makeFromAxisAngle(VectorReadable3DType axis,
                              double angle,
                              QuaternionM4D out)
```
    Produce a quaternion that represents a rotation of angle degrees around the axis specified by axis, saving the result to out. axis is assumed to be of unit length.
    
    Parameters:
    axis - The normalized quaternion representing the axis
    angle - The angle to rotate, in radians
    out - The output quaternion
    
    Returns:
    A quaternion representing the rotation
    See Also:
    VectorI3D.normalize(VectorReadable3DType), VectorI4D.normalize(VectorReadable4DType), VectorM3D.normalize(VectorReadable3DType, VectorM3D), VectorM4D.normalize(VectorReadable4DType, VectorM4D)
  - makeFromRotationMatrix3x3
```
public static final QuaternionM4D makeFromRotationMatrix3x3(MatrixReadable3x3DType m,
                                      QuaternionM4D out)
```
    Produce a quaternion equivalent to the rotation matrix m, writing the result to out.
    
    Parameters:
    m - The rotation matrix
    out - The output quaternion
    
    Returns:
    out
    Since:
    
    5.0.0
  - makeFromRotationMatrix4x4
```
public static final QuaternionM4D makeFromRotationMatrix4x4(MatrixReadable4x4DType m,
                                      QuaternionM4D out)
```
    Produce a quaternion equivalent to the rotation matrix m, writing the result to out.
    
    Parameters:
    m - The rotation matrix
    out - The output quaternion
    
    Returns:
    out
    Since:
    
    5.0.0
  - makeRotationMatrix3x3
```
public static final MatrixM3x3D makeRotationMatrix3x3(QuaternionReadable4DType q,
                                MatrixM3x3D m)
```
    Produce a rotation matrix from the quaternion q, saving the result to m.
    
    Parameters:
    q - The input quaternion
    m - The output matrix
    
    Returns:
    m
    Since:
    
    5.0.0
  - makeRotationMatrix4x4
```
public static final MatrixM4x4D makeRotationMatrix4x4(QuaternionReadable4DType q,
                                MatrixM4x4D m)
```
    Produce a rotation matrix from the quaternion q, saving the result to m.
    
    Parameters:
    q - The input quaternion
    m - The output matrix
    
    Returns:
    m
    Since:
    
    5.0.0
  - multiply
```
public static final QuaternionM4D multiply(QuaternionReadable4DType q0,
                     QuaternionReadable4DType q1,
                     QuaternionM4D qr)
```
    Multiply the quaternion q0 by the quaternion q1 , saving the result to qr.
    Note that this operation is not commutative.
    
    The function is most often used to concatenate quaternions to combine rotations. As an example, assuming that:
    - qx represents some rotation around the X axis
    - qy represents some rotation around the Y axis
    - qz represents some rotation around the Z axis
    The following code produces a quaternion qr that represents a rotation around the X axis, followed by a rotation around the Y axis, followed by a rotation around the Z axis:
```
 QuaternionM4D qr = new QuaternionM4D();
 QuaternionM4D.multiply(qy, qx, qr);
 QuaternionM4D.multiply(qz, qr, qr);
 
```
    Parameters:
    q0 - The left input quaternion
    q1 - The right input quaternion
    qr - The output quaternion
    
    Returns:
    qr
  - multiplyInPlace
```
public static final QuaternionM4D multiplyInPlace(QuaternionM4D q0,
                            QuaternionReadable4DType q1)
```
    Multiply the quaternion q0 by the quaternion q1 , saving the result to q0.
    
    Parameters:
    q0 - The left quaternion
    q1 - The right quaternion
    
    Returns:
    q0
    See Also:
    multiply(QuaternionReadable4DType, QuaternionReadable4DType, QuaternionM4D)
  - negate
```
public static final QuaternionM4D negate(QuaternionReadable4DType qa,
                   QuaternionM4D out)
```
    Negate the elements of qa, writing the resulting quaternion to out.
    
    Parameters:
    qa - The input quaternion
    out - The output quaternion
    
    Returns:
    out
    Since:
    
    5.0.0
  - negateInPlace
```
public static final QuaternionM4D negateInPlace(QuaternionM4D q)
```
    Negate the elements of q, modifying the quaternion in-place.
    
    Parameters:
    q - The input quaternion
    
    Returns:
    q
    Since:
    
    5.0.0
  - normalize
```
public static final QuaternionM4D normalize(QuaternionReadable4DType q,
                      QuaternionM4D out)
```
    Returns a quaternion with the same orientation as q but with magnitude equal to 1.0 in out. The function returns the zero quaternion iff the input is the zero quaternion.
    
    Parameters:
    out - The output quaternion
    q - The input quaternion
    
    Returns:
    out
  - normalizeInPlace
```
public static final QuaternionM4D normalizeInPlace(QuaternionM4D q)
```
    Returns a quaternion with the same orientation as q but with magnitude equal to 1.0 in q. The function returns the zero quaternion iff the input is the zero quaternion.
    
    Parameters:
    q - The input quaternion
    
    Returns:
    q
  - scale
```
public static final QuaternionM4D scale(QuaternionReadable4DType q,
                  double r,
                  QuaternionM4D out)
```
    Scale the quaternion q by the scalar r, saving the result to out.
    
    Parameters:
    q - The input quaternion
    r - The scaling value
    out - The output quaternion
    
    Returns:
    (q.x * r, q.y * r, q.z * r, q.w * r)
  - scaleInPlace
```
public static final QuaternionM4D scaleInPlace(QuaternionM4D q,
                         double r)
```
    Scale the quaternion q by the scalar r, saving the result to q.
    
    Parameters:
    q - The input quaternion
    r - The scaling value
    
    Returns:
    (q.x * r, q.y * r, q.z * r, q.w * r)
  - subtract
```
public static final QuaternionM4D subtract(QuaternionReadable4DType q0,
                     QuaternionReadable4DType q1,
                     QuaternionM4D out)
```
    Subtract the quaternion q0 from the quaternion q1, saving the result to out.
    
    Parameters:
    q0 - The left input quaternion
    q1 - The right input quaternion
    out - The output quaternion
    
    Returns:
    (q0.x - q1.x, q0.y - q1.y, q0.z - q1.z, q0.w - q1.w)
  - subtractInPlace
```
public static final QuaternionM4D subtractInPlace(QuaternionM4D q0,
                            QuaternionReadable4DType q1)
```
    Subtract the quaternion q0 from the quaternion q1, saving the result to q0.
    
    Parameters:
    q0 - The left input quaternion
    q1 - The right input quaternion
    
    Returns:
    (q0.x - q1.x, q0.y - q1.y, q0.z - q1.z, q0.w - q1.w)
  - copyFrom2D
```
public final void copyFrom2D(VectorReadable2DType in_v)
```
    Description copied from interface: VectorWritable2DType
    
    Set the current vector to the contents of the input vector.
    
    Specified by:
    
    copyFrom2D in interface VectorWritable2DType
    
    Parameters:
    in_v - The input vector
  - copyFrom3D
```
public final void copyFrom3D(VectorReadable3DType in_v)
```
    Description copied from interface: VectorWritable3DType
    
    Set the current vector to the contents of the input vector.
    
    Specified by:
    
    copyFrom3D in interface VectorWritable3DType
    
    Parameters:
    in_v - The input vector
  - copyFrom4D
```
public final void copyFrom4D(VectorReadable4DType in_v)
```
    Description copied from interface: VectorWritable4DType
    
    Set the current vector to the contents of the input vector.
    
    Specified by:
    
    copyFrom4D in interface VectorWritable4DType
    
    Parameters:
    in_v - The input vector
  - equals
```
public final boolean equals(@Nullable
             Object obj)
```
    Overrides:
    
    equals in class Object
  - getWD
```
public final double getWD()
```
    Specified by:
    
    getWD in interface VectorReadable4DType
    
    Returns:
    The W value of the given vector.
  - getXD
```
public final double getXD()
```
    Specified by:
    
    getXD in interface VectorReadable2DType
    
    Returns:
    The X value of the given vector.
  - getYD
```
public final double getYD()
```
    Specified by:
    
    getYD in interface VectorReadable2DType
    
    Returns:
    The Y value of the given vector.
  - getZD
```
public final double getZD()
```
    Specified by:
    
    getZD in interface VectorReadable3DType
    
    Returns:
    The Z value of the given vector.
  - hashCode
```
public final int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - set2D
```
public final void set2D(double in_x,
         double in_y)
```
    Description copied from interface: VectorWritable2DType
    
    Set the current x and y values of the current vector.
    
    Specified by:
    
    set2D in interface VectorWritable2DType
    
    Parameters:
    in_x - The new x value.
    in_y - The new y value.
  - set3D
```
public final void set3D(double in_x,
         double in_y,
         double in_z)
```
    Description copied from interface: VectorWritable3DType
    
    Set the current x, y and z values of the current vector.
    
    Specified by:
    
    set3D in interface VectorWritable3DType
    
    Parameters:
    in_x - The new x value.
    in_y - The new y value.
    in_z - The new z value.
  - set4D
```
public final void set4D(double in_x,
         double in_y,
         double in_z,
         double in_w)
```
    Description copied from interface: VectorWritable4DType
    
    Set the current x, y, z and w values of the current vector.
    
    Specified by:
    
    set4D in interface VectorWritable4DType
    
    Parameters:
    in_x - The new x value.
    in_y - The new y value.
    in_z - The new z value.
    in_w - The new w value.
  - setWD
```
public final void setWD(double in_w)
```
    Description copied from interface: VectorWritable4DType
    
    Set the current w value of the current vector.
    
    Specified by:
    
    setWD in interface VectorWritable4DType
    
    Parameters:
    in_w - The new w value.
  - setXD
```
public final void setXD(double in_x)
```
    Description copied from interface: VectorWritable2DType
    
    Set the current x value of the current vector.
    
    Specified by:
    
    setXD in interface VectorWritable2DType
    
    Parameters:
    in_x - The new x value.
  - setYD
```
public final void setYD(double in_y)
```
    Description copied from interface: VectorWritable2DType
    
    Set the current y value of the current vector.
    
    Specified by:
    
    setYD in interface VectorWritable2DType
    
    Parameters:
    in_y - The new y value.
  - setZD
```
public final void setZD(double in_z)
```
    Description copied from interface: VectorWritable3DType
    
    Set the current z value of the current vector.
    
    Specified by:
    
    setZD in interface VectorWritable3DType
    
    Parameters:
    in_z - The new z value.
  - toString
```
public final String toString()
```
    Overrides:
    
    toString in class Object

Class QuaternionM4D

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

QuaternionM4D

QuaternionM4D

QuaternionM4D

Method Detail

add

addInPlace

almostEqual

conjugate

conjugateInPlace

copy

dotProduct

interpolateLinear

isNegationOf

lookAtWithContext

magnitude

magnitudeSquared

makeFromAxisAngle

makeFromRotationMatrix3x3

makeFromRotationMatrix4x4

makeRotationMatrix3x3

makeRotationMatrix4x4

multiply

multiplyInPlace

negate

negateInPlace

normalize

normalizeInPlace

scale

scaleInPlace

subtract

subtractInPlace

copyFrom2D

copyFrom3D

copyFrom4D

equals

getWD

getXD

getYD

getZD

hashCode

set2D

set3D

set4D

setWD

setXD

setYD

setZD

toString