EuclidCoreTestTools (euclid-core 0.5.1 API)

java.lang.Object
- us.ihmc.euclid.tools.EuclidCoreTestTools

```
public abstract class EuclidCoreTestTools
extends java.lang.Object
```
This class provides the tools to perform a variety of assertions on Euclid Core's types.

Constructor Summary

Constructors
Constructor and Description

EuclidCoreTestTools()

Constructors
Constructor and Description
`EuclidCoreTestTools()`

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static void`	`assertAffineTransformEquals(AffineTransform expected, AffineTransform actual, double epsilon)` Asserts on a per component basis that the two given affine transforms are equal to an `epsilon`.
`static void`	`assertAffineTransformEquals(java.lang.String messagePrefix, AffineTransform expected, AffineTransform actual, double epsilon)` Asserts on a per component basis that the two given affine transforms are equal to an `epsilon`.
`static void`	`assertAffineTransformEquals(java.lang.String messagePrefix, AffineTransform expected, AffineTransform actual, double epsilon, java.lang.String format)` Asserts on a per component basis that the two given affine transforms are equal to an `epsilon`.
`static void`	`assertAffineTransformGeometricallyEquals(AffineTransform expected, AffineTransform actual, double epsilon)` Asserts that the two given affine transforms represent the same geometry to an `epsilon`.
`static void`	`assertAffineTransformGeometricallyEquals(java.lang.String messagePrefix, AffineTransform expected, AffineTransform actual, double epsilon)` Asserts that the two given affine transforms represent the same geometry to an `epsilon`.
`static void`	`assertAffineTransformGeometricallyEquals(java.lang.String messagePrefix, AffineTransform expected, AffineTransform actual, double epsilon, java.lang.String format)` Asserts that the two given affine transforms represent the same geometry to an `epsilon`.
`static void`	`assertAngleEquals(double expected, double actual, double epsilon)` Asserts that the two given angles are equal to an `epsilon`.
`static void`	`assertAngleEquals(java.lang.String messagePrefix, double expected, double actual, double epsilon)` Asserts that the two given angles are equal to an `epsilon`.
`static void`	`assertAxisAngleContainsOnlyNaN(AxisAngleReadOnly axisAngleToAssert)` Asserts that the given axis-angle contains only `Double.NaN`.
`static void`	`assertAxisAngleContainsOnlyNaN(java.lang.String messagePrefix, AxisAngleReadOnly axisAngleToAssert)` Asserts that the given axis-angle contains only `Double.NaN`.
`static void`	`assertAxisAngleEquals(AxisAngleReadOnly expected, AxisAngleReadOnly actual, double epsilon)` Asserts on a per component basis if the two axis-angles are equal to an `epsilon`.
`static void`	`assertAxisAngleEquals(java.lang.String messagePrefix, AxisAngleReadOnly expected, AxisAngleReadOnly actual, double epsilon)` Asserts on a per component basis if the two axis-angles are equal to an `epsilon`.
`static void`	`assertAxisAngleEquals(java.lang.String messagePrefix, AxisAngleReadOnly expected, AxisAngleReadOnly actual, double epsilon, java.lang.String format)` Asserts on a per component basis if the two axis-angles are equal to an `epsilon`.
`static void`	`assertAxisAngleEqualsSmart(AxisAngleReadOnly expected, AxisAngleReadOnly actual, double epsilon)` Deprecated. Use `assertAxisAngleGeometricallyEquals(AxisAngleReadOnly, AxisAngleReadOnly, double)` instead. This method will be removed in a future version.
`static void`	`assertAxisAngleEqualsSmart(java.lang.String messagePrefix, AxisAngleReadOnly expected, AxisAngleReadOnly actual, double epsilon)` Deprecated. Use `assertAxisAngleGeometricallyEquals(String, AxisAngleReadOnly, AxisAngleReadOnly, double)` instead. This method will be removed in a future version.
`static void`	`assertAxisAngleEqualsSmart(java.lang.String messagePrefix, AxisAngleReadOnly expected, AxisAngleReadOnly actual, double epsilon, java.lang.String format)` Deprecated. Use `assertAxisAngleGeometricallyEquals(String, AxisAngleReadOnly, AxisAngleReadOnly, double, String)` instead. This method will be removed in a future version.
`static void`	`assertAxisAngleGeometricallyEquals(AxisAngleReadOnly expected, AxisAngleReadOnly actual, double epsilon)` Asserts on a per component basis if the two axis-angles represent the same geometry to an `epsilon`.
`static void`	`assertAxisAngleGeometricallyEquals(java.lang.String messagePrefix, AxisAngleReadOnly expected, AxisAngleReadOnly actual, double epsilon)` Asserts on a per component basis if the two axis-angles represent the same geometry to an `epsilon`.
`static void`	`assertAxisAngleGeometricallyEquals(java.lang.String messagePrefix, AxisAngleReadOnly expected, AxisAngleReadOnly actual, double epsilon, java.lang.String format)` Asserts on a per component basis if the two axis-angles represent the same geometry to an `epsilon`.
`static void`	`assertAxisAngleIsSetToZero(AxisAngleReadOnly axisAngleToAssert)` Assert that `AxisAngleBasics.setToZero()` has just been called on the given axis-angle.
`static void`	`assertAxisAngleIsSetToZero(java.lang.String messagePrefix, AxisAngleReadOnly axisAngleToAssert)` Assert that `AxisAngleBasics.setToZero()` has just been called on the given axis-angle.
`static void`	`assertAxisUnitary(AxisAngleReadOnly axisAngleToAssert, double epsilon)` Asserts that the length of the axis of the axis-angle is equal to `1.0 +/- epsilon`.
`static void`	`assertAxisUnitary(java.lang.String messagePrefix, AxisAngleReadOnly axisAngleToAssert, double epsilon)` Asserts that the length of the axis of the axis-angle is equal to `1.0 +/- epsilon`.
`static void`	`assertAxisUnitary(java.lang.String messagePrefix, AxisAngleReadOnly axisAngleToAssert, double epsilon, java.lang.String format)` Asserts that the length of the axis of the axis-angle is equal to `1.0 +/- epsilon`.
`static void`	`assertIdentity(Matrix3DReadOnly matrixToAssert, double epsilon)` Asserts on a per coefficient basis that this matrix is equal to identity to an `epsilon`.
`static void`	`assertIdentity(java.lang.String messagePrefix, Matrix3DReadOnly matrixToAssert, double epsilon)` Asserts on a per coefficient basis that this matrix is equal to identity to an `epsilon`.
`static void`	`assertIdentity(java.lang.String messagePrefix, Matrix3DReadOnly matrixToAssert, double epsilon, java.lang.String format)` Asserts on a per coefficient basis that this matrix is equal to identity to an `epsilon`.
`static void`	`assertMatrix3DContainsOnlyNaN(Matrix3DReadOnly matrixToAssert)` Asserts that the given matrix contains on `Double.NaN`.
`static void`	`assertMatrix3DContainsOnlyNaN(java.lang.String messagePrefix, Matrix3DReadOnly matrixToAssert)` Asserts that the given matrix contains on `Double.NaN`.
`static void`	`assertMatrix3DEquals(Matrix3DReadOnly expected, Matrix3DReadOnly actual, double epsilon)` Asserts on a per component basis that the two matrices are equal to an `epsilon`.
`static void`	`assertMatrix3DEquals(java.lang.String messagePrefix, Matrix3DReadOnly expected, Matrix3DReadOnly actual, double epsilon)` Asserts on a per component basis that the two matrices are equal to an `epsilon`.
`static void`	`assertMatrix3DEquals(java.lang.String messagePrefix, Matrix3DReadOnly expected, Matrix3DReadOnly actual, double epsilon, java.lang.String format)` Asserts on a per component basis that the two matrices are equal to an `epsilon`.
`static void`	`assertPoint2DGeometricallyEquals(Point2DReadOnly expected, Point2DReadOnly actual, double epsilon)` Asserts on a per component basis that the two points represent the same geometry to an `epsilon`.
`static void`	`assertPoint2DGeometricallyEquals(java.lang.String messagePrefix, Point2DReadOnly expected, Point2DReadOnly actual, double epsilon)` Asserts on a per component basis that the two points represent the same geometry to an `epsilon`.
`static void`	`assertPoint2DGeometricallyEquals(java.lang.String messagePrefix, Point2DReadOnly expected, Point2DReadOnly actual, double epsilon, java.lang.String format)` Asserts on a per component basis that the two points represent the same geometry to an `epsilon`.
`static void`	`assertPoint3DGeometricallyEquals(Point3DReadOnly expected, Point3DReadOnly actual, double epsilon)` Asserts on a per component basis that the two points represent the same geometry to an `epsilon`.
`static void`	`assertPoint3DGeometricallyEquals(java.lang.String messagePrefix, Point3DReadOnly expected, Point3DReadOnly actual, double epsilon)` Asserts on a per component basis that the two points represent the same geometry to an `epsilon`.
`static void`	`assertPoint3DGeometricallyEquals(java.lang.String messagePrefix, Point3DReadOnly expected, Point3DReadOnly actual, double epsilon, java.lang.String format)` Asserts on a per component basis that the two points represent the same geometry to an `epsilon`.
`static void`	`assertQuaternionBasedTransformEquals(QuaternionBasedTransform expected, QuaternionBasedTransform actual, double epsilon)` Asserts on a per component basis that the two quaternion-based transforms are equal to an `epsilon`.
`static void`	`assertQuaternionBasedTransformEquals(java.lang.String messagePrefix, QuaternionBasedTransform expected, QuaternionBasedTransform actual, double epsilon)` Asserts on a per component basis that the two quaternion-based transforms are equal to an `epsilon`.
`static void`	`assertQuaternionBasedTransformEquals(java.lang.String messagePrefix, QuaternionBasedTransform expected, QuaternionBasedTransform actual, double epsilon, java.lang.String format)` Asserts on a per component basis that the two quaternion-based transforms are equal to an `epsilon`.
`static void`	`assertQuaternionBasedTransformEqualsSmart(QuaternionBasedTransform expected, QuaternionBasedTransform actual, double epsilon)` Deprecated. Use `assertQuaternionBasedTransformGeometricallyEquals(QuaternionBasedTransform, QuaternionBasedTransform, double)` instead. This method will be removed in a future version.
`static void`	`assertQuaternionBasedTransformEqualsSmart(java.lang.String messagePrefix, QuaternionBasedTransform expected, QuaternionBasedTransform actual, double epsilon)` Deprecated. Use `assertQuaternionBasedTransformGeometricallyEquals(String, QuaternionBasedTransform, QuaternionBasedTransform, double)` instead. This method will be removed in a future version.
`static void`	`assertQuaternionBasedTransformEqualsSmart(java.lang.String messagePrefix, QuaternionBasedTransform expected, QuaternionBasedTransform actual, double epsilon, java.lang.String format)` Deprecated. Use `assertQuaternionBasedTransformGeometricallyEquals(String, QuaternionBasedTransform, QuaternionBasedTransform, double, String)` instead. This method will be removed in a future version.
`static void`	`assertQuaternionBasedTransformGeometricallyEquals(QuaternionBasedTransform expected, QuaternionBasedTransform actual, double epsilon)` Asserts on a per component basis that the two quaternion-based transforms represent the same geometry to an `epsilon`.
`static void`	`assertQuaternionBasedTransformGeometricallyEquals(java.lang.String messagePrefix, QuaternionBasedTransform expected, QuaternionBasedTransform actual, double epsilon)` Asserts on a per component basis that the two quaternion-based transforms represent the same geometry to an `epsilon`.
`static void`	`assertQuaternionBasedTransformGeometricallyEquals(java.lang.String messagePrefix, QuaternionBasedTransform expected, QuaternionBasedTransform actual, double epsilon, java.lang.String format)` Asserts on a per component basis that the two quaternion-based transforms represent the same geometry to an `epsilon`.
`static void`	`assertQuaternionEquals(QuaternionReadOnly expected, QuaternionReadOnly actual, double epsilon)` Asserts on a per component basis that the two quaternions are equal to an `epsilon`.
`static void`	`assertQuaternionEquals(java.lang.String messagePrefix, QuaternionReadOnly expected, QuaternionReadOnly actual, double epsilon)` Asserts on a per component basis that the two quaternions are equal to an `epsilon`.
`static void`	`assertQuaternionEquals(java.lang.String messagePrefix, QuaternionReadOnly expected, QuaternionReadOnly actual, double epsilon, java.lang.String format)` Asserts on a per component basis that the two quaternions are equal to an `epsilon`.
`static void`	`assertQuaternionEqualsSmart(QuaternionReadOnly expected, QuaternionReadOnly actual, double epsilon)` Deprecated. Use `assertQuaternionGeometricallyEquals(QuaternionReadOnly, QuaternionReadOnly, double)` instead. This method will be removed in a future version.
`static void`	`assertQuaternionEqualsSmart(java.lang.String messagePrefix, QuaternionReadOnly expected, QuaternionReadOnly actual, double epsilon)` Deprecated. Use `assertQuaternionGeometricallyEquals(String, QuaternionReadOnly, QuaternionReadOnly, double)` instead. This method will be removed in a future version.
`static void`	`assertQuaternionEqualsSmart(java.lang.String messagePrefix, QuaternionReadOnly expected, QuaternionReadOnly actual, double epsilon, java.lang.String format)` Deprecated. Use `assertQuaternionGeometricallyEquals(String, QuaternionReadOnly, QuaternionReadOnly, double, String)` instead. This method will be removed in a future version.
`static void`	`assertQuaternionEqualsUsingDifference(QuaternionReadOnly expected, QuaternionReadOnly actual, double epsilon)` Deprecated. Use `assertQuaternionGeometricallyEquals(QuaternionReadOnly, QuaternionReadOnly, double)` instead. This method will be removed in a future version.
`static void`	`assertQuaternionEqualsUsingDifference(java.lang.String messagePrefix, QuaternionReadOnly expected, QuaternionReadOnly actual, double epsilon)` Deprecated. Use `assertQuaternionGeometricallyEquals(String, QuaternionReadOnly, QuaternionReadOnly, double)` instead. This method will be removed in a future version.
`static void`	`assertQuaternionEqualsUsingDifference(java.lang.String messagePrefix, QuaternionReadOnly expected, QuaternionReadOnly actual, double epsilon, java.lang.String format)` Deprecated. Use `assertQuaternionGeometricallyEquals(String, QuaternionReadOnly, QuaternionReadOnly, double, String)` instead. This method will be removed in a future version.
`static void`	`assertQuaternionGeometricallyEquals(QuaternionReadOnly expected, QuaternionReadOnly actual, double epsilon)` Asserts on a per component basis that the two quaternions represent the same geometry to an `epsilon`.
`static void`	`assertQuaternionGeometricallyEquals(java.lang.String messagePrefix, QuaternionReadOnly expected, QuaternionReadOnly actual, double epsilon)` Asserts on a per component basis that the two quaternions represent the same geometry to an `epsilon`.
`static void`	`assertQuaternionGeometricallyEquals(java.lang.String messagePrefix, QuaternionReadOnly expected, QuaternionReadOnly actual, double epsilon, java.lang.String format)` Asserts on a per component basis that the two quaternions represent the same geometry to an `epsilon`.
`static void`	`assertQuaternionIsSetToZero(QuaternionReadOnly quaternionToAssert)` Assert that `QuaternionBasics.setToZero()` has just been called on the given quaternion.
`static void`	`assertQuaternionIsSetToZero(java.lang.String messagePrefix, QuaternionReadOnly quaternionToAssert)` Assert that `QuaternionBasics.setToZero()` has just been called on the given quaternion.
`static void`	`assertQuaternionIsSetToZero(java.lang.String messagePrefix, QuaternionReadOnly quaternionToAssert, java.lang.String format)` Assert that `QuaternionBasics.setToZero()` has just been called on the given quaternion.
`static void`	`assertQuaternionIsUnitary(QuaternionReadOnly quaternionToAssert, double epsilon)` Asserts that the norm of the given quaternion is equal to `1.0 +/- epsilon`.
`static void`	`assertQuaternionIsUnitary(java.lang.String messagePrefix, QuaternionReadOnly quaternionToAssert, double epsilon)` Asserts that the norm of the given quaternion is equal to `1.0 +/- epsilon`.
`static void`	`assertQuaternionIsUnitary(java.lang.String messagePrefix, QuaternionReadOnly quaternionToAssert, double epsilon, java.lang.String format)` Asserts that the norm of the given quaternion is equal to `1.0 +/- epsilon`.
`static void`	`assertRigidBodyTransformEquals(RigidBodyTransform expected, RigidBodyTransform actual, double epsilon)` Asserts on a per component basis that the two given rigid-body transform are equal to an `epsilon`.
`static void`	`assertRigidBodyTransformEquals(java.lang.String messagePrefix, RigidBodyTransform expected, RigidBodyTransform actual, double epsilon)` Asserts on a per component basis that the two given rigid-body transform are equal to an `epsilon`.
`static void`	`assertRigidBodyTransformEquals(java.lang.String messagePrefix, RigidBodyTransform expected, RigidBodyTransform actual, double epsilon, java.lang.String format)` Asserts on a per component basis that the two given rigid-body transform are equal to an `epsilon`.
`static void`	`assertRigidBodyTransformGeometricallyEquals(RigidBodyTransform expected, RigidBodyTransform actual, double epsilon)` Asserts on a per component basis that the two given rigid-body transform represent the same geometry to an `epsilon`.
`static void`	`assertRigidBodyTransformGeometricallyEquals(java.lang.String messagePrefix, RigidBodyTransform expected, RigidBodyTransform actual, double epsilon)` Asserts on a per component basis that the two given rigid-body transform represent the same geometry to an `epsilon`.
`static void`	`assertRigidBodyTransformGeometricallyEquals(java.lang.String messagePrefix, RigidBodyTransform expected, RigidBodyTransform actual, double epsilon, java.lang.String format)` Asserts on a per component basis that the two given rigid-body transform represent the same geometry to an `epsilon`.
`static void`	`assertRotationMatrix(Matrix3DReadOnly matrixToAssert, double epsilon)` Asserts that this matrix is a rotation matrix.
`static void`	`assertRotationMatrix(java.lang.String messagePrefix, Matrix3DReadOnly matrixToAssert, double epsilon)` Asserts that this matrix is a rotation matrix.
`static void`	`assertRotationMatrix(java.lang.String messagePrefix, Matrix3DReadOnly matrixToAssert, double epsilon, java.lang.String format)` Asserts that this matrix is a rotation matrix.
`static void`	`assertRotationMatrixGeometricallyEquals(RotationMatrixReadOnly expected, RotationMatrixReadOnly actual, double epsilon)` Asserts on a per component basis that the two rotation matrices represent the same geometry to an `epsilon`.
`static void`	`assertRotationMatrixGeometricallyEquals(java.lang.String messagePrefix, RotationMatrixReadOnly expected, RotationMatrixReadOnly actual, double epsilon)` Asserts on a per component basis that the two rotation matrices represent the same geometry to an `epsilon`.
`static void`	`assertRotationMatrixGeometricallyEquals(java.lang.String messagePrefix, RotationMatrixReadOnly expected, RotationMatrixReadOnly actual, double epsilon, java.lang.String format)` Asserts on a per component basis that the two rotation matrices represent the same geometry to an `epsilon`.
`static void`	`assertRotationVectorEquals(java.lang.String messagePrefix, Vector3DReadOnly expected, Vector3DReadOnly actual, double epsilon)` Deprecated. Use `assertRotationVectorGeometricallyEquals(String, Vector3DReadOnly, Vector3DReadOnly, double)` instead. This method will be removed in a future version.
`static void`	`assertRotationVectorEquals(java.lang.String messagePrefix, Vector3DReadOnly expected, Vector3DReadOnly actual, double epsilon, java.lang.String format)` Deprecated. Use `assertRotationVectorGeometricallyEquals(String, Vector3DReadOnly, Vector3DReadOnly, double, String)` instead. This method will be removed in a future version.
`static void`	`assertRotationVectorEquals(Vector3DReadOnly expected, Vector3DReadOnly actual, double epsilon)` Deprecated. Use `assertRotationVectorGeometricallyEquals(Vector3DReadOnly, Vector3DReadOnly, double)` instead. This method will be removed in a future version.
`static void`	`assertRotationVectorGeometricallyEquals(java.lang.String messagePrefix, Vector3DReadOnly expected, Vector3DReadOnly actual, double epsilon)` Asserts on a per component basis that the two rotation vectors represent the same geometry to an `epsilon`.
`static void`	`assertRotationVectorGeometricallyEquals(java.lang.String messagePrefix, Vector3DReadOnly expected, Vector3DReadOnly actual, double epsilon, java.lang.String format)` Asserts on a per component basis that the two rotation vectors represent the same geometry to an `epsilon`.
`static void`	`assertRotationVectorGeometricallyEquals(Vector3DReadOnly expected, Vector3DReadOnly actual, double epsilon)` Asserts on a per component basis that the two rotation vectors represent the same geometry to an `epsilon`.
`static void`	`assertSkewSymmetric(Matrix3DReadOnly matrixToAssert, double epsilon)` Asserts that the given matrix is skew-symmetric:
`static void`	`assertSkewSymmetric(java.lang.String messagePrefix, Matrix3DReadOnly matrixToAssert, double epsilon)` Asserts that the given matrix is skew-symmetric:
`static void`	`assertSkewSymmetric(java.lang.String messagePrefix, Matrix3DReadOnly matrixToAssert, double epsilon, java.lang.String format)` Asserts that the given matrix is skew-symmetric:
`static void`	`assertTuple2DContainsOnlyNaN(java.lang.String messagePrefix, Tuple2DReadOnly tupleToAssert)` Asserts that the given tuple contains only `Double.NaN`.
`static void`	`assertTuple2DContainsOnlyNaN(Tuple2DReadOnly tupleToAssert)` Asserts that the given tuple contains only `Double.NaN`.
`static void`	`assertTuple2DEquals(java.lang.String messagePrefix, Tuple2DReadOnly expected, Tuple2DReadOnly actual, double epsilon)` Asserts on a per component basis that the two tuples are equal to an `epsilon`.
`static void`	`assertTuple2DEquals(java.lang.String messagePrefix, Tuple2DReadOnly expected, Tuple2DReadOnly actual, double epsilon, java.lang.String format)` Asserts on a per component basis that the two tuples are equal to an `epsilon`.
`static void`	`assertTuple2DEquals(Tuple2DReadOnly expected, Tuple2DReadOnly actual, double epsilon)` Asserts on a per component basis that the two tuples are equal to an `epsilon`.
`static void`	`assertTuple2DIsSetToZero(java.lang.String messagePrefix, Tuple2DReadOnly tupleToAssert)` Assert that `Tuple2DBasics.setToZero()` has just been called on the given tuple.
`static void`	`assertTuple2DIsSetToZero(java.lang.String messagePrefix, Tuple2DReadOnly tupleToAssert, java.lang.String format)` Assert that `Tuple2DBasics.setToZero()` has just been called on the given tuple.
`static void`	`assertTuple2DIsSetToZero(Tuple2DReadOnly tupleToAssert)` Assert that `Tuple2DBasics.setToZero()` has just been called on the given tuple.
`static void`	`assertTuple3DContainsOnlyNaN(java.lang.String messagePrefix, Tuple3DReadOnly tupleToAssert)` Asserts that the given tuple contains only `Double.NaN`.
`static void`	`assertTuple3DContainsOnlyNaN(Tuple3DReadOnly tupleToAssert)` Asserts that the given tuple contains only `Double.NaN`.
`static void`	`assertTuple3DEquals(java.lang.String messagePrefix, Tuple3DReadOnly expected, Tuple3DReadOnly actual, double epsilon)` Asserts on a per component basis that the two tuples are equal to an `epsilon`.
`static void`	`assertTuple3DEquals(java.lang.String messagePrefix, Tuple3DReadOnly expected, Tuple3DReadOnly actual, double epsilon, java.lang.String format)` Asserts on a per component basis that the two tuples are equal to an `epsilon`.
`static void`	`assertTuple3DEquals(Tuple3DReadOnly expected, Tuple3DReadOnly actual, double epsilon)` Asserts on a per component basis that the two tuples are equal to an `epsilon`.
`static void`	`assertTuple3DIsSetToZero(java.lang.String messagePrefix, Tuple3DReadOnly tupleToAssert)` Assert that `Tuple3DBasics.setToZero()` has just been called on the given tuple.
`static void`	`assertTuple3DIsSetToZero(java.lang.String messagePrefix, Tuple3DReadOnly tupleToAssert, java.lang.String format)` Assert that `Tuple3DBasics.setToZero()` has just been called on the given tuple.
`static void`	`assertTuple3DIsSetToZero(Tuple3DReadOnly tupleToAssert)` Assert that `Tuple3DBasics.setToZero()` has just been called on the given tuple.
`static void`	`assertTuple4DContainsOnlyNaN(java.lang.String messagePrefix, Tuple4DReadOnly tupleToAssert)` Asserts that the given quaternion contains only `Double.NaN`.
`static void`	`assertTuple4DContainsOnlyNaN(Tuple4DReadOnly tupleToAssert)` Asserts that the given tuple contains only `Double.NaN`.
`static void`	`assertTuple4DEquals(java.lang.String messagePrefix, Tuple4DReadOnly expected, Tuple4DReadOnly actual, double epsilon)` Asserts on a per component basis that the two tuples are equal to an `epsilon`.
`static void`	`assertTuple4DEquals(java.lang.String messagePrefix, Tuple4DReadOnly expected, Tuple4DReadOnly actual, double epsilon, java.lang.String format)` Asserts on a per component basis that the two tuples are equal to an `epsilon`.
`static void`	`assertTuple4DEquals(Tuple4DReadOnly expected, Tuple4DReadOnly actual, double epsilon)` Asserts on a per component basis that the two tuples are equal to an `epsilon`.
`static void`	`assertVector2DGeometricallyEquals(java.lang.String messagePrefix, Vector2DReadOnly expected, Vector2DReadOnly actual, double epsilon)` Asserts on a per component basis that the two vectors represent the same geometry to an `epsilon`.
`static void`	`assertVector2DGeometricallyEquals(java.lang.String messagePrefix, Vector2DReadOnly expected, Vector2DReadOnly actual, double epsilon, java.lang.String format)` Asserts on a per component basis that the two vectors represent the same geometry to an `epsilon`.
`static void`	`assertVector2DGeometricallyEquals(Vector2DReadOnly expected, Vector2DReadOnly actual, double epsilon)` Asserts on a per component basis that the two vectors represent the same geometry to an `epsilon`.
`static void`	`assertVector3DGeometricallyEquals(java.lang.String messagePrefix, Vector3DReadOnly expected, Vector3DReadOnly actual, double epsilon)` Asserts on a per component basis that the two vectors represent the same geometry to an `epsilon`.
`static void`	`assertVector3DGeometricallyEquals(java.lang.String messagePrefix, Vector3DReadOnly expected, Vector3DReadOnly actual, double epsilon, java.lang.String format)` Asserts on a per component basis that the two vectors represent the same geometry to an `epsilon`.
`static void`	`assertVector3DGeometricallyEquals(Vector3DReadOnly expected, Vector3DReadOnly actual, double epsilon)` Asserts on a per component basis that the two vectors represent the same geometry to an `epsilon`.
`static void`	`assertVector4DGeometricallyEquals(java.lang.String messagePrefix, Vector4DReadOnly expected, Vector4DReadOnly actual, double epsilon)` Asserts on a per component basis that the two vectors represent the same geometry to an `epsilon`.
`static void`	`assertVector4DGeometricallyEquals(java.lang.String messagePrefix, Vector4DReadOnly expected, Vector4DReadOnly actual, double epsilon, java.lang.String format)` Asserts on a per component basis that the two vectors represent the same geometry to an `epsilon`.
`static void`	`assertVector4DGeometricallyEquals(Vector4DReadOnly expected, Vector4DReadOnly actual, double epsilon)` Asserts on a per component basis that the two vectors represent the same geometry to an `epsilon`.
`static void`	`assertYawPitchRollEquals(double[] expected, double[] actual, double epsilon)` Asserts on a per component basis that the two sets of yaw-pitch-roll angles are equal to an `epsilon`.
`static void`	`assertYawPitchRollEquals(java.lang.String messagePrefix, double[] expected, double[] actual, double epsilon)` Asserts on a per component basis that the two sets of yaw-pitch-roll angles are equal to an `epsilon`.
`static void`	`assertYawPitchRollEquals(java.lang.String messagePrefix, double[] expected, double[] actual, double epsilon, java.lang.String format)` Asserts on a per component basis that the two sets of yaw-pitch-roll angles are equal to an `epsilon`.
`static void`	`assertYawPitchRollGeometricallyEquals(double[] expected, double[] actual, double epsilon)` Asserts on a per component basis that the two sets of yaw-pitch-roll angles represent the same geometry to an `epsilon`.
`static void`	`assertYawPitchRollGeometricallyEquals(java.lang.String messagePrefix, double[] expected, double[] actual, double epsilon)` Asserts on a per component basis that the two sets of yaw-pitch-roll angles represent the same geometry to an `epsilon`.
`static void`	`assertYawPitchRollGeometricallyEquals(java.lang.String messagePrefix, double[] expected, double[] actual, double epsilon, java.lang.String format)` Asserts on a per component basis that the two sets of yaw-pitch-roll angles represent the same geometry to an `epsilon`.

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

- Constructor Detail
  - EuclidCoreTestTools
```
public EuclidCoreTestTools()
```
- Method Detail
  - assertAngleEquals
```
public static void assertAngleEquals(double expected,
                                     double actual,
                                     double epsilon)
```
    Asserts that the two given angles are equal to an epsilon.
    The method returns true for angles such as: actualAngle = expectedAngle +/- 2.0 * Math.PI.
    
    Parameters:
    
    expected - the expected angle.
    
    actual - the actual angle.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two angles are not equal.
  - assertAngleEquals
```
public static void assertAngleEquals(java.lang.String messagePrefix,
                                     double expected,
                                     double actual,
                                     double epsilon)
```
    Asserts that the two given angles are equal to an epsilon.
    The method returns true for angles such as: actualAngle = expectedAngle +/- 2.0 * Math.PI.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected angle.
    
    actual - the actual angle.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two angles are not equal.
  - assertYawPitchRollEquals
```
public static void assertYawPitchRollEquals(double[] expected,
                                            double[] actual,
                                            double epsilon)
```
    Asserts on a per component basis that the two sets of yaw-pitch-roll angles are equal to an epsilon.
    The method returns true for angles such as: actualAngle = expectedAngle +/- 2.0 * Math.PI.
    
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    expected - the expected set of yaw-pitch-roll angles. Not modified.
    
    actual - the actual set of yaw-pitch-roll angles. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two sets of yaw-pitch-roll angles are not equal. If only one of the arguments is equal to null. If at least one of the arguments has a length different than 3.
  - assertYawPitchRollEquals
```
public static void assertYawPitchRollEquals(java.lang.String messagePrefix,
                                            double[] expected,
                                            double[] actual,
                                            double epsilon)
```
    Asserts on a per component basis that the two sets of yaw-pitch-roll angles are equal to an epsilon.
    The method returns true for angles such as: actualAngle = expectedAngle +/- 2.0 * Math.PI.
    
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected set of yaw-pitch-roll angles. Not modified.
    
    actual - the actual set of yaw-pitch-roll angles. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two sets of yaw-pitch-roll angles are not equal. If only one of the arguments is equal to null. If at least one of the arguments has a length different than 3.
  - assertYawPitchRollEquals
```
public static void assertYawPitchRollEquals(java.lang.String messagePrefix,
                                            double[] expected,
                                            double[] actual,
                                            double epsilon,
                                            java.lang.String format)
```
    Asserts on a per component basis that the two sets of yaw-pitch-roll angles are equal to an epsilon.
    The method returns true for angles such as: actualAngle = expectedAngle +/- 2.0 * Math.PI.
    
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected set of yaw-pitch-roll angles. Not modified.
    
    actual - the actual set of yaw-pitch-roll angles. Not modified.
    
    epsilon - the tolerance to use.
    
    format - the format to use for printing each component when an AssertionError is thrown.
    
    Throws:
    
    java.lang.AssertionError - if the two sets of yaw-pitch-roll angles are not equal. If only one of the arguments is equal to null. If at least one of the arguments has a length different than 3.
  - assertYawPitchRollGeometricallyEquals
```
public static void assertYawPitchRollGeometricallyEquals(double[] expected,
                                                         double[] actual,
                                                         double epsilon)
```
    Asserts on a per component basis that the two sets of yaw-pitch-roll angles represent the same geometry to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    expected - the expected set of yaw-pitch-roll angles. Not modified.
    
    actual - the actual set of yaw-pitch-roll angles. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two sets of yaw-pitch-roll angles do not represent the same geometry. If only one of the arguments is equal to null. If at least one of the arguments has a length different than 3.
  - assertYawPitchRollGeometricallyEquals
```
public static void assertYawPitchRollGeometricallyEquals(java.lang.String messagePrefix,
                                                         double[] expected,
                                                         double[] actual,
                                                         double epsilon)
```
    Asserts on a per component basis that the two sets of yaw-pitch-roll angles represent the same geometry to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected set of yaw-pitch-roll angles. Not modified.
    
    actual - the actual set of yaw-pitch-roll angles. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two sets of yaw-pitch-roll angles do not represent the same geometry. If only one of the arguments is equal to null. If at least one of the arguments has a length different than 3.
  - assertYawPitchRollGeometricallyEquals
```
public static void assertYawPitchRollGeometricallyEquals(java.lang.String messagePrefix,
                                                         double[] expected,
                                                         double[] actual,
                                                         double epsilon,
                                                         java.lang.String format)
```
    Asserts on a per component basis that the two sets of yaw-pitch-roll angles represent the same geometry to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected set of yaw-pitch-roll angles. Not modified.
    
    actual - the actual set of yaw-pitch-roll angles. Not modified.
    
    epsilon - the tolerance to use.
    
    format - the format to use for printing each component when an AssertionError is thrown.
    
    Throws:
    
    java.lang.AssertionError - if the two sets of yaw-pitch-roll angles do not represent the same geometry. If only one of the arguments is equal to null. If at least one of the arguments has a length different than 3.
  - assertRotationVectorEquals
```
@Deprecated
public static void assertRotationVectorEquals(Vector3DReadOnly expected,
                                                           Vector3DReadOnly actual,
                                                           double epsilon)
```
    Deprecated. Use assertRotationVectorGeometricallyEquals(Vector3DReadOnly, Vector3DReadOnly, double) instead. This method will be removed in a future version.
    
    Asserts on a per component basis that the two rotation vectors are equal to an epsilon.
    The method returns true for angles such as: actualAngle = expectedAngle +/- 2.0 * Math.PI.
    
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    expected - the expected rotation vector. Not modified.
    
    actual - the actual rotation vector. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two rotation vectors are not equal. If only one of the arguments is equal to null.
  - assertRotationVectorEquals
```
@Deprecated
public static void assertRotationVectorEquals(java.lang.String messagePrefix,
                                                           Vector3DReadOnly expected,
                                                           Vector3DReadOnly actual,
                                                           double epsilon)
```
    Deprecated. Use assertRotationVectorGeometricallyEquals(String, Vector3DReadOnly, Vector3DReadOnly, double) instead. This method will be removed in a future version.
    
    Asserts on a per component basis that the two rotation vectors are equal to an epsilon.
    The method returns true for angles such as: actualAngle = expectedAngle +/- 2.0 * Math.PI.
    
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected rotation vector. Not modified.
    
    actual - the actual rotation vector. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two rotation vectors are not equal. If only one of the arguments is equal to null.
  - assertRotationVectorEquals
```
@Deprecated
public static void assertRotationVectorEquals(java.lang.String messagePrefix,
                                                           Vector3DReadOnly expected,
                                                           Vector3DReadOnly actual,
                                                           double epsilon,
                                                           java.lang.String format)
```
    Deprecated. Use assertRotationVectorGeometricallyEquals(String, Vector3DReadOnly, Vector3DReadOnly, double, String) instead. This method will be removed in a future version.
    
    Asserts on a per component basis that the two rotation vectors are equal to an epsilon.
    The method returns true for angles such as: actualAngle = expectedAngle +/- 2.0 * Math.PI.
    
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected rotation vector. Not modified.
    
    actual - the actual rotation vector. Not modified.
    
    epsilon - the tolerance to use.
    
    format - the format to use for printing each component when an AssertionError is thrown.
    
    Throws:
    
    java.lang.AssertionError - if the two rotation vectors are not equal. If only one of the arguments is equal to null.
  - assertRotationVectorGeometricallyEquals
```
public static void assertRotationVectorGeometricallyEquals(Vector3DReadOnly expected,
                                                           Vector3DReadOnly actual,
                                                           double epsilon)
```
    Asserts on a per component basis that the two rotation vectors represent the same geometry to an epsilon.
    The method returns true for angles such as: actualAngle = expectedAngle +/- 2.0 * Math.PI.
    
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    expected - the expected rotation vector. Not modified.
    
    actual - the actual rotation vector. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two rotation vectors do not represent the same geometry. If only one of the arguments is equal to null.
  - assertRotationVectorGeometricallyEquals
```
public static void assertRotationVectorGeometricallyEquals(java.lang.String messagePrefix,
                                                           Vector3DReadOnly expected,
                                                           Vector3DReadOnly actual,
                                                           double epsilon)
```
    Asserts on a per component basis that the two rotation vectors represent the same geometry to an epsilon.
    The method returns true for angles such as: actualAngle = expectedAngle +/- 2.0 * Math.PI.
    
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected rotation vector. Not modified.
    
    actual - the actual rotation vector. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two rotation vectors do not represent the same geometry. If only one of the arguments is equal to null.
  - assertRotationVectorGeometricallyEquals
```
public static void assertRotationVectorGeometricallyEquals(java.lang.String messagePrefix,
                                                           Vector3DReadOnly expected,
                                                           Vector3DReadOnly actual,
                                                           double epsilon,
                                                           java.lang.String format)
```
    Asserts on a per component basis that the two rotation vectors represent the same geometry to an epsilon.
    The method returns true for angles such as: actualAngle = expectedAngle +/- 2.0 * Math.PI.
    
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected rotation vector. Not modified.
    
    actual - the actual rotation vector. Not modified.
    
    epsilon - the tolerance to use.
    
    format - the format to use for printing each component when an AssertionError is thrown.
    
    Throws:
    
    java.lang.AssertionError - if the two rotation vectors do not represent the same geometry. If only one of the arguments is equal to null.
  - assertTuple2DEquals
```
public static void assertTuple2DEquals(Tuple2DReadOnly expected,
                                       Tuple2DReadOnly actual,
                                       double epsilon)
```
    Asserts on a per component basis that the two tuples are equal to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    expected - the expected tuple. Not modified.
    
    actual - the actual tuple. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two tuples are not equal. If only one of the arguments is equal to null.
  - assertTuple2DEquals
```
public static void assertTuple2DEquals(java.lang.String messagePrefix,
                                       Tuple2DReadOnly expected,
                                       Tuple2DReadOnly actual,
                                       double epsilon)
```
    Asserts on a per component basis that the two tuples are equal to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the automated message.
    
    expected - the expected tuple. Not modified.
    
    actual - the actual tuple. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two tuples are not equal. If only one of the arguments is equal to null.
  - assertTuple2DEquals
```
public static void assertTuple2DEquals(java.lang.String messagePrefix,
                                       Tuple2DReadOnly expected,
                                       Tuple2DReadOnly actual,
                                       double epsilon,
                                       java.lang.String format)
```
    Asserts on a per component basis that the two tuples are equal to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the automated message.
    
    expected - the expected tuple. Not modified.
    
    actual - the actual tuple. Not modified.
    
    epsilon - the tolerance to use.
    
    format - the format to use for printing each component when an AssertionError is thrown.
    
    Throws:
    
    java.lang.AssertionError - if the two tuples are not equal. If only one of the arguments is equal to null.
  - assertPoint2DGeometricallyEquals
```
public static void assertPoint2DGeometricallyEquals(Point2DReadOnly expected,
                                                    Point2DReadOnly actual,
                                                    double epsilon)
```
    Asserts on a per component basis that the two points represent the same geometry to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    expected - the expected point. Not modified.
    
    actual - the actual point. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two points do not represent the same geometry. If only one of the arguments is equal to null.
  - assertPoint2DGeometricallyEquals
```
public static void assertPoint2DGeometricallyEquals(java.lang.String messagePrefix,
                                                    Point2DReadOnly expected,
                                                    Point2DReadOnly actual,
                                                    double epsilon)
```
    Asserts on a per component basis that the two points represent the same geometry to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected point. Not modified.
    
    actual - the actual point. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two points do not represent the same geometry. If only one of the arguments is equal to null.
  - assertPoint2DGeometricallyEquals
```
public static void assertPoint2DGeometricallyEquals(java.lang.String messagePrefix,
                                                    Point2DReadOnly expected,
                                                    Point2DReadOnly actual,
                                                    double epsilon,
                                                    java.lang.String format)
```
    Asserts on a per component basis that the two points represent the same geometry to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected point. Not modified.
    
    actual - the actual point. Not modified.
    
    epsilon - the tolerance to use.
    
    format - the format to use for printing each component when an AssertionError is thrown.
    
    Throws:
    
    java.lang.AssertionError - if the two points do not represent the same geometry. If only one of the arguments is equal to null.
  - assertVector2DGeometricallyEquals
```
public static void assertVector2DGeometricallyEquals(Vector2DReadOnly expected,
                                                     Vector2DReadOnly actual,
                                                     double epsilon)
```
    Asserts on a per component basis that the two vectors represent the same geometry to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    expected - the expected vector. Not modified.
    
    actual - the actual vector. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two vectors do not represent the same geometry. If only one of the arguments is equal to null.
  - assertVector2DGeometricallyEquals
```
public static void assertVector2DGeometricallyEquals(java.lang.String messagePrefix,
                                                     Vector2DReadOnly expected,
                                                     Vector2DReadOnly actual,
                                                     double epsilon)
```
    Asserts on a per component basis that the two vectors represent the same geometry to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected vector. Not modified.
    
    actual - the actual vector. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two vectors do not represent the same geometry. If only one of the arguments is equal to null.
  - assertVector2DGeometricallyEquals
```
public static void assertVector2DGeometricallyEquals(java.lang.String messagePrefix,
                                                     Vector2DReadOnly expected,
                                                     Vector2DReadOnly actual,
                                                     double epsilon,
                                                     java.lang.String format)
```
    Asserts on a per component basis that the two vectors represent the same geometry to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected vector. Not modified.
    
    actual - the actual vector. Not modified.
    
    epsilon - the tolerance to use.
    
    format - the format to use for printing each component when an AssertionError is thrown.
    
    Throws:
    
    java.lang.AssertionError - if the two vectors do not represent the same geometry. If only one of the arguments is equal to null.
  - assertTuple3DEquals
```
public static void assertTuple3DEquals(Tuple3DReadOnly expected,
                                       Tuple3DReadOnly actual,
                                       double epsilon)
```
    Asserts on a per component basis that the two tuples are equal to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    expected - the expected tuple. Not modified.
    
    actual - the actual tuple. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two tuples are not equal. If only one of the arguments is equal to null.
  - assertTuple3DEquals
```
public static void assertTuple3DEquals(java.lang.String messagePrefix,
                                       Tuple3DReadOnly expected,
                                       Tuple3DReadOnly actual,
                                       double epsilon)
```
    Asserts on a per component basis that the two tuples are equal to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected tuple. Not modified.
    
    actual - the actual tuple. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two tuples are not equal. If only one of the arguments is equal to null.
  - assertTuple3DEquals
```
public static void assertTuple3DEquals(java.lang.String messagePrefix,
                                       Tuple3DReadOnly expected,
                                       Tuple3DReadOnly actual,
                                       double epsilon,
                                       java.lang.String format)
```
    Asserts on a per component basis that the two tuples are equal to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected tuple. Not modified.
    
    actual - the actual tuple. Not modified.
    
    epsilon - the tolerance to use.
    
    format - the format to use for printing each component when an AssertionError is thrown.
    
    Throws:
    
    java.lang.AssertionError - if the two tuples are not equal. If only one of the arguments is equal to null.
  - assertPoint3DGeometricallyEquals
```
public static void assertPoint3DGeometricallyEquals(Point3DReadOnly expected,
                                                    Point3DReadOnly actual,
                                                    double epsilon)
```
    Asserts on a per component basis that the two points represent the same geometry to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    expected - the expected point. Not modified.
    
    actual - the actual point. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two points do not represent the same geometry. If only one of the arguments is equal to null.
  - assertPoint3DGeometricallyEquals
```
public static void assertPoint3DGeometricallyEquals(java.lang.String messagePrefix,
                                                    Point3DReadOnly expected,
                                                    Point3DReadOnly actual,
                                                    double epsilon)
```
    Asserts on a per component basis that the two points represent the same geometry to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected point. Not modified.
    
    actual - the actual point. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two points do not represent the same geometry. If only one of the arguments is equal to null.
  - assertPoint3DGeometricallyEquals
```
public static void assertPoint3DGeometricallyEquals(java.lang.String messagePrefix,
                                                    Point3DReadOnly expected,
                                                    Point3DReadOnly actual,
                                                    double epsilon,
                                                    java.lang.String format)
```
    Asserts on a per component basis that the two points represent the same geometry to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected point. Not modified.
    
    actual - the actual point. Not modified.
    
    epsilon - the tolerance to use.
    
    format - the format to use for printing each component when an AssertionError is thrown.
    
    Throws:
    
    java.lang.AssertionError - if the two points do not represent the same geometry. If only one of the arguments is equal to null.
  - assertVector3DGeometricallyEquals
```
public static void assertVector3DGeometricallyEquals(Vector3DReadOnly expected,
                                                     Vector3DReadOnly actual,
                                                     double epsilon)
```
    Asserts on a per component basis that the two vectors represent the same geometry to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    expected - the expected vector. Not modified.
    
    actual - the actual vector. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two vectors do not represent the same geometry. If only one of the arguments is equal to null.
  - assertVector3DGeometricallyEquals
```
public static void assertVector3DGeometricallyEquals(java.lang.String messagePrefix,
                                                     Vector3DReadOnly expected,
                                                     Vector3DReadOnly actual,
                                                     double epsilon)
```
    Asserts on a per component basis that the two vectors represent the same geometry to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected vector. Not modified.
    
    actual - the actual vector. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two vectors do not represent the same geometry. If only one of the arguments is equal to null.
  - assertVector3DGeometricallyEquals
```
public static void assertVector3DGeometricallyEquals(java.lang.String messagePrefix,
                                                     Vector3DReadOnly expected,
                                                     Vector3DReadOnly actual,
                                                     double epsilon,
                                                     java.lang.String format)
```
    Asserts on a per component basis that the two vectors represent the same geometry to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected vector. Not modified.
    
    actual - the actual vector. Not modified.
    
    epsilon - the tolerance to use.
    
    format - the format to use for printing each component when an AssertionError is thrown.
    
    Throws:
    
    java.lang.AssertionError - if the two vectors do not represent the same geometry. If only one of the arguments is equal to null.
  - assertTuple4DEquals
```
public static void assertTuple4DEquals(Tuple4DReadOnly expected,
                                       Tuple4DReadOnly actual,
                                       double epsilon)
```
    Asserts on a per component basis that the two tuples are equal to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    expected - the expected tuple. Not modified.
    
    actual - the actual tuple. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two tuples are not equal. If only one of the arguments is equal to null.
  - assertTuple4DEquals
```
public static void assertTuple4DEquals(java.lang.String messagePrefix,
                                       Tuple4DReadOnly expected,
                                       Tuple4DReadOnly actual,
                                       double epsilon)
```
    Asserts on a per component basis that the two tuples are equal to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected tuple. Not modified.
    
    actual - the actual tuple. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two tuples are not equal. If only one of the arguments is equal to null.
  - assertTuple4DEquals
```
public static void assertTuple4DEquals(java.lang.String messagePrefix,
                                       Tuple4DReadOnly expected,
                                       Tuple4DReadOnly actual,
                                       double epsilon,
                                       java.lang.String format)
```
    Asserts on a per component basis that the two tuples are equal to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected tuple. Not modified.
    
    actual - the actual tuple. Not modified.
    
    epsilon - the tolerance to use.
    
    format - the format to use for printing each component when an AssertionError is thrown.
    
    Throws:
    
    java.lang.AssertionError - if the two tuples are not equal. If only one of the arguments is equal to null.
  - assertVector4DGeometricallyEquals
```
public static void assertVector4DGeometricallyEquals(Vector4DReadOnly expected,
                                                     Vector4DReadOnly actual,
                                                     double epsilon)
```
    Asserts on a per component basis that the two vectors represent the same geometry to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    expected - the expected vector. Not modified.
    
    actual - the actual vector. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two vectors do not represent the same geometry. If only one of the arguments is equal to null.
  - assertVector4DGeometricallyEquals
```
public static void assertVector4DGeometricallyEquals(java.lang.String messagePrefix,
                                                     Vector4DReadOnly expected,
                                                     Vector4DReadOnly actual,
                                                     double epsilon)
```
    Asserts on a per component basis that the two vectors represent the same geometry to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected vector. Not modified.
    
    actual - the actual vector. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two vectors do not represent the same geometry. If only one of the arguments is equal to null.
  - assertVector4DGeometricallyEquals
```
public static void assertVector4DGeometricallyEquals(java.lang.String messagePrefix,
                                                     Vector4DReadOnly expected,
                                                     Vector4DReadOnly actual,
                                                     double epsilon,
                                                     java.lang.String format)
```
    Asserts on a per component basis that the two vectors represent the same geometry to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected vector. Not modified.
    
    actual - the actual vector. Not modified.
    
    epsilon - the tolerance to use.
    
    format - the format to use for printing each component when an AssertionError is thrown.
    
    Throws:
    
    java.lang.AssertionError - if the two vectors do not represent the same geometry. If only one of the arguments is equal to null.
  - assertMatrix3DEquals
```
public static void assertMatrix3DEquals(Matrix3DReadOnly expected,
                                        Matrix3DReadOnly actual,
                                        double epsilon)
```
    Asserts on a per component basis that the two matrices are equal to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    expected - the expected matrix. Not modified.
    
    actual - the actual matrix. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two matrices are not equal. If only one of the arguments is equal to null.
  - assertMatrix3DEquals
```
public static void assertMatrix3DEquals(java.lang.String messagePrefix,
                                        Matrix3DReadOnly expected,
                                        Matrix3DReadOnly actual,
                                        double epsilon)
```
    Asserts on a per component basis that the two matrices are equal to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected matrix. Not modified.
    
    actual - the actual matrix. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two matrices are not equal. If only one of the arguments is equal to null.
  - assertMatrix3DEquals
```
public static void assertMatrix3DEquals(java.lang.String messagePrefix,
                                        Matrix3DReadOnly expected,
                                        Matrix3DReadOnly actual,
                                        double epsilon,
                                        java.lang.String format)
```
    Asserts on a per component basis that the two matrices are equal to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected matrix. Not modified.
    
    actual - the actual matrix. Not modified.
    
    epsilon - the tolerance to use.
    
    format - the format to use for printing each component when an AssertionError is thrown.
    
    Throws:
    
    java.lang.AssertionError - if the two matrices are not equal. If only one of the arguments is equal to null.
  - assertRotationMatrixGeometricallyEquals
```
public static void assertRotationMatrixGeometricallyEquals(RotationMatrixReadOnly expected,
                                                           RotationMatrixReadOnly actual,
                                                           double epsilon)
```
    Asserts on a per component basis that the two rotation matrices represent the same geometry to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    expected - the expected rotation matrix. Not modified.
    
    actual - the actual rotation matrix. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two rotation matrices do not represent the same geometry. If only one of the arguments is equal to null.
  - assertRotationMatrixGeometricallyEquals
```
public static void assertRotationMatrixGeometricallyEquals(java.lang.String messagePrefix,
                                                           RotationMatrixReadOnly expected,
                                                           RotationMatrixReadOnly actual,
                                                           double epsilon)
```
    Asserts on a per component basis that the two rotation matrices represent the same geometry to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected rotation matrix. Not modified.
    
    actual - the actual rotation matrix. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two rotation matrices do not represent the same geometry. If only one of the arguments is equal to null.
  - assertRotationMatrixGeometricallyEquals
```
public static void assertRotationMatrixGeometricallyEquals(java.lang.String messagePrefix,
                                                           RotationMatrixReadOnly expected,
                                                           RotationMatrixReadOnly actual,
                                                           double epsilon,
                                                           java.lang.String format)
```
    Asserts on a per component basis that the two rotation matrices represent the same geometry to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected rotation matrix. Not modified.
    
    actual - the actual rotation matrix. Not modified.
    
    epsilon - the tolerance to use.
    
    format - the format to use for printing each component when an AssertionError is thrown.
    
    Throws:
    
    java.lang.AssertionError - if the two rotation matrices do not represent the same geometry. If only one of the arguments is equal to null.
  - assertSkewSymmetric
```
public static void assertSkewSymmetric(Matrix3DReadOnly matrixToAssert,
                                       double epsilon)
```
    Asserts that the given matrix is skew-symmetric:
```
     |  0 -z  y |
 m = |  z  0 -x |
     | -y  x  0 |
 
```
    This matrix is considered to be skew symmetric if:
    - each diagonal coefficient is equal to 0.0 +/- epsilon,
    - the sums of each pair of cross-diagonal coefficients (m10, m01), (m12, m21), and (m20, m02) are equal to 0.0 +/- epsilon.
    Parameters:
    
    matrixToAssert - the query. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the matrix is not skew-symmetric. If the argument is equal to null.
  - assertSkewSymmetric
```
public static void assertSkewSymmetric(java.lang.String messagePrefix,
                                       Matrix3DReadOnly matrixToAssert,
                                       double epsilon)
```
    Asserts that the given matrix is skew-symmetric:
```
     |  0 -z  y |
 m = |  z  0 -x |
     | -y  x  0 |
 
```
    This matrix is considered to be skew symmetric if:
    - each diagonal coefficient is equal to 0.0 +/- epsilon,
    - the sums of each pair of cross-diagonal coefficients (m10, m01), (m12, m21), and (m20, m02) are equal to 0.0 +/- epsilon.
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    matrixToAssert - the query. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the matrix is not skew-symmetric. If the argument is equal to null.
  - assertSkewSymmetric
```
public static void assertSkewSymmetric(java.lang.String messagePrefix,
                                       Matrix3DReadOnly matrixToAssert,
                                       double epsilon,
                                       java.lang.String format)
```
    Asserts that the given matrix is skew-symmetric:
```
     |  0 -z  y |
 m = |  z  0 -x |
     | -y  x  0 |
 
```
    This matrix is considered to be skew symmetric if:
    - each diagonal coefficient is equal to 0.0 +/- epsilon,
    - the sums of each pair of cross-diagonal coefficients (m10, m01), (m12, m21), and (m20, m02) are equal to 0.0 +/- epsilon.
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    matrixToAssert - the query. Not modified.
    
    epsilon - the tolerance to use.
    
    format - the format to use for printing each component when an AssertionError is thrown.
    
    Throws:
    
    java.lang.AssertionError - if the matrix is not skew-symmetric. If the argument is equal to null.
  - assertRotationMatrix
```
public static void assertRotationMatrix(Matrix3DReadOnly matrixToAssert,
                                        double epsilon)
```
    Asserts that this matrix is a rotation matrix.
    This matrix is a rotation matrix if:
    - the length of each row vector is equal to 1.0 +/- epsilon,
    - the dot product of each pair of row vectors is equal to 0.0 +/- epsilon,
    - the determinant of the matrix is equal to 1.0 +/- epsilon.
    Parameters:
    
    matrixToAssert - the query. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the matrix is not a rotation matrix. If the argument is equal to null.
  - assertRotationMatrix
```
public static void assertRotationMatrix(java.lang.String messagePrefix,
                                        Matrix3DReadOnly matrixToAssert,
                                        double epsilon)
```
    Asserts that this matrix is a rotation matrix.
    This matrix is a rotation matrix if:
    - the length of each row vector is equal to 1.0 +/- epsilon,
    - the dot product of each pair of row vectors is equal to 0.0 +/- epsilon,
    - the determinant of the matrix is equal to 1.0 +/- epsilon.
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    matrixToAssert - the query. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the matrix is not a rotation matrix. If the argument is equal to null.
  - assertRotationMatrix
```
public static void assertRotationMatrix(java.lang.String messagePrefix,
                                        Matrix3DReadOnly matrixToAssert,
                                        double epsilon,
                                        java.lang.String format)
```
    Asserts that this matrix is a rotation matrix.
    This matrix is a rotation matrix if:
    - the length of each row vector is equal to 1.0 +/- epsilon,
    - the dot product of each pair of row vectors is equal to 0.0 +/- epsilon,
    - the determinant of the matrix is equal to 1.0 +/- epsilon.
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    matrixToAssert - the query. Not modified.
    
    epsilon - the tolerance to use.
    
    format - the format to use for printing each component when an AssertionError is thrown.
    
    Throws:
    
    java.lang.AssertionError - if the matrix is not a rotation matrix. If the argument is equal to null.
  - assertIdentity
```
public static void assertIdentity(Matrix3DReadOnly matrixToAssert,
                                  double epsilon)
```
    Asserts on a per coefficient basis that this matrix is equal to identity to an epsilon.
    
    Parameters:
    
    matrixToAssert - the query. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the matrix is not identity. If the argument is equal to null.
  - assertIdentity
```
public static void assertIdentity(java.lang.String messagePrefix,
                                  Matrix3DReadOnly matrixToAssert,
                                  double epsilon)
```
    Asserts on a per coefficient basis that this matrix is equal to identity to an epsilon.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    matrixToAssert - the query. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the matrix is not identity. If the argument is equal to null.
  - assertIdentity
```
public static void assertIdentity(java.lang.String messagePrefix,
                                  Matrix3DReadOnly matrixToAssert,
                                  double epsilon,
                                  java.lang.String format)
```
    Asserts on a per coefficient basis that this matrix is equal to identity to an epsilon.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    matrixToAssert - the query. Not modified.
    
    epsilon - the tolerance to use.
    
    format - the format to use for printing each component when an AssertionError is thrown.
    
    Throws:
    
    java.lang.AssertionError - if the matrix is not identity. If the argument is equal to null.
  - assertMatrix3DContainsOnlyNaN
```
public static void assertMatrix3DContainsOnlyNaN(Matrix3DReadOnly matrixToAssert)
```
    Asserts that the given matrix contains on Double.NaN.
    
    Parameters:
    
    matrixToAssert - the query. Not modified.
    
    Throws:
    
    java.lang.AssertionError - if the matrix does not only contain Double.NaN. If the argument is equal to null.
  - assertMatrix3DContainsOnlyNaN
```
public static void assertMatrix3DContainsOnlyNaN(java.lang.String messagePrefix,
                                                 Matrix3DReadOnly matrixToAssert)
```
    Asserts that the given matrix contains on Double.NaN.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    matrixToAssert - the query. Not modified.
    
    Throws:
    
    java.lang.AssertionError - if the matrix does not only contain Double.NaN. If the argument is equal to null.
  - assertQuaternionEquals
```
public static void assertQuaternionEquals(QuaternionReadOnly expected,
                                          QuaternionReadOnly actual,
                                          double epsilon)
```
    Asserts on a per component basis that the two quaternions are equal to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    expected - the expected quaternion. Not modified.
    
    actual - the actual quaternion. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two quaternions are not equal. If only one of the arguments is equal to null.
  - assertQuaternionEquals
```
public static void assertQuaternionEquals(java.lang.String messagePrefix,
                                          QuaternionReadOnly expected,
                                          QuaternionReadOnly actual,
                                          double epsilon)
```
    Asserts on a per component basis that the two quaternions are equal to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected quaternion. Not modified.
    
    actual - the actual quaternion. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two quaternions are not equal. If only one of the arguments is equal to null.
  - assertQuaternionEquals
```
public static void assertQuaternionEquals(java.lang.String messagePrefix,
                                          QuaternionReadOnly expected,
                                          QuaternionReadOnly actual,
                                          double epsilon,
                                          java.lang.String format)
```
    Asserts on a per component basis that the two quaternions are equal to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected quaternion. Not modified.
    
    actual - the actual quaternion. Not modified.
    
    epsilon - the tolerance to use.
    
    format - the format to use for printing each component when an AssertionError is thrown.
    
    Throws:
    
    java.lang.AssertionError - if the two quaternions are not equal. If only one of the arguments is equal to null.
  - assertQuaternionGeometricallyEquals
```
public static void assertQuaternionGeometricallyEquals(QuaternionReadOnly expected,
                                                       QuaternionReadOnly actual,
                                                       double epsilon)
```
    Asserts on a per component basis that the two quaternions represent the same geometry to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    expected - the expected quaternion. Not modified.
    
    actual - the actual quaternion. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two quaternions do not represent the same geometry. If only one of the arguments is equal to null.
  - assertQuaternionGeometricallyEquals
```
public static void assertQuaternionGeometricallyEquals(java.lang.String messagePrefix,
                                                       QuaternionReadOnly expected,
                                                       QuaternionReadOnly actual,
                                                       double epsilon)
```
    Asserts on a per component basis that the two quaternions represent the same geometry to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected quaternion. Not modified.
    
    actual - the actual quaternion. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two quaternions do not represent the same geometry. If only one of the arguments is equal to null.
  - assertQuaternionGeometricallyEquals
```
public static void assertQuaternionGeometricallyEquals(java.lang.String messagePrefix,
                                                       QuaternionReadOnly expected,
                                                       QuaternionReadOnly actual,
                                                       double epsilon,
                                                       java.lang.String format)
```
    Asserts on a per component basis that the two quaternions represent the same geometry to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected quaternion. Not modified.
    
    actual - the actual quaternion. Not modified.
    
    epsilon - the tolerance to use.
    
    format - the format to use for printing each component when an AssertionError is thrown.
    
    Throws:
    
    java.lang.AssertionError - if the two quaternions do not represent the same geometry. If only one of the arguments is equal to null.
  - assertQuaternionEqualsSmart
```
@Deprecated
public static void assertQuaternionEqualsSmart(QuaternionReadOnly expected,
                                                            QuaternionReadOnly actual,
                                                            double epsilon)
```
    Deprecated. Use assertQuaternionGeometricallyEquals(QuaternionReadOnly, QuaternionReadOnly, double) instead. This method will be removed in a future version.
    
    Asserts on a per component basis that the two quaternions are equal to an epsilon.
    This method changes the sign of one of the two quaternions when comparing if their dot product is negative.
    
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    expected - the expected quaternion. Not modified.
    
    actual - the actual quaternion. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two quaternions are not equal. If only one of the arguments is equal to null.
  - assertQuaternionEqualsSmart
```
@Deprecated
public static void assertQuaternionEqualsSmart(java.lang.String messagePrefix,
                                                            QuaternionReadOnly expected,
                                                            QuaternionReadOnly actual,
                                                            double epsilon)
```
    Deprecated. Use assertQuaternionGeometricallyEquals(String, QuaternionReadOnly, QuaternionReadOnly, double) instead. This method will be removed in a future version.
    
    Asserts on a per component basis that the two quaternions are equal to an epsilon.
    This method changes the sign of one of the two quaternions when comparing if their dot product is negative.
    
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected quaternion. Not modified.
    
    actual - the actual quaternion. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two quaternions are not equal. If only one of the arguments is equal to null.
  - assertQuaternionEqualsSmart
```
@Deprecated
public static void assertQuaternionEqualsSmart(java.lang.String messagePrefix,
                                                            QuaternionReadOnly expected,
                                                            QuaternionReadOnly actual,
                                                            double epsilon,
                                                            java.lang.String format)
```
    Deprecated. Use assertQuaternionGeometricallyEquals(String, QuaternionReadOnly, QuaternionReadOnly, double, String) instead. This method will be removed in a future version.
    
    Asserts on a per component basis that the two quaternions are equal to an epsilon.
    This method changes the sign of one of the two quaternions when comparing if their dot product is negative.
    
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected quaternion. Not modified.
    
    actual - the actual quaternion. Not modified.
    
    epsilon - the tolerance to use.
    
    format - the format to use for printing each component when an AssertionError is thrown.
    
    Throws:
    
    java.lang.AssertionError - if the two quaternions are not equal. If only one of the arguments is equal to null.
  - assertQuaternionEqualsUsingDifference
```
@Deprecated
public static void assertQuaternionEqualsUsingDifference(QuaternionReadOnly expected,
                                                                      QuaternionReadOnly actual,
                                                                      double epsilon)
```
    Deprecated. Use assertQuaternionGeometricallyEquals(QuaternionReadOnly, QuaternionReadOnly, double) instead. This method will be removed in a future version.
    
    Asserts that the two given quaternions represents the same orientation to an epsilon by calculating the magnitude of their difference.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    expected - the expected quaternion. Not modified.
    
    actual - the actual quaternion. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two quaternions do not represent the same orientation. If only one of the arguments is equal to null.
  - assertQuaternionEqualsUsingDifference
```
@Deprecated
public static void assertQuaternionEqualsUsingDifference(java.lang.String messagePrefix,
                                                                      QuaternionReadOnly expected,
                                                                      QuaternionReadOnly actual,
                                                                      double epsilon)
```
    Deprecated. Use assertQuaternionGeometricallyEquals(String, QuaternionReadOnly, QuaternionReadOnly, double) instead. This method will be removed in a future version.
    
    Asserts that the two given quaternions represents the same orientation to an epsilon by calculating the magnitude of their difference.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected quaternion. Not modified.
    
    actual - the actual quaternion. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two quaternions do not represent the same orientation. If only one of the arguments is equal to null.
  - assertQuaternionEqualsUsingDifference
```
@Deprecated
public static void assertQuaternionEqualsUsingDifference(java.lang.String messagePrefix,
                                                                      QuaternionReadOnly expected,
                                                                      QuaternionReadOnly actual,
                                                                      double epsilon,
                                                                      java.lang.String format)
```
    Deprecated. Use assertQuaternionGeometricallyEquals(String, QuaternionReadOnly, QuaternionReadOnly, double, String) instead. This method will be removed in a future version.
    
    Asserts that the two given quaternions represents the same orientation to an epsilon by calculating the magnitude of their difference.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected quaternion. Not modified.
    
    actual - the actual quaternion. Not modified.
    
    epsilon - the tolerance to use.
    
    format - the format to use for printing each component when an AssertionError is thrown.
    
    Throws:
    
    java.lang.AssertionError - if the two quaternions do not represent the same orientation. If only one of the arguments is equal to null.
  - assertAxisAngleEquals
```
public static void assertAxisAngleEquals(AxisAngleReadOnly expected,
                                         AxisAngleReadOnly actual,
                                         double epsilon)
```
    Asserts on a per component basis if the two axis-angles are equal to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    expected - the expected axis-angle. Not modified.
    
    actual - the actual axis-angle. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two axis-angles are not equal. If only one of the arguments is equal to null.
  - assertAxisAngleEquals
```
public static void assertAxisAngleEquals(java.lang.String messagePrefix,
                                         AxisAngleReadOnly expected,
                                         AxisAngleReadOnly actual,
                                         double epsilon)
```
    Asserts on a per component basis if the two axis-angles are equal to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected axis-angle. Not modified.
    
    actual - the actual axis-angle. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two axis-angles are not equal. If only one of the arguments is equal to null.
  - assertAxisAngleEquals
```
public static void assertAxisAngleEquals(java.lang.String messagePrefix,
                                         AxisAngleReadOnly expected,
                                         AxisAngleReadOnly actual,
                                         double epsilon,
                                         java.lang.String format)
```
    Asserts on a per component basis if the two axis-angles are equal to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected axis-angle. Not modified.
    
    actual - the actual axis-angle. Not modified.
    
    epsilon - the tolerance to use.
    
    format - the format to use for printing each component when an AssertionError is thrown.
    
    Throws:
    
    java.lang.AssertionError - if the two axis-angles are not equal. If only one of the arguments is equal to null.
  - assertAxisAngleGeometricallyEquals
```
public static void assertAxisAngleGeometricallyEquals(AxisAngleReadOnly expected,
                                                      AxisAngleReadOnly actual,
                                                      double epsilon)
```
    Asserts on a per component basis if the two axis-angles represent the same geometry to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    expected - the expected axis-angle. Not modified.
    
    actual - the actual axis-angle. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two axis-angles do not represent the same geometry. If only one of the arguments is equal to null.
  - assertAxisAngleGeometricallyEquals
```
public static void assertAxisAngleGeometricallyEquals(java.lang.String messagePrefix,
                                                      AxisAngleReadOnly expected,
                                                      AxisAngleReadOnly actual,
                                                      double epsilon)
```
    Asserts on a per component basis if the two axis-angles represent the same geometry to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected axis-angle. Not modified.
    
    actual - the actual axis-angle. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two axis-angles do not represent the same geometry. If only one of the arguments is equal to null.
  - assertAxisAngleGeometricallyEquals
```
public static void assertAxisAngleGeometricallyEquals(java.lang.String messagePrefix,
                                                      AxisAngleReadOnly expected,
                                                      AxisAngleReadOnly actual,
                                                      double epsilon,
                                                      java.lang.String format)
```
    Asserts on a per component basis if the two axis-angles represent the same geometry to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected axis-angle. Not modified.
    
    actual - the actual axis-angle. Not modified.
    
    epsilon - the tolerance to use.
    
    format - the format to use for printing each component when an AssertionError is thrown.
    
    Throws:
    
    java.lang.AssertionError - if the two axis-angles do not represent the same geometry. If only one of the arguments is equal to null.
  - assertAxisAngleEqualsSmart
```
@Deprecated
public static void assertAxisAngleEqualsSmart(AxisAngleReadOnly expected,
                                                           AxisAngleReadOnly actual,
                                                           double epsilon)
```
    Deprecated. Use assertAxisAngleGeometricallyEquals(AxisAngleReadOnly, AxisAngleReadOnly, double) instead. This method will be removed in a future version.
    
    Asserts on a per component basis if the two axis-angles are equal to an epsilon.
    This method changes the sign of one of the two axis-angles when comparing if the dot product of their axis is negative.
    
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    expected - the expected axis-angle. Not modified.
    
    actual - the actual axis-angle. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two axis-angles are not equal. If only one of the arguments is equal to null.
  - assertAxisAngleEqualsSmart
```
@Deprecated
public static void assertAxisAngleEqualsSmart(java.lang.String messagePrefix,
                                                           AxisAngleReadOnly expected,
                                                           AxisAngleReadOnly actual,
                                                           double epsilon)
```
    Deprecated. Use assertAxisAngleGeometricallyEquals(String, AxisAngleReadOnly, AxisAngleReadOnly, double) instead. This method will be removed in a future version.
    
    Asserts on a per component basis if the two axis-angles are equal to an epsilon.
    This method changes the sign of one of the two axis-angles when comparing if the dot product of their axis is negative.
    
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected axis-angle. Not modified.
    
    actual - the actual axis-angle. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two axis-angles are not equal. If only one of the arguments is equal to null.
  - assertAxisAngleEqualsSmart
```
@Deprecated
public static void assertAxisAngleEqualsSmart(java.lang.String messagePrefix,
                                                           AxisAngleReadOnly expected,
                                                           AxisAngleReadOnly actual,
                                                           double epsilon,
                                                           java.lang.String format)
```
    Deprecated. Use assertAxisAngleGeometricallyEquals(String, AxisAngleReadOnly, AxisAngleReadOnly, double, String) instead. This method will be removed in a future version.
    
    Asserts on a per component basis if the two axis-angles are equal to an epsilon.
    This method changes the sign of one of the two axis-angles when comparing if the dot product of their axis is negative.
    
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected axis-angle. Not modified.
    
    actual - the actual axis-angle. Not modified.
    
    epsilon - the tolerance to use.
    
    format - the format to use for printing each component when an AssertionError is thrown.
    
    Throws:
    
    java.lang.AssertionError - if the two axis-angles are not equal. If only one of the arguments is equal to null.
  - assertAxisAngleContainsOnlyNaN
```
public static void assertAxisAngleContainsOnlyNaN(AxisAngleReadOnly axisAngleToAssert)
```
    Asserts that the given axis-angle contains only Double.NaN.
    
    Parameters:
    
    axisAngleToAssert - the query. Not modified.
    
    Throws:
    
    java.lang.AssertionError - if the axis-angle does not only contain Double.NaN. If the argument is equal to null.
  - assertAxisAngleContainsOnlyNaN
```
public static void assertAxisAngleContainsOnlyNaN(java.lang.String messagePrefix,
                                                  AxisAngleReadOnly axisAngleToAssert)
```
    Asserts that the given axis-angle contains only Double.NaN.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    axisAngleToAssert - the query. Not modified.
    
    Throws:
    
    java.lang.AssertionError - if the axis-angle does not only contain Double.NaN. If the argument is equal to null.
  - assertAxisAngleIsSetToZero
```
public static void assertAxisAngleIsSetToZero(AxisAngleReadOnly axisAngleToAssert)
```
    Assert that AxisAngleBasics.setToZero() has just been called on the given axis-angle.
    
    Parameters:
    
    axisAngleToAssert - the query. Not modified.
    
    Throws:
    
    java.lang.AssertionError - if the axis-angle has not been set to zero. If the argument is equal to null.
  - assertAxisAngleIsSetToZero
```
public static void assertAxisAngleIsSetToZero(java.lang.String messagePrefix,
                                              AxisAngleReadOnly axisAngleToAssert)
```
    Assert that AxisAngleBasics.setToZero() has just been called on the given axis-angle.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    axisAngleToAssert - the query. Not modified.
    
    Throws:
    
    java.lang.AssertionError - if the axis-angle has not been set to zero. If the argument is equal to null.
  - assertAxisUnitary
```
public static void assertAxisUnitary(AxisAngleReadOnly axisAngleToAssert,
                                     double epsilon)
```
    Asserts that the length of the axis of the axis-angle is equal to 1.0 +/- epsilon.
    
    Parameters:
    
    axisAngleToAssert - the query. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the axis is not unitary. If the argument is equal to null.
  - assertAxisUnitary
```
public static void assertAxisUnitary(java.lang.String messagePrefix,
                                     AxisAngleReadOnly axisAngleToAssert,
                                     double epsilon)
```
    Asserts that the length of the axis of the axis-angle is equal to 1.0 +/- epsilon.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    axisAngleToAssert - the query. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the axis is not unitary. If the argument is equal to null.
  - assertAxisUnitary
```
public static void assertAxisUnitary(java.lang.String messagePrefix,
                                     AxisAngleReadOnly axisAngleToAssert,
                                     double epsilon,
                                     java.lang.String format)
```
    Asserts that the length of the axis of the axis-angle is equal to 1.0 +/- epsilon.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    axisAngleToAssert - the query. Not modified.
    
    epsilon - the tolerance to use.
    
    format - the format to use for printing each component when an AssertionError is thrown.
    
    Throws:
    
    java.lang.AssertionError - if the axis is not unitary. If the argument is equal to null.
  - assertQuaternionIsSetToZero
```
public static void assertQuaternionIsSetToZero(QuaternionReadOnly quaternionToAssert)
```
    Assert that QuaternionBasics.setToZero() has just been called on the given quaternion.
    
    Parameters:
    
    quaternionToAssert - the query. Not modified.
    
    Throws:
    
    java.lang.AssertionError - if the quaternion has not been set to zero. If the argument is equal to null.
  - assertQuaternionIsSetToZero
```
public static void assertQuaternionIsSetToZero(java.lang.String messagePrefix,
                                               QuaternionReadOnly quaternionToAssert)
```
    Assert that QuaternionBasics.setToZero() has just been called on the given quaternion.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    quaternionToAssert - the query. Not modified.
    
    Throws:
    
    java.lang.AssertionError - if the quaternion has not been set to zero. If the argument is equal to null.
  - assertQuaternionIsSetToZero
```
public static void assertQuaternionIsSetToZero(java.lang.String messagePrefix,
                                               QuaternionReadOnly quaternionToAssert,
                                               java.lang.String format)
```
    Assert that QuaternionBasics.setToZero() has just been called on the given quaternion.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    quaternionToAssert - the query. Not modified.
    
    format - the format to use for printing each component when an AssertionError is thrown.
    
    Throws:
    
    java.lang.AssertionError - if the quaternion has not been set to zero. If the argument is equal to null.
  - assertQuaternionIsUnitary
```
public static void assertQuaternionIsUnitary(QuaternionReadOnly quaternionToAssert,
                                             double epsilon)
```
    Asserts that the norm of the given quaternion is equal to 1.0 +/- epsilon.
    
    Parameters:
    
    quaternionToAssert - the query. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the quaternion is not a unit-quaternion. If the argument is equal to null.
  - assertQuaternionIsUnitary
```
public static void assertQuaternionIsUnitary(java.lang.String messagePrefix,
                                             QuaternionReadOnly quaternionToAssert,
                                             double epsilon)
```
    Asserts that the norm of the given quaternion is equal to 1.0 +/- epsilon.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    quaternionToAssert - the query. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the quaternion is not a unit-quaternion. If the argument is equal to null.
  - assertQuaternionIsUnitary
```
public static void assertQuaternionIsUnitary(java.lang.String messagePrefix,
                                             QuaternionReadOnly quaternionToAssert,
                                             double epsilon,
                                             java.lang.String format)
```
    Asserts that the norm of the given quaternion is equal to 1.0 +/- epsilon.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    quaternionToAssert - the query. Not modified.
    
    epsilon - the tolerance to use.
    
    format - the format to use for printing each component when an AssertionError is thrown.
    
    Throws:
    
    java.lang.AssertionError - if the quaternion is not a unit-quaternion. If the argument is equal to null.
  - assertTuple2DContainsOnlyNaN
```
public static void assertTuple2DContainsOnlyNaN(Tuple2DReadOnly tupleToAssert)
```
    Asserts that the given tuple contains only Double.NaN.
    
    Parameters:
    
    tupleToAssert - the query. Not modified.
    
    Throws:
    
    java.lang.AssertionError - if the tuple does not only contain Double.NaN. If the argument is equal to null.
  - assertTuple2DContainsOnlyNaN
```
public static void assertTuple2DContainsOnlyNaN(java.lang.String messagePrefix,
                                                Tuple2DReadOnly tupleToAssert)
```
    Asserts that the given tuple contains only Double.NaN.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    tupleToAssert - the query. Not modified.
    
    Throws:
    
    java.lang.AssertionError - if the tuple does not only contain Double.NaN. If the argument is equal to null.
  - assertTuple2DIsSetToZero
```
public static void assertTuple2DIsSetToZero(Tuple2DReadOnly tupleToAssert)
```
    Assert that Tuple2DBasics.setToZero() has just been called on the given tuple.
    
    Parameters:
    
    tupleToAssert - the query. Not modified.
    
    Throws:
    
    java.lang.AssertionError - if the tuple has not been set to zero. If the argument is equal to null.
  - assertTuple2DIsSetToZero
```
public static void assertTuple2DIsSetToZero(java.lang.String messagePrefix,
                                            Tuple2DReadOnly tupleToAssert)
```
    Assert that Tuple2DBasics.setToZero() has just been called on the given tuple.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    tupleToAssert - the query. Not modified.
    
    Throws:
    
    java.lang.AssertionError - if the tuple has not been set to zero. If the argument is equal to null.
  - assertTuple2DIsSetToZero
```
public static void assertTuple2DIsSetToZero(java.lang.String messagePrefix,
                                            Tuple2DReadOnly tupleToAssert,
                                            java.lang.String format)
```
    Assert that Tuple2DBasics.setToZero() has just been called on the given tuple.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    tupleToAssert - the query. Not modified.
    
    format - the format to use for printing each component when an AssertionError is thrown.
    
    Throws:
    
    java.lang.AssertionError - if the tuple has not been set to zero. If the argument is equal to null.
  - assertTuple3DContainsOnlyNaN
```
public static void assertTuple3DContainsOnlyNaN(Tuple3DReadOnly tupleToAssert)
```
    Asserts that the given tuple contains only Double.NaN.
    
    Parameters:
    
    tupleToAssert - the query. Not modified.
    
    Throws:
    
    java.lang.AssertionError - if the tuple does not only contain Double.NaN. If the argument is equal to null.
  - assertTuple3DContainsOnlyNaN
```
public static void assertTuple3DContainsOnlyNaN(java.lang.String messagePrefix,
                                                Tuple3DReadOnly tupleToAssert)
```
    Asserts that the given tuple contains only Double.NaN.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    tupleToAssert - the query. Not modified.
    
    Throws:
    
    java.lang.AssertionError - if the tuple does not only contain Double.NaN. If the argument is equal to null.
  - assertTuple3DIsSetToZero
```
public static void assertTuple3DIsSetToZero(Tuple3DReadOnly tupleToAssert)
```
    Assert that Tuple3DBasics.setToZero() has just been called on the given tuple.
    
    Parameters:
    
    tupleToAssert - the query. Not modified.
    
    Throws:
    
    java.lang.AssertionError - if the tuple has not been set to zero. If the argument is equal to null.
  - assertTuple3DIsSetToZero
```
public static void assertTuple3DIsSetToZero(java.lang.String messagePrefix,
                                            Tuple3DReadOnly tupleToAssert)
```
    Assert that Tuple3DBasics.setToZero() has just been called on the given tuple.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    tupleToAssert - the query. Not modified.
    
    Throws:
    
    java.lang.AssertionError - if the tuple has not been set to zero. If the argument is equal to null.
  - assertTuple3DIsSetToZero
```
public static void assertTuple3DIsSetToZero(java.lang.String messagePrefix,
                                            Tuple3DReadOnly tupleToAssert,
                                            java.lang.String format)
```
    Assert that Tuple3DBasics.setToZero() has just been called on the given tuple.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    tupleToAssert - the query. Not modified.
    
    format - the format to use for printing each component when an AssertionError is thrown.
    
    Throws:
    
    java.lang.AssertionError - if the tuple has not been set to zero. If the argument is equal to null.
  - assertTuple4DContainsOnlyNaN
```
public static void assertTuple4DContainsOnlyNaN(Tuple4DReadOnly tupleToAssert)
```
    Asserts that the given tuple contains only Double.NaN.
    
    Parameters:
    
    tupleToAssert - the query. Not modified.
    
    Throws:
    
    java.lang.AssertionError - if the quaternion does not only contain Double.NaN. If the argument is equal to null.
  - assertTuple4DContainsOnlyNaN
```
public static void assertTuple4DContainsOnlyNaN(java.lang.String messagePrefix,
                                                Tuple4DReadOnly tupleToAssert)
```
    Asserts that the given quaternion contains only Double.NaN.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    tupleToAssert - the query. Not modified.
    
    Throws:
    
    java.lang.AssertionError - if the quaternion does not only contain Double.NaN. If the argument is equal to null.
  - assertRigidBodyTransformEquals
```
public static void assertRigidBodyTransformEquals(RigidBodyTransform expected,
                                                  RigidBodyTransform actual,
                                                  double epsilon)
```
    Asserts on a per component basis that the two given rigid-body transform are equal to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    expected - the expected rigid-body transform. Not modified.
    
    actual - the actual rigid-body transform. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two rigid-body transforms are not equal. If only one of the arguments is equal to null.
  - assertRigidBodyTransformEquals
```
public static void assertRigidBodyTransformEquals(java.lang.String messagePrefix,
                                                  RigidBodyTransform expected,
                                                  RigidBodyTransform actual,
                                                  double epsilon)
```
    Asserts on a per component basis that the two given rigid-body transform are equal to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected rigid-body transform. Not modified.
    
    actual - the actual rigid-body transform. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two rigid-body transforms are not equal. If only one of the arguments is equal to null.
  - assertRigidBodyTransformEquals
```
public static void assertRigidBodyTransformEquals(java.lang.String messagePrefix,
                                                  RigidBodyTransform expected,
                                                  RigidBodyTransform actual,
                                                  double epsilon,
                                                  java.lang.String format)
```
    Asserts on a per component basis that the two given rigid-body transform are equal to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected rigid-body transform. Not modified.
    
    actual - the actual rigid-body transform. Not modified.
    
    epsilon - the tolerance to use.
    
    format - the format to use for printing each component when an AssertionError is thrown.
    
    Throws:
    
    java.lang.AssertionError - if the two rigid-body transforms are not equal. If only one of the arguments is equal to null.
  - assertRigidBodyTransformGeometricallyEquals
```
public static void assertRigidBodyTransformGeometricallyEquals(RigidBodyTransform expected,
                                                               RigidBodyTransform actual,
                                                               double epsilon)
```
    Asserts on a per component basis that the two given rigid-body transform represent the same geometry to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    expected - the expected rigid-body transform. Not modified.
    
    actual - the actual rigid-body transform. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two rigid-body transforms do not represent the same geometry. If only one of the arguments is equal to null.
  - assertRigidBodyTransformGeometricallyEquals
```
public static void assertRigidBodyTransformGeometricallyEquals(java.lang.String messagePrefix,
                                                               RigidBodyTransform expected,
                                                               RigidBodyTransform actual,
                                                               double epsilon)
```
    Asserts on a per component basis that the two given rigid-body transform represent the same geometry to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected rigid-body transform. Not modified.
    
    actual - the actual rigid-body transform. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two rigid-body transforms do not represent the same geometry. If only one of the arguments is equal to null.
  - assertRigidBodyTransformGeometricallyEquals
```
public static void assertRigidBodyTransformGeometricallyEquals(java.lang.String messagePrefix,
                                                               RigidBodyTransform expected,
                                                               RigidBodyTransform actual,
                                                               double epsilon,
                                                               java.lang.String format)
```
    Asserts on a per component basis that the two given rigid-body transform represent the same geometry to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected rigid-body transform. Not modified.
    
    actual - the actual rigid-body transform. Not modified.
    
    epsilon - the tolerance to use.
    
    format - the format to use for printing each component when an AssertionError is thrown.
    
    Throws:
    
    java.lang.AssertionError - if the two rigid-body transforms do not represent the same geometry. If only one of the arguments is equal to null.
  - assertQuaternionBasedTransformEquals
```
public static void assertQuaternionBasedTransformEquals(QuaternionBasedTransform expected,
                                                        QuaternionBasedTransform actual,
                                                        double epsilon)
```
    Asserts on a per component basis that the two quaternion-based transforms are equal to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    expected - the expected quaternion-based transform. Not modified.
    
    actual - the actual quaternion-based transform. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two quaternion-based transforms are not equal. If only one of the arguments is equal to null.
  - assertQuaternionBasedTransformEquals
```
public static void assertQuaternionBasedTransformEquals(java.lang.String messagePrefix,
                                                        QuaternionBasedTransform expected,
                                                        QuaternionBasedTransform actual,
                                                        double epsilon)
```
    Asserts on a per component basis that the two quaternion-based transforms are equal to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected quaternion-based transform. Not modified.
    
    actual - the actual quaternion-based transform. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two quaternion-based transforms are not equal. If only one of the arguments is equal to null.
  - assertQuaternionBasedTransformEquals
```
public static void assertQuaternionBasedTransformEquals(java.lang.String messagePrefix,
                                                        QuaternionBasedTransform expected,
                                                        QuaternionBasedTransform actual,
                                                        double epsilon,
                                                        java.lang.String format)
```
    Asserts on a per component basis that the two quaternion-based transforms are equal to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected quaternion-based transform. Not modified.
    
    actual - the actual quaternion-based transform. Not modified.
    
    epsilon - the tolerance to use.
    
    format - the format to use for printing each component when an AssertionError is thrown.
    
    Throws:
    
    java.lang.AssertionError - if the two quaternion-based transforms are not equal. If only one of the arguments is equal to null.
  - assertQuaternionBasedTransformGeometricallyEquals
```
public static void assertQuaternionBasedTransformGeometricallyEquals(QuaternionBasedTransform expected,
                                                                     QuaternionBasedTransform actual,
                                                                     double epsilon)
```
    Asserts on a per component basis that the two quaternion-based transforms represent the same geometry to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    expected - the expected quaternion-based transform. Not modified.
    
    actual - the actual quaternion-based transform. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two quaternion-based transforms do not represent the same geometry. If only one of the arguments is equal to null.
  - assertQuaternionBasedTransformGeometricallyEquals
```
public static void assertQuaternionBasedTransformGeometricallyEquals(java.lang.String messagePrefix,
                                                                     QuaternionBasedTransform expected,
                                                                     QuaternionBasedTransform actual,
                                                                     double epsilon)
```
    Asserts on a per component basis that the two quaternion-based transforms represent the same geometry to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected quaternion-based transform. Not modified.
    
    actual - the actual quaternion-based transform. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two quaternion-based transforms do not represent the same geometry. If only one of the arguments is equal to null.
  - assertQuaternionBasedTransformGeometricallyEquals
```
public static void assertQuaternionBasedTransformGeometricallyEquals(java.lang.String messagePrefix,
                                                                     QuaternionBasedTransform expected,
                                                                     QuaternionBasedTransform actual,
                                                                     double epsilon,
                                                                     java.lang.String format)
```
    Asserts on a per component basis that the two quaternion-based transforms represent the same geometry to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected quaternion-based transform. Not modified.
    
    actual - the actual quaternion-based transform. Not modified.
    
    epsilon - the tolerance to use.
    
    format - the format to use for printing each component when an AssertionError is thrown.
    
    Throws:
    
    java.lang.AssertionError - if the two quaternion-based transforms do not represent the same geometry. If only one of the arguments is equal to null.
  - assertQuaternionBasedTransformEqualsSmart
```
@Deprecated
public static void assertQuaternionBasedTransformEqualsSmart(QuaternionBasedTransform expected,
                                                                          QuaternionBasedTransform actual,
                                                                          double epsilon)
```
    Deprecated. Use assertQuaternionBasedTransformGeometricallyEquals(QuaternionBasedTransform, QuaternionBasedTransform, double) instead. This method will be removed in a future version.
    
    Asserts on a per component basis that the two quaternion-based transforms are equal to an epsilon.
    This method compares the quaternions using assertQuaternionEqualsSmart(QuaternionReadOnly, QuaternionReadOnly, double).
    
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    expected - the expected quaternion-based transform. Not modified.
    
    actual - the actual quaternion-based transform. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two quaternion-based transforms are not equal. If only one of the arguments is equal to null.
  - assertQuaternionBasedTransformEqualsSmart
```
@Deprecated
public static void assertQuaternionBasedTransformEqualsSmart(java.lang.String messagePrefix,
                                                                          QuaternionBasedTransform expected,
                                                                          QuaternionBasedTransform actual,
                                                                          double epsilon)
```
    Deprecated. Use assertQuaternionBasedTransformGeometricallyEquals(String, QuaternionBasedTransform, QuaternionBasedTransform, double) instead. This method will be removed in a future version.
    
    Asserts on a per component basis that the two quaternion-based transforms are equal to an epsilon.
    This method compares the quaternions using assertQuaternionEqualsSmart(QuaternionReadOnly, QuaternionReadOnly, double).
    
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected quaternion-based transform. Not modified.
    
    actual - the actual quaternion-based transform. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two quaternion-based transforms are not equal. If only one of the arguments is equal to null.
  - assertQuaternionBasedTransformEqualsSmart
```
@Deprecated
public static void assertQuaternionBasedTransformEqualsSmart(java.lang.String messagePrefix,
                                                                          QuaternionBasedTransform expected,
                                                                          QuaternionBasedTransform actual,
                                                                          double epsilon,
                                                                          java.lang.String format)
```
    Deprecated. Use assertQuaternionBasedTransformGeometricallyEquals(String, QuaternionBasedTransform, QuaternionBasedTransform, double, String) instead. This method will be removed in a future version.
    
    Asserts on a per component basis that the two quaternion-based transforms are equal to an epsilon.
    This method compares the quaternions using assertQuaternionEqualsSmart(QuaternionReadOnly, QuaternionReadOnly, double).
    
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected quaternion-based transform. Not modified.
    
    actual - the actual quaternion-based transform. Not modified.
    
    epsilon - the tolerance to use.
    
    format - the format to use for printing each component when an AssertionError is thrown.
    
    Throws:
    
    java.lang.AssertionError - if the two quaternion-based transforms are not equal. If only one of the arguments is equal to null.
  - assertAffineTransformEquals
```
public static void assertAffineTransformEquals(AffineTransform expected,
                                               AffineTransform actual,
                                               double epsilon)
```
    Asserts on a per component basis that the two given affine transforms are equal to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    expected - the expected affine transform. Not modified.
    
    actual - the actual affine transform. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two affine transforms are not equal. If only one of the arguments is equal to null.
  - assertAffineTransformEquals
```
public static void assertAffineTransformEquals(java.lang.String messagePrefix,
                                               AffineTransform expected,
                                               AffineTransform actual,
                                               double epsilon)
```
    Asserts on a per component basis that the two given affine transforms are equal to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected affine transform. Not modified.
    
    actual - the actual affine transform. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two affine transforms are not equal. If only one of the arguments is equal to null.
  - assertAffineTransformEquals
```
public static void assertAffineTransformEquals(java.lang.String messagePrefix,
                                               AffineTransform expected,
                                               AffineTransform actual,
                                               double epsilon,
                                               java.lang.String format)
```
    Asserts on a per component basis that the two given affine transforms are equal to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected affine transform. Not modified.
    
    actual - the actual affine transform. Not modified.
    
    epsilon - the tolerance to use.
    
    format - the format to use for printing each component when an AssertionError is thrown.
    
    Throws:
    
    java.lang.AssertionError - if the two affine transforms are not equal. If only one of the arguments is equal to null.
  - assertAffineTransformGeometricallyEquals
```
public static void assertAffineTransformGeometricallyEquals(AffineTransform expected,
                                                            AffineTransform actual,
                                                            double epsilon)
```
    Asserts that the two given affine transforms represent the same geometry to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    expected - the expected affine transform. Not modified.
    
    actual - the actual affine transform. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two affine transforms do not represent the same geometry. If only one of the arguments is equal to null.
  - assertAffineTransformGeometricallyEquals
```
public static void assertAffineTransformGeometricallyEquals(java.lang.String messagePrefix,
                                                            AffineTransform expected,
                                                            AffineTransform actual,
                                                            double epsilon)
```
    Asserts that the two given affine transforms represent the same geometry to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected affine transform. Not modified.
    
    actual - the actual affine transform. Not modified.
    
    epsilon - the tolerance to use.
    
    Throws:
    
    java.lang.AssertionError - if the two affine transforms do not represent the same geometry. If only one of the arguments is equal to null.
  - assertAffineTransformGeometricallyEquals
```
public static void assertAffineTransformGeometricallyEquals(java.lang.String messagePrefix,
                                                            AffineTransform expected,
                                                            AffineTransform actual,
                                                            double epsilon,
                                                            java.lang.String format)
```
    Asserts that the two given affine transforms represent the same geometry to an epsilon.
    Note: the two arguments are considered to be equal if they are both equal to null.
    
    Parameters:
    
    messagePrefix - prefix to add to the error message.
    
    expected - the expected affine transform. Not modified.
    
    actual - the actual affine transform. Not modified.
    
    epsilon - the tolerance to use.
    
    format - the format to use for printing each component when an AssertionError is thrown.
    
    Throws:
    
    java.lang.AssertionError - if the two affine transforms do not represent the same geometry. If only one of the arguments is equal to null.

Class EuclidCoreTestTools

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

EuclidCoreTestTools

Method Detail

assertAngleEquals

assertAngleEquals

assertYawPitchRollEquals

assertYawPitchRollEquals

assertYawPitchRollEquals

assertYawPitchRollGeometricallyEquals

assertYawPitchRollGeometricallyEquals

assertYawPitchRollGeometricallyEquals

assertRotationVectorEquals

assertRotationVectorEquals

assertRotationVectorEquals

assertRotationVectorGeometricallyEquals

assertRotationVectorGeometricallyEquals

assertRotationVectorGeometricallyEquals

assertTuple2DEquals

assertTuple2DEquals

assertTuple2DEquals

assertPoint2DGeometricallyEquals

assertPoint2DGeometricallyEquals

assertPoint2DGeometricallyEquals

assertVector2DGeometricallyEquals

assertVector2DGeometricallyEquals

assertVector2DGeometricallyEquals

assertTuple3DEquals

assertTuple3DEquals

assertTuple3DEquals

assertPoint3DGeometricallyEquals

assertPoint3DGeometricallyEquals

assertPoint3DGeometricallyEquals

assertVector3DGeometricallyEquals

assertVector3DGeometricallyEquals

assertVector3DGeometricallyEquals

assertTuple4DEquals

assertTuple4DEquals

assertTuple4DEquals

assertVector4DGeometricallyEquals

assertVector4DGeometricallyEquals

assertVector4DGeometricallyEquals

assertMatrix3DEquals

assertMatrix3DEquals

assertMatrix3DEquals

assertRotationMatrixGeometricallyEquals

assertRotationMatrixGeometricallyEquals

assertRotationMatrixGeometricallyEquals

assertSkewSymmetric

assertSkewSymmetric

assertSkewSymmetric

assertRotationMatrix

assertRotationMatrix

assertRotationMatrix

assertIdentity

assertIdentity

assertIdentity

assertMatrix3DContainsOnlyNaN

assertMatrix3DContainsOnlyNaN

assertQuaternionEquals

assertQuaternionEquals

assertQuaternionEquals

assertQuaternionGeometricallyEquals

assertQuaternionGeometricallyEquals

assertQuaternionGeometricallyEquals

assertQuaternionEqualsSmart

assertQuaternionEqualsSmart

assertQuaternionEqualsSmart

assertQuaternionEqualsUsingDifference

assertQuaternionEqualsUsingDifference

assertQuaternionEqualsUsingDifference

assertAxisAngleEquals

assertAxisAngleEquals

assertAxisAngleEquals

assertAxisAngleGeometricallyEquals

assertAxisAngleGeometricallyEquals

assertAxisAngleGeometricallyEquals