Package us.ihmc.euclid.tools

Class EuclidCoreTestTools

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.

Author:

Sylvain Bertrand

Constructor Summary

Constructors

Constructor	Description
EuclidCoreTestTools()

Method Summary

Modifier and Type	Method	Description
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	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	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	assertAffineTransformGeometricallyEquals(AffineTransform expected, AffineTransform actual, double epsilon)	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(java.lang.String messagePrefix, AxisAngleReadOnly axisAngleToAssert)	Asserts that the given axis-angle contains only Double.NaN.
static void	assertAxisAngleContainsOnlyNaN(AxisAngleReadOnly axisAngleToAssert)	Asserts that the given axis-angle contains only Double.NaN.
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	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	assertAxisAngleEqualsSmart(java.lang.String messagePrefix, AxisAngleReadOnly expected, AxisAngleReadOnly actual, double epsilon)	Deprecated. Use assertAxisAngleGeometricallyEquals(String, AxisAngleReadOnly, AxisAngleReadOnly, double) instead.
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.
static void	assertAxisAngleEqualsSmart(AxisAngleReadOnly expected, AxisAngleReadOnly actual, double epsilon)	Deprecated. Use assertAxisAngleGeometricallyEquals(AxisAngleReadOnly, AxisAngleReadOnly, double) instead.
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	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	assertAxisAngleIsSetToZero(java.lang.String messagePrefix, AxisAngleReadOnly axisAngleToAssert)	Assert that AxisAngleBasics.setToZero() has just been called on the given axis-angle.
static void	assertAxisAngleIsSetToZero(AxisAngleReadOnly axisAngleToAssert)	Assert that AxisAngleBasics.setToZero() has just been called on the given axis-angle.
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	assertAxisUnitary(AxisAngleReadOnly axisAngleToAssert, double epsilon)	Asserts that the length of the axis of the axis-angle is equal to 1.0 +/- 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	assertIdentity(Matrix3DReadOnly matrixToAssert, double epsilon)	Asserts on a per coefficient basis that this matrix is equal to identity to an epsilon.
static void	assertMatrix3DContainsOnlyNaN(java.lang.String messagePrefix, Matrix3DReadOnly matrixToAssert)	Asserts that the given matrix contains on Double.NaN.
static void	assertMatrix3DContainsOnlyNaN(Matrix3DReadOnly matrixToAssert)	Asserts that the given matrix contains on Double.NaN.
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	assertMatrix3DEquals(Matrix3DReadOnly expected, Matrix3DReadOnly actual, double epsilon)	Asserts on a per component basis that the two matrices are equal 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	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	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	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	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	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	assertQuaternionBasedTransformEqualsSmart(java.lang.String messagePrefix, QuaternionBasedTransform expected, QuaternionBasedTransform actual, double epsilon)	Deprecated. Use assertQuaternionBasedTransformGeometricallyEquals(String, QuaternionBasedTransform, QuaternionBasedTransform, double) instead.
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.
static void	assertQuaternionBasedTransformEqualsSmart(QuaternionBasedTransform expected, QuaternionBasedTransform actual, double epsilon)	Deprecated. Use assertQuaternionBasedTransformGeometricallyEquals(QuaternionBasedTransform, QuaternionBasedTransform, double) instead.
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	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	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	assertQuaternionEquals(QuaternionReadOnly expected, QuaternionReadOnly actual, double epsilon)	Asserts on a per component basis that the two quaternions are equal to an epsilon.
static void	assertQuaternionEqualsSmart(java.lang.String messagePrefix, QuaternionReadOnly expected, QuaternionReadOnly actual, double epsilon)	Deprecated. Use assertQuaternionGeometricallyEquals(String, QuaternionReadOnly, QuaternionReadOnly, double) instead.
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.
static void	assertQuaternionEqualsSmart(QuaternionReadOnly expected, QuaternionReadOnly actual, double epsilon)	Deprecated. Use assertQuaternionGeometricallyEquals(QuaternionReadOnly, QuaternionReadOnly, double) instead.
static void	assertQuaternionEqualsUsingDifference(java.lang.String messagePrefix, QuaternionReadOnly expected, QuaternionReadOnly actual, double epsilon)	Deprecated. Use assertQuaternionGeometricallyEquals(String, QuaternionReadOnly, QuaternionReadOnly, double) instead.
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.
static void	assertQuaternionEqualsUsingDifference(QuaternionReadOnly expected, QuaternionReadOnly actual, double epsilon)	Deprecated. Use assertQuaternionGeometricallyEquals(QuaternionReadOnly, QuaternionReadOnly, double) instead.
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	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	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	assertQuaternionIsSetToZero(QuaternionReadOnly quaternionToAssert)	Assert that QuaternionBasics.setToZero() has just been called on the given quaternion.
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	assertQuaternionIsUnitary(QuaternionReadOnly quaternionToAssert, double epsilon)	Asserts that the norm of the given quaternion is equal to 1.0 +/- 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	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	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	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	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	assertRotationMatrix(Matrix3DReadOnly matrixToAssert, double epsilon)	Asserts that this matrix is a rotation matrix.
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	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	assertRotationVectorEquals(java.lang.String messagePrefix, Vector3DReadOnly expected, Vector3DReadOnly actual, double epsilon)	Deprecated. Use assertRotationVectorGeometricallyEquals(String, Vector3DReadOnly, Vector3DReadOnly, double) instead.
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.
static void	assertRotationVectorEquals(Vector3DReadOnly expected, Vector3DReadOnly actual, double epsilon)	Deprecated. Use assertRotationVectorGeometricallyEquals(Vector3DReadOnly, Vector3DReadOnly, double) instead.
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(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	assertSkewSymmetric(Matrix3DReadOnly matrixToAssert, double epsilon)	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.