QuaternionM4F (io7m-jtensors-documentation 6.0.0 API)

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

All Implemented Interfaces:

QuaternionReadable4FType, QuaternionWritable4FType, VectorReadable2FType, VectorReadable3FType, VectorReadable4FType, VectorWritable2FType, VectorWritable3FType, VectorWritable4FType
```
public class QuaternionM4F
extends Object
implements QuaternionReadable4FType, QuaternionWritable4FType
```
A four-dimensional mutable quaternion type with single 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`	`QuaternionM4F.Context` The Context type contains the minimum storage required for all of the functions of the `QuaternionM4D` class.

Constructor Summary

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

Method Summary

Methods
Modifier and Type	Method and Description
`static QuaternionM4F`	`add(QuaternionReadable4FType q0, QuaternionReadable4FType q1, QuaternionM4F out)` Calculate the element-wise sum of the quaternions `q0` and `q1`, saving the result to `qr`.
`static QuaternionM4F`	`addInPlace(QuaternionM4F q0, QuaternionReadable4FType q1)` Calculate the element-wise sum of the quaternions `q0` and `q1`, saving the result to `q0`.
`static boolean`	`almostEqual(com.io7m.jequality.AlmostEqualFloat.ContextRelative context, QuaternionReadable4FType qa, QuaternionReadable4FType qb)` Determine whether or not the quaternions `qa` and `qb` are equal to within the degree of error given in `context`.
`static QuaternionM4F`	`conjugate(QuaternionReadable4FType q, QuaternionM4F out)` Calculate the conjugate of the input quaternion `q`, saving the result to `out`.
`static QuaternionM4F`	`conjugateInPlace(QuaternionM4F q)` Calculate the conjugate of the input quaternion `q`, modifying `q` in place.
`static QuaternionM4F`	`copy(QuaternionReadable4FType q, QuaternionM4F out)` Copy the contents of the quaternion `q` to `out`.
`void`	`copyFrom2F(VectorReadable2FType in_v)` Set the current vector to the contents of the input vector.
`void`	`copyFrom3F(VectorReadable3FType in_v)` Set the current vector to the contents of the input vector.
`void`	`copyFrom4F(VectorReadable4FType in_v)` Set the current vector to the contents of the input vector.
`static double`	`dotProduct(QuaternionReadable4FType q0, QuaternionReadable4FType q1)` Calculate the scalar product of the quaternions `q0` and `q1`.
`boolean`	`equals(Object obj)`
`float`	`getWF()`
`float`	`getXF()`
`float`	`getYF()`
`float`	`getZF()`
`int`	`hashCode()`
`static QuaternionM4F`	`interpolateLinear(QuaternionReadable4FType q0, QuaternionReadable4FType q1, double alpha, QuaternionM4F 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.AlmostEqualFloat.ContextRelative context, QuaternionReadable4FType qa, QuaternionReadable4FType qb)` Return `true` iff `qa` is the negation of `qb`.
`static QuaternionM4F`	`lookAtWithContext(QuaternionM4F.Context context, VectorReadable3FType origin, VectorReadable3FType target, VectorReadable3FType up, QuaternionM4F 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(QuaternionReadable4FType q)` Calculate the magnitude of the quaternion `q`.
`static double`	`magnitudeSquared(QuaternionReadable4FType q)` Calculate the squared magnitude of the quaternion `q`.
`static QuaternionM4F`	`makeFromAxisAngle(VectorReadable3FType axis, double angle, QuaternionM4F out)` Produce a quaternion that represents a rotation of `angle` degrees around the axis specified by `axis`, saving the result to `out`.
`static QuaternionM4F`	`makeFromRotationMatrix3x3(MatrixReadable3x3FType m, QuaternionM4F out)` Produce a quaternion equivalent to the rotation matrix `m`, writing the result to `out`.
`static QuaternionM4F`	`makeFromRotationMatrix4x4(MatrixReadable4x4FType m, QuaternionM4F out)` Produce a quaternion equivalent to the rotation matrix `m`, writing the result to `out`.
`static MatrixM3x3F`	`makeRotationMatrix3x3(QuaternionM4F q, MatrixM3x3F m)` Produce a rotation matrix from the quaternion `q`, saving the result to `m`.
`static MatrixM4x4F`	`makeRotationMatrix4x4(QuaternionReadable4FType q, MatrixM4x4F m)` Produce a rotation matrix from the quaternion `q`, saving the result to `m`.
`static QuaternionM4F`	`multiply(QuaternionReadable4FType q0, QuaternionReadable4FType q1, QuaternionM4F qr)` Multiply the quaternion `q0` by the quaternion `q1` , saving the result to `qr`.
`static QuaternionM4F`	`multiplyInPlace(QuaternionM4F q0, QuaternionReadable4FType q1)` Multiply the quaternion `q0` by the quaternion `q1` , saving the result to `q0`.
`static QuaternionM4F`	`negate(QuaternionReadable4FType qa, QuaternionM4F out)` Negate the elements of `qa`, writing the resulting quaternion to `out`.
`static QuaternionM4F`	`negateInPlace(QuaternionM4F q)` Negate the elements of `q`, modifying the quaternion in-place.
`static QuaternionM4F`	`normalize(QuaternionReadable4FType q, QuaternionM4F out)` Returns a quaternion with the same orientation as `q` but with magnitude equal to `1.0` in `out`.
`static QuaternionM4F`	`normalizeInPlace(QuaternionM4F q)` Returns a quaternion with the same orientation as `q` but with magnitude equal to `1.0` in `q`.
`static QuaternionM4F`	`scale(QuaternionReadable4FType q, double r, QuaternionM4F out)` Scale the quaternion `q` by the scalar `r`, saving the result to `out`.
`static QuaternionM4F`	`scaleInPlace(QuaternionM4F q, double r)` Scale the quaternion `q` by the scalar `r`, saving the result to `q`.
`void`	`set2F(float in_x, float in_y)` Set the current `x` and `y` values of the current vector.
`void`	`set3F(float in_x, float in_y, float in_z)` Set the current `x`, `y` and `z` values of the current vector.
`void`	`set4F(float in_x, float in_y, float in_z, float in_w)` Set the current `x`, `y`, `z` and `w` values of the current vector.
`void`	`setWF(float in_w)` Set the current `w` value of the current vector.
`void`	`setXF(float in_x)` Set the current `x` value of the current vector.
`void`	`setYF(float in_y)` Set the current `y` value of the current vector.
`void`	`setZF(float in_z)` Set the current `z` value of the current vector.
`static QuaternionM4F`	`subtract(QuaternionReadable4FType q0, QuaternionReadable4FType q1, QuaternionM4F out)` Subtract the quaternion `q0` from the quaternion `q1`, saving the result to `out`.
`static QuaternionM4F`	`subtractInPlace(QuaternionM4F q0, QuaternionReadable4FType 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
  - QuaternionM4F
```
public QuaternionM4F()
```
    Default constructor, initializing the quaternion with values [0.0, 0.0, 0.0, 1.0]
  - QuaternionM4F
```
public QuaternionM4F(float in_x,
             float in_y,
             float in_z,
             float 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
  - QuaternionM4F
```
public QuaternionM4F(QuaternionReadable4FType q)
```
    Construct a quaternion initialized with the values given in q.
    
    Parameters:
    q - The source quaternion
- Method Detail
  - add
```
public static final QuaternionM4F add(QuaternionReadable4FType q0,
                QuaternionReadable4FType q1,
                QuaternionM4F 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 QuaternionM4F addInPlace(QuaternionM4F q0,
                       QuaternionReadable4FType 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.AlmostEqualFloat.ContextRelative context,
                  QuaternionReadable4FType qa,
                  QuaternionReadable4FType 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:
    AlmostEqualFloat.almostEqual(ContextRelative, float, float)
  - conjugate
```
public static final QuaternionM4F conjugate(QuaternionReadable4FType q,
                      QuaternionM4F 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 QuaternionM4F conjugateInPlace(QuaternionM4F q)
```
    Calculate the conjugate of the input quaternion q, modifying q in place.
    
    Parameters:
    q - The input quaternion
    
    Returns:
    q
  - copy
```
public static final QuaternionM4F copy(QuaternionReadable4FType q,
                 QuaternionM4F 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(QuaternionReadable4FType q0,
                QuaternionReadable4FType 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 QuaternionM4F interpolateLinear(QuaternionReadable4FType q0,
                              QuaternionReadable4FType q1,
                              double alpha,
                              QuaternionM4F 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.AlmostEqualFloat.ContextRelative context,
                   QuaternionReadable4FType qa,
                   QuaternionReadable4FType qb)
```
    Return true iff qa is the negation of qb.
    Each element is compared with AlmostEqualFloat.almostEqual(ContextRelative, float, float).
    
    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 QuaternionM4F lookAtWithContext(QuaternionM4F.Context context,
                              VectorReadable3FType origin,
                              VectorReadable3FType target,
                              VectorReadable3FType up,
                              QuaternionM4F 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(QuaternionReadable4FType 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(QuaternionReadable4FType 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 QuaternionM4F makeFromAxisAngle(VectorReadable3FType axis,
                              double angle,
                              QuaternionM4F 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 vector representing the axis
    angle - The angle to rotate, in radians
    out - The output quaternion
    
    Returns:
    A quaternion representing the rotation
    See Also:
    VectorI3F.normalize(VectorReadable3FType), VectorI4F.normalize(VectorReadable4FType), VectorM3F.normalize(VectorReadable3FType, VectorM3F), VectorM4F.normalize(VectorReadable4FType, VectorM4F)
  - makeFromRotationMatrix3x3
```
public static final QuaternionM4F makeFromRotationMatrix3x3(MatrixReadable3x3FType m,
                                      QuaternionM4F 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 QuaternionM4F makeFromRotationMatrix4x4(MatrixReadable4x4FType m,
                                      QuaternionM4F 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 MatrixM3x3F makeRotationMatrix3x3(QuaternionM4F q,
                                MatrixM3x3F 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 MatrixM4x4F makeRotationMatrix4x4(QuaternionReadable4FType q,
                                MatrixM4x4F 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 QuaternionM4F multiply(QuaternionReadable4FType q0,
                     QuaternionReadable4FType q1,
                     QuaternionM4F 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:
    QuaternionM4F qr = new QuaternionM4F(); QuaternionM4F.multiply(qy, qx, qr); QuaternionM4F.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 QuaternionM4F multiplyInPlace(QuaternionM4F q0,
                            QuaternionReadable4FType 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(QuaternionReadable4FType, QuaternionReadable4FType, QuaternionM4F)
  - negate
```
public static final QuaternionM4F negate(QuaternionReadable4FType qa,
                   QuaternionM4F 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 QuaternionM4F negateInPlace(QuaternionM4F 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 QuaternionM4F normalize(QuaternionReadable4FType q,
                      QuaternionM4F 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 QuaternionM4F normalizeInPlace(QuaternionM4F 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 QuaternionM4F scale(QuaternionReadable4FType q,
                  double r,
                  QuaternionM4F 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 QuaternionM4F scaleInPlace(QuaternionM4F 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 QuaternionM4F subtract(QuaternionReadable4FType q0,
                     QuaternionReadable4FType q1,
                     QuaternionM4F 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 QuaternionM4F subtractInPlace(QuaternionM4F q0,
                            QuaternionReadable4FType 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)
  - copyFrom2F
```
public final void copyFrom2F(VectorReadable2FType in_v)
```
    Description copied from interface: VectorWritable2FType
    
    Set the current vector to the contents of the input vector.
    
    Specified by:
    
    copyFrom2F in interface VectorWritable2FType
    
    Parameters:
    in_v - The input vector
  - copyFrom3F
```
public final void copyFrom3F(VectorReadable3FType in_v)
```
    Description copied from interface: VectorWritable3FType
    
    Set the current vector to the contents of the input vector.
    
    Specified by:
    
    copyFrom3F in interface VectorWritable3FType
    
    Parameters:
    in_v - The input vector
  - copyFrom4F
```
public final void copyFrom4F(VectorReadable4FType in_v)
```
    Description copied from interface: VectorWritable4FType
    
    Set the current vector to the contents of the input vector.
    
    Specified by:
    
    copyFrom4F in interface VectorWritable4FType
    
    Parameters:
    in_v - The input vector
  - equals
```
public final boolean equals(@Nullable
             Object obj)
```
    Overrides:
    
    equals in class Object
  - getWF
```
public final float getWF()
```
    Specified by:
    
    getWF in interface VectorReadable4FType
    
    Returns:
    The W value of the given vector.
  - getXF
```
public final float getXF()
```
    Specified by:
    
    getXF in interface VectorReadable2FType
    
    Returns:
    The X value of the given vector.
  - getYF
```
public final float getYF()
```
    Specified by:
    
    getYF in interface VectorReadable2FType
    
    Returns:
    The Y value of the given vector.
  - getZF
```
public final float getZF()
```
    Specified by:
    
    getZF in interface VectorReadable3FType
    
    Returns:
    The Z value of the given vector.
  - hashCode
```
public final int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - set2F
```
public final void set2F(float in_x,
         float in_y)
```
    Description copied from interface: VectorWritable2FType
    
    Set the current x and y values of the current vector.
    
    Specified by:
    
    set2F in interface VectorWritable2FType
    
    Parameters:
    in_x - The new x value.
    in_y - The new y value.
  - set3F
```
public final void set3F(float in_x,
         float in_y,
         float in_z)
```
    Description copied from interface: VectorWritable3FType
    
    Set the current x, y and z values of the current vector.
    
    Specified by:
    
    set3F in interface VectorWritable3FType
    
    Parameters:
    in_x - The new x value.
    in_y - The new y value.
    in_z - The new z value.
  - set4F
```
public final void set4F(float in_x,
         float in_y,
         float in_z,
         float in_w)
```
    Description copied from interface: VectorWritable4FType
    
    Set the current x, y, z and w values of the current vector.
    
    Specified by:
    
    set4F in interface VectorWritable4FType
    
    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.
  - setWF
```
public final void setWF(float in_w)
```
    Description copied from interface: VectorWritable4FType
    
    Set the current w value of the current vector.
    
    Specified by:
    
    setWF in interface VectorWritable4FType
    
    Parameters:
    in_w - The new w value.
  - setXF
```
public final void setXF(float in_x)
```
    Description copied from interface: VectorWritable2FType
    
    Set the current x value of the current vector.
    
    Specified by:
    
    setXF in interface VectorWritable2FType
    
    Parameters:
    in_x - The new x value.
  - setYF
```
public final void setYF(float in_y)
```
    Description copied from interface: VectorWritable2FType
    
    Set the current y value of the current vector.
    
    Specified by:
    
    setYF in interface VectorWritable2FType
    
    Parameters:
    in_y - The new y value.
  - setZF
```
public final void setZF(float in_z)
```
    Description copied from interface: VectorWritable3FType
    
    Set the current z value of the current vector.
    
    Specified by:
    
    setZF in interface VectorWritable3FType
    
    Parameters:
    in_z - The new z value.
  - toString
```
public final String toString()
```
    Overrides:
    
    toString in class Object

Class QuaternionM4F

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

QuaternionM4F

QuaternionM4F

QuaternionM4F

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

copyFrom2F

copyFrom3F

copyFrom4F

equals

getWF

getXF

getYF

getZF

hashCode

set2F

set3F

set4F

setWF

setXF

setYF

setZF

toString