@Test public void testPreMultiply() { Random random = new Random(65445L); for (int i = 0; i < ITERATIONS; i++) { T qOther1 = createRandomTuple(random); T qOther2 = createRandomTuple(random); T qActual = createRandomTuple(random); T qExpected = createEmptyTuple(); { // Test preMultiply(QuaternionBasics other) qActual.set(qOther1); qExpected.set(qOther1); qActual.preMultiply(qOther2); QuaternionTools.multiply(qOther2, qExpected, qExpected); EuclidCoreTestTools.assertQuaternionEquals(qActual, qExpected, getEpsilon()); } } }
@Test public void testDifference() { Random random = new Random(65445L); T diff = createEmptyTuple(); T expected = createEmptyTuple(); for (int i = 0; i < ITERATIONS; i++) { T q1 = createRandomTuple(random); T q2 = createRandomTuple(random); diff.difference(q1, q2); QuaternionTools.multiplyConjugateLeft(q1, q2, expected); EuclidCoreTestTools.assertQuaternionEquals(diff, expected, getEpsilon()); } }
@Test public void testSetToZero() { Random random = new Random(621541L); T quaternion = createRandomTuple(random); quaternion.setToZero(); T zeroQ = createTuple(0.0, 0.0, 0.0, 1.0); EuclidCoreTestTools.assertQuaternionEquals(quaternion, zeroQ, getEpsilon()); }
@Test public void testMultiply() { Random random = new Random(65445L); for (int i = 0; i < ITERATIONS; i++) { T qOther1 = createRandomTuple(random); T qOther2 = createRandomTuple(random); T qActual = createRandomTuple(random); T qExpected = createEmptyTuple(); { // Test multiply(QuaternionBasics other) qActual.set(qOther1); qExpected.set(qOther1); qActual.multiply(qOther2); QuaternionTools.multiply(qExpected, qOther2, qExpected); EuclidCoreTestTools.assertQuaternionEquals(qActual, qExpected, getEpsilon()); } { // Test multiply(QuaternionBasics q1, QuaternionBasics q2) qActual.multiply(qOther1, qOther2); QuaternionTools.multiply(qOther1, qOther2, qExpected); EuclidCoreTestTools.assertQuaternionEquals(qActual, qExpected, getEpsilon()); } } }
@Test public void testGetRotationVector() throws Exception { Random random = new Random(23423L); for (int i = 0; i < ITERATIONS; i++) { T quaternion = createRandomTuple(random); Vector3D expectedRotationVector = new Vector3D(); Vector3D actualRotationVector = new Vector3D(); RotationVectorConversion.convertQuaternionToRotationVector(quaternion, expectedRotationVector); quaternion.getRotationVector(actualRotationVector); EuclidCoreTestTools.assertTuple3DEquals(expectedRotationVector, actualRotationVector, getEpsilon()); } }
@Test public void testPreMultiplyConjugate() { Random random = new Random(65445L); for (int i = 0; i < ITERATIONS; i++) { T qOther1 = createRandomTuple(random); T qOther2 = createRandomTuple(random); T qActual = createRandomTuple(random); T qExpected = createEmptyTuple(); { // Test preMultiplyConjugateThis(QuaternionBasics other) qExpected.set(qOther1); qExpected.conjugate(); qExpected.preMultiply(qOther2); qActual.set(qOther1); qActual.preMultiplyConjugateThis(qOther2); EuclidCoreTestTools.assertQuaternionEquals(qActual, qExpected, getEpsilon()); } { // Test preMultiplyConjugateOther(QuaternionBasics other) qExpected.set(qOther1); T qOther2Conjugated = createEmptyTuple(); qOther2Conjugated.setAndConjugate(qOther2); qExpected.preMultiply(qOther2Conjugated); qActual.set(qOther1); qActual.preMultiplyConjugateOther(qOther2); EuclidCoreTestTools.assertQuaternionEquals(qActual, qExpected, getEpsilon()); } } }
@Test public void testDistancePrecise() throws Exception { Random random = new Random(1651L); for (int i = 0; i < ITERATIONS; i++) { QuaternionReadOnly q1 = createRandomTuple(random); for (int j = 0; j < ITERATIONS; j++) { double expectedAngle = random.nextDouble(); AxisAngle aa = new AxisAngle(EuclidCoreRandomTools.nextVector3DWithFixedLength(random, 1.0), expectedAngle); T q2 = createEmptyTuple(); q2.set(aa); q2.preMultiply(q1); double actualAngle = q1.distancePrecise(q2); assertEquals(expectedAngle, actualAngle, getEpsilon()); assertEquals(0.0, q1.distance(q1), 1.0e-3); } } }
@Test public void testMultiplyConjugate() { Random random = new Random(65445L); for (int i = 0; i < ITERATIONS; i++) { T qOther1 = createRandomTuple(random); T qOther2 = createRandomTuple(random); T qActual = createRandomTuple(random); T qExpected = createEmptyTuple(); { // Test multiplyConjugateThis(QuaternionReadOnly other) qExpected.set(qOther1); qExpected.conjugate(); qExpected.multiply(qOther2); qActual.set(qOther1); qActual.multiplyConjugateThis(qOther2); EuclidCoreTestTools.assertQuaternionEquals(qActual, qExpected, getEpsilon()); } { // Test multiplyConjugateOther(QuaternionReadOnly other) qExpected.set(qOther1); T qOther2Conjugated = createEmptyTuple(); qOther2Conjugated.setAndConjugate(qOther2); qExpected.multiply(qOther2Conjugated); qActual.set(qOther1); qActual.multiplyConjugateOther(qOther2); EuclidCoreTestTools.assertQuaternionEquals(qActual, qExpected, getEpsilon()); } } }
QuaternionReadOnly q1 = createRandomTuple(random); QuaternionReadOnly q2 = createRandomTuple(random);; qDiff.difference(q1, q2); q2 = createRandomTuple(random); qDiff.difference(q1, q2); QuaternionReadOnly q1 = createRandomTuple(random);
@Test public void testPow() throws Exception { Random random = new Random(541651L); for (int i = 0; i < ITERATIONS; i++) { QuaternionBasics original = createRandomTuple(random); double alpha = EuclidCoreRandomTools.nextDouble(random, 2.0); AxisAngle axisAngle = new AxisAngle(original); axisAngle.setAngle(alpha * axisAngle.getAngle()); QuaternionBasics expected = createEmptyTuple(); expected.set(axisAngle); QuaternionBasics actual = createEmptyTuple(); actual.set(original); actual.pow(alpha); EuclidCoreTestTools.assertQuaternionEquals(expected, actual, getEpsilon()); } }
@Override public void testSetDoubles() { Random random = new Random(621541L); T quaternion = createEmptyTuple(); for (int i = 0; i < ITERATIONS; i++) { // Test set(double x, double y, double z, double s); double x = random.nextDouble(); double y = random.nextDouble(); double z = random.nextDouble(); double s = random.nextDouble(); quaternion.set(x, y, z, s); // The method should normalize, so assertNotEquals is used. assertNotEquals(quaternion.getX(), x, getEpsilon()); assertNotEquals(quaternion.getY(), y, getEpsilon()); assertNotEquals(quaternion.getZ(), z, getEpsilon()); assertNotEquals(quaternion.getS(), s, getEpsilon()); assertEquals(1.0, quaternion.norm(), getEpsilon()); T original = createRandomTuple(random); x = original.getX(); y = original.getY(); z = original.getZ(); s = original.getS(); quaternion.set(x, y, z, s); EuclidCoreTestTools.assertQuaternionEquals(original, quaternion, getEpsilon()); } }
T original = createRandomTuple(random); T yawRotation = createEmptyTuple(); double yaw = EuclidCoreRandomTools.nextDouble(random, Math.PI); T original = createRandomTuple(random); T pitchRotation = createEmptyTuple(); double pitch = EuclidCoreRandomTools.nextDouble(random, Math.PI); T original = createRandomTuple(random); T rollRotation = createEmptyTuple(); double roll = EuclidCoreRandomTools.nextDouble(random, Math.PI);
T original = createRandomTuple(random); T yawRotation = createEmptyTuple(); double yaw = EuclidCoreRandomTools.nextDouble(random, Math.PI); T original = createRandomTuple(random); T pitchRotation = createEmptyTuple(); double pitch = EuclidCoreRandomTools.nextDouble(random, Math.PI); T original = createRandomTuple(random); T rollRotation = createEmptyTuple(); double roll = EuclidCoreRandomTools.nextDouble(random, Math.PI);
T original = createRandomTuple(random); T expected = createEmptyTuple(); T actual = createEmptyTuple(); T original = createRandomTuple(random); T expected = createEmptyTuple(); T actual = createEmptyTuple(); T original = createRandomTuple(random); T expected = createEmptyTuple(); T actual = createEmptyTuple();
T qOriginal = createRandomTuple(random); qExpected.set(qOriginal); qExpected.inverse();
T original = createRandomTuple(random); T expected = createEmptyTuple(); T actual = createEmptyTuple(); T original = createRandomTuple(random); T expected = createEmptyTuple(); T actual = createEmptyTuple(); T original = createRandomTuple(random); T expected = createEmptyTuple(); T actual = createEmptyTuple();
@Test public void testIsUnitary() { Random random = new Random(65445L); for (int i = 0; i < ITERATIONS; i++) { T q1 = createRandomTuple(random); assertTrue(q1.isUnitary(getEpsilon())); // Quaternion should have norm = 1 T q2 = createRandomTuple(random); q1 = createTuple(q2.getX(), q2.getY(), q2.getZ(), q2.getS()); assertTrue(q1.isUnitary(getEpsilon())); double delta = 6.0 * Math.sqrt(getEpsilon()); q1 = createTuple(delta + q2.getX(), q2.getY(), q2.getZ(), q2.getS()); assertFalse(q1.isUnitary(getEpsilon())); q1 = createTuple(q2.getX(), delta + q2.getY(), q2.getZ(), q2.getS()); assertFalse(q1.isUnitary(getEpsilon())); q1 = createTuple(q2.getX(), q2.getY(), delta + q2.getZ(), q2.getS()); assertFalse(q1.isUnitary(getEpsilon())); q1 = createTuple(q2.getX(), q2.getY(), q2.getZ(), delta + q2.getS()); assertFalse(q1.isUnitary(getEpsilon())); } }
for (int i = 0; i < ITERATIONS; i++) quaternion = createRandomTuple(random);
@Test public void testConjugate() { Random random = new Random(65445L); T quaternion; T quaternionCopy = createEmptyTuple(); for (int i = 0; i < ITERATIONS; i++) { quaternion = createRandomTuple(random); quaternionCopy.set(quaternion); { // Test conjugate() quaternion.conjugate(); assertEquals(quaternion.getX(), -quaternionCopy.getX(), getEpsilon()); assertEquals(quaternion.getY(), -quaternionCopy.getY(), getEpsilon()); assertEquals(quaternion.getZ(), -quaternionCopy.getZ(), getEpsilon()); assertEquals(quaternion.getS(), quaternionCopy.getS(), getEpsilon()); } { // Test conjugate (QuaternionBasics other) T quaternion2 = createEmptyTuple(); quaternion2.setAndConjugate(quaternionCopy); assertTrue(quaternion2.getX() == -quaternionCopy.getX()); assertTrue(quaternion2.getY() == -quaternionCopy.getY()); assertTrue(quaternion2.getZ() == -quaternionCopy.getZ()); assertTrue(quaternion2.getS() == quaternionCopy.getS()); } } }
T original = createRandomTuple(random); double xOriginal = signX * original.getX(); double yOriginal = signY * original.getY();