improved test coverage
git-svn-id: https://svn.apache.org/repos/asf/commons/proper/math/trunk@574265 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Luc Maisonobe
parent
02a39b2078
commit
f8b5350ec2
|
|
@ -0,0 +1,66 @@
|
|||
/*
|
||||
* Licensed to the Apache Software Foundation (ASF) under one or more
|
||||
* contributor license agreements. See the NOTICE file distributed with
|
||||
* this work for additional information regarding copyright ownership.
|
||||
* The ASF licenses this file to You under the Apache License, Version 2.0
|
||||
* (the "License"); you may not use this file except in compliance with
|
||||
* the License. You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.apache.commons.math.geometry;
|
||||
|
||||
import java.lang.reflect.Field;
|
||||
|
||||
import org.apache.commons.math.geometry.RotationOrder;
|
||||
|
||||
import junit.framework.*;
|
||||
|
||||
public class RotationOrderTest
|
||||
extends TestCase {
|
||||
|
||||
public RotationOrderTest(String name) {
|
||||
super(name);
|
||||
}
|
||||
|
||||
public void testName() {
|
||||
|
||||
RotationOrder[] orders = {
|
||||
RotationOrder.XYZ, RotationOrder.XZY, RotationOrder.YXZ,
|
||||
RotationOrder.YZX, RotationOrder.ZXY, RotationOrder.ZYX,
|
||||
RotationOrder.XYX, RotationOrder.XZX, RotationOrder.YXY,
|
||||
RotationOrder.YZY, RotationOrder.ZXZ, RotationOrder.ZYZ
|
||||
};
|
||||
|
||||
for (int i = 0; i < orders.length; ++i) {
|
||||
assertEquals(getFieldName(orders[i]), orders[i].toString());
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
private String getFieldName(RotationOrder order) {
|
||||
try {
|
||||
Field[] fields = RotationOrder.class.getFields();
|
||||
for (int i = 0; i < fields.length; ++i) {
|
||||
if (fields[i].get(null) == order) {
|
||||
return fields[i].getName();
|
||||
}
|
||||
}
|
||||
} catch (IllegalAccessException iae) {
|
||||
// ignored
|
||||
}
|
||||
return "unknown";
|
||||
}
|
||||
|
||||
public static Test suite() {
|
||||
return new TestSuite(RotationOrderTest.class);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -80,6 +80,17 @@ public class RotationTest
|
|||
checkVector(r.getAxis(), Vector3D.plusJ);
|
||||
checkAngle(r.getAngle(), Math.PI);
|
||||
|
||||
checkVector(new Rotation().getAxis(), Vector3D.plusI);
|
||||
|
||||
}
|
||||
|
||||
public void testRevert() {
|
||||
Rotation r = new Rotation(0.001, 0.36, 0.48, 0.8, true);
|
||||
Rotation reverted = r.revert();
|
||||
checkRotation(r.applyTo(reverted), 1, 0, 0, 0);
|
||||
checkRotation(reverted.applyTo(r), 1, 0, 0, 0);
|
||||
assertEquals(r.getAngle(), reverted.getAngle(), 1.0e-12);
|
||||
assertEquals(-1, Vector3D.dotProduct(r.getAxis(), reverted.getAxis()), 1.0e-12);
|
||||
}
|
||||
|
||||
public void testVectorOnePair() {
|
||||
|
|
@ -91,6 +102,14 @@ public class RotationTest
|
|||
|
||||
checkAngle(new Rotation(u, u.negate()).getAngle(), Math.PI);
|
||||
|
||||
try {
|
||||
new Rotation(u, new Vector3D());
|
||||
fail("an exception should have been thrown");
|
||||
} catch (ArithmeticException e) {
|
||||
} catch (Exception e) {
|
||||
fail("unexpected exception");
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
public void testVectorTwoPairs() {
|
||||
|
|
@ -112,11 +131,93 @@ public class RotationTest
|
|||
}
|
||||
checkAngle(r.getAngle(), Math.PI);
|
||||
|
||||
double sqrt = Math.sqrt(2) / 2;
|
||||
r = new Rotation(Vector3D.plusI, Vector3D.plusJ,
|
||||
new Vector3D(0.5, 0.5, sqrt),
|
||||
new Vector3D(0.5, 0.5, -sqrt));
|
||||
checkRotation(r, sqrt, 0.5, 0.5, 0);
|
||||
|
||||
r = new Rotation(u1, u2, u1, Vector3D.crossProduct(u1, u2));
|
||||
checkRotation(r, sqrt, -sqrt, 0, 0);
|
||||
|
||||
checkRotation(new Rotation(u1, u2, u1, u2), 1, 0, 0, 0);
|
||||
|
||||
try {
|
||||
new Rotation(u1, u2, new Vector3D(), v2);
|
||||
fail("an exception should have been thrown");
|
||||
} catch (ArithmeticException e) {
|
||||
} catch (Exception e) {
|
||||
fail("unexpected exception");
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
public void testMatrix()
|
||||
throws NotARotationMatrixException {
|
||||
|
||||
try {
|
||||
new Rotation(new double[][] {
|
||||
{ 0.0, 1.0, 0.0 },
|
||||
{ 1.0, 0.0, 0.0 }
|
||||
}, 1.0e-7);
|
||||
} catch (NotARotationMatrixException nrme) {
|
||||
// expected behavior
|
||||
} catch (Exception e) {
|
||||
fail("wrong exception caught: " + e.getMessage());
|
||||
}
|
||||
|
||||
try {
|
||||
new Rotation(new double[][] {
|
||||
{ 0.445888, 0.797184, -0.407040 },
|
||||
{ 0.821760, -0.184320, 0.539200 },
|
||||
{ -0.354816, 0.574912, 0.737280 }
|
||||
}, 1.0e-7);
|
||||
} catch (NotARotationMatrixException nrme) {
|
||||
// expected behavior
|
||||
} catch (Exception e) {
|
||||
fail("wrong exception caught: " + e.getMessage());
|
||||
}
|
||||
|
||||
try {
|
||||
new Rotation(new double[][] {
|
||||
{ 0.4, 0.8, -0.4 },
|
||||
{ -0.4, 0.6, 0.7 },
|
||||
{ 0.8, -0.2, 0.5 }
|
||||
}, 1.0e-15);
|
||||
} catch (NotARotationMatrixException nrme) {
|
||||
// expected behavior
|
||||
} catch (Exception e) {
|
||||
fail("wrong exception caught: " + e.getMessage());
|
||||
}
|
||||
|
||||
checkRotation(new Rotation(new double[][] {
|
||||
{ 0.445888, 0.797184, -0.407040 },
|
||||
{ -0.354816, 0.574912, 0.737280 },
|
||||
{ 0.821760, -0.184320, 0.539200 }
|
||||
}, 1.0e-10),
|
||||
0.8, 0.288, 0.384, 0.36);
|
||||
|
||||
checkRotation(new Rotation(new double[][] {
|
||||
{ 0.539200, 0.737280, 0.407040 },
|
||||
{ 0.184320, -0.574912, 0.797184 },
|
||||
{ 0.821760, -0.354816, -0.445888 }
|
||||
}, 1.0e-10),
|
||||
0.36, 0.8, 0.288, 0.384);
|
||||
|
||||
checkRotation(new Rotation(new double[][] {
|
||||
{ -0.445888, 0.797184, -0.407040 },
|
||||
{ 0.354816, 0.574912, 0.737280 },
|
||||
{ 0.821760, 0.184320, -0.539200 }
|
||||
}, 1.0e-10),
|
||||
0.384, 0.36, 0.8, 0.288);
|
||||
|
||||
checkRotation(new Rotation(new double[][] {
|
||||
{ -0.539200, 0.737280, 0.407040 },
|
||||
{ -0.184320, -0.574912, 0.797184 },
|
||||
{ 0.821760, 0.354816, 0.445888 }
|
||||
}, 1.0e-10),
|
||||
0.288, 0.384, 0.36, 0.8);
|
||||
|
||||
double[][] m1 = { { 0.0, 1.0, 0.0 },
|
||||
{ 0.0, 0.0, 1.0 },
|
||||
{ 1.0, 0.0, 0.0 } };
|
||||
|
|
@ -209,17 +310,11 @@ public class RotationTest
|
|||
RotationOrder.YZX, RotationOrder.ZXY, RotationOrder.ZYX
|
||||
};
|
||||
|
||||
RotationOrder[] EulerOrders = {
|
||||
RotationOrder.XYX, RotationOrder.XZX, RotationOrder.YXY,
|
||||
RotationOrder.YZY, RotationOrder.ZXZ, RotationOrder.ZYZ
|
||||
};
|
||||
|
||||
for (int i = 0; i < CardanOrders.length; ++i) {
|
||||
for (double alpha1 = 0.1; alpha1 < 6.2; alpha1 += 0.3) {
|
||||
for (double alpha2 = -1.55; alpha2 < 1.55; alpha2 += 0.3) {
|
||||
for (double alpha3 = 0.1; alpha3 < 6.2; alpha3 += 0.3) {
|
||||
Rotation r = new Rotation(CardanOrders[i],
|
||||
alpha1, alpha2, alpha3);
|
||||
Rotation r = new Rotation(CardanOrders[i], alpha1, alpha2, alpha3);
|
||||
double[] angles = r.getAngles(CardanOrders[i]);
|
||||
checkAngle(angles[0], alpha1);
|
||||
checkAngle(angles[1], alpha2);
|
||||
|
|
@ -229,6 +324,11 @@ public class RotationTest
|
|||
}
|
||||
}
|
||||
|
||||
RotationOrder[] EulerOrders = {
|
||||
RotationOrder.XYX, RotationOrder.XZX, RotationOrder.YXY,
|
||||
RotationOrder.YZY, RotationOrder.ZXZ, RotationOrder.ZYZ
|
||||
};
|
||||
|
||||
for (int i = 0; i < EulerOrders.length; ++i) {
|
||||
for (double alpha1 = 0.1; alpha1 < 6.2; alpha1 += 0.3) {
|
||||
for (double alpha2 = 0.05; alpha2 < 3.1; alpha2 += 0.3) {
|
||||
|
|
@ -246,7 +346,54 @@ public class RotationTest
|
|||
|
||||
}
|
||||
|
||||
public void testSingularities()
|
||||
throws CardanEulerSingularityException {
|
||||
|
||||
RotationOrder[] CardanOrders = {
|
||||
RotationOrder.XYZ, RotationOrder.XZY, RotationOrder.YXZ,
|
||||
RotationOrder.YZX, RotationOrder.ZXY, RotationOrder.ZYX
|
||||
};
|
||||
|
||||
double[] singularCardanAngle = { Math.PI / 2, -Math.PI / 2 };
|
||||
for (int i = 0; i < CardanOrders.length; ++i) {
|
||||
for (int j = 0; j < singularCardanAngle.length; ++j) {
|
||||
Rotation r = new Rotation(CardanOrders[i], 0.1, singularCardanAngle[j], 0.3);
|
||||
try {
|
||||
r.getAngles(CardanOrders[i]);
|
||||
fail("an exception should have been caught");
|
||||
} catch (CardanEulerSingularityException cese) {
|
||||
// expected behavior
|
||||
} catch (Exception e) {
|
||||
fail("wrong exception caught: " + e.getMessage());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
RotationOrder[] EulerOrders = {
|
||||
RotationOrder.XYX, RotationOrder.XZX, RotationOrder.YXY,
|
||||
RotationOrder.YZY, RotationOrder.ZXZ, RotationOrder.ZYZ
|
||||
};
|
||||
|
||||
double[] singularEulerAngle = { 0, Math.PI };
|
||||
for (int i = 0; i < EulerOrders.length; ++i) {
|
||||
for (int j = 0; j < singularEulerAngle.length; ++j) {
|
||||
Rotation r = new Rotation(EulerOrders[i], 0.1, singularEulerAngle[j], 0.3);
|
||||
try {
|
||||
r.getAngles(EulerOrders[i]);
|
||||
fail("an exception should have been caught");
|
||||
} catch (CardanEulerSingularityException cese) {
|
||||
// expected behavior
|
||||
} catch (Exception e) {
|
||||
fail("wrong exception caught: " + e.getMessage());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
public void testQuaternion() {
|
||||
|
||||
Rotation r1 = new Rotation(new Vector3D(2, -3, 5), 1.7);
|
||||
double n = 23.5;
|
||||
Rotation r2 = new Rotation(n * r1.getQ0(), n * r1.getQ1(),
|
||||
|
|
@ -260,6 +407,10 @@ public class RotationTest
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
r1 = new Rotation( 0.288, 0.384, 0.36, 0.8, false);
|
||||
checkRotation(r1, -r1.getQ0(), -r1.getQ1(), -r1.getQ2(), -r1.getQ3());
|
||||
|
||||
}
|
||||
|
||||
public void testCompose() {
|
||||
|
|
@ -343,6 +494,11 @@ public class RotationTest
|
|||
assertTrue(Math.abs(a1 - a2) < 1.0e-10);
|
||||
}
|
||||
|
||||
private void checkRotation(Rotation r, double q0, double q1, double q2, double q3) {
|
||||
Rotation reference = new Rotation(q0, q1, q2, q3, false);
|
||||
assertEquals(0, r.applyInverseTo(reference).getAngle(), 1.0e-12);
|
||||
}
|
||||
|
||||
public static Test suite() {
|
||||
return new TestSuite(RotationTest.class);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -28,6 +28,24 @@ public class Vector3DTest
|
|||
super(name);
|
||||
}
|
||||
|
||||
public void testConstructors() {
|
||||
double r = Math.sqrt(2) /2;
|
||||
checkVector(new Vector3D(2, new Vector3D(Math.PI / 3, -Math.PI / 4)),
|
||||
r, r * Math.sqrt(3), -2 * r);
|
||||
checkVector(new Vector3D(2, Vector3D.plusI,
|
||||
-3, Vector3D.minusK),
|
||||
2, 0, 3);
|
||||
checkVector(new Vector3D(2, Vector3D.plusI,
|
||||
5, Vector3D.plusJ,
|
||||
-3, Vector3D.minusK),
|
||||
2, 5, 3);
|
||||
checkVector(new Vector3D(2, Vector3D.plusI,
|
||||
5, Vector3D.plusJ,
|
||||
5, Vector3D.minusJ,
|
||||
-3, Vector3D.minusK),
|
||||
2, 0, 3);
|
||||
}
|
||||
|
||||
public void testCoordinates() {
|
||||
Vector3D v = new Vector3D(1, 2, 3);
|
||||
assertTrue(Math.abs(v.getX() - 1) < 1.0e-12);
|
||||
|
|
@ -46,9 +64,10 @@ public class Vector3DTest
|
|||
Vector3D v1 = new Vector3D(1, 2, 3);
|
||||
Vector3D v2 = new Vector3D(-3, -2, -1);
|
||||
v1 = v1.subtract(v2);
|
||||
checkVector(v1, new Vector3D(4, 4, 4));
|
||||
checkVector(v1, 4, 4, 4);
|
||||
|
||||
checkVector(v2.subtract(v1), new Vector3D(-7, -6, -5));
|
||||
checkVector(v2.subtract(v1), -7, -6, -5);
|
||||
checkVector(v2.subtract(3, v1), -15, -14, -13);
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -56,18 +75,19 @@ public class Vector3DTest
|
|||
Vector3D v1 = new Vector3D(1, 2, 3);
|
||||
Vector3D v2 = new Vector3D(-3, -2, -1);
|
||||
v1 = v1.add(v2);
|
||||
checkVector(v1, new Vector3D(-2, 0, 2));
|
||||
checkVector(v1, -2, 0, 2);
|
||||
|
||||
checkVector(v2.add(v1), new Vector3D(-5, -2, 1));
|
||||
checkVector(v2.add(v1), -5, -2, 1);
|
||||
checkVector(v2.add(3, v1), -9, -2, 5);
|
||||
|
||||
}
|
||||
|
||||
public void testScalarProduct() {
|
||||
Vector3D v = new Vector3D(1, 2, 3);
|
||||
v = v.multiply(3);
|
||||
checkVector(v, new Vector3D(3, 6, 9));
|
||||
checkVector(v, 3, 6, 9);
|
||||
|
||||
checkVector(v.multiply(0.5), new Vector3D(1.5, 3, 4.5));
|
||||
checkVector(v.multiply(0.5), 1.5, 3, 4.5);
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -78,7 +98,7 @@ public class Vector3DTest
|
|||
assertTrue(Math.abs(Vector3D.dotProduct(v1, v2) - 11) < 1.0e-12);
|
||||
|
||||
Vector3D v3 = Vector3D.crossProduct(v1, v2);
|
||||
checkVector(v3, new Vector3D(3, -10, -1));
|
||||
checkVector(v3, 3, -10, -1);
|
||||
|
||||
assertTrue(Math.abs(Vector3D.dotProduct(v1, v3)) < 1.0e-12);
|
||||
assertTrue(Math.abs(Vector3D.dotProduct(v2, v3)) < 1.0e-12);
|
||||
|
|
@ -111,8 +131,59 @@ public class Vector3DTest
|
|||
|
||||
}
|
||||
|
||||
private void checkVector(Vector3D v1, Vector3D v2) {
|
||||
assertTrue(v1.subtract(v2).getNorm() < 1.0e-12);
|
||||
public void testNormalize() {
|
||||
assertEquals(1.0, new Vector3D(5, -4, 2).normalize().getNorm(), 1.0e-12);
|
||||
try {
|
||||
new Vector3D().normalize();
|
||||
fail("an exception should have been thrown");
|
||||
} catch (ArithmeticException ae) {
|
||||
// expected behavior
|
||||
} catch (Exception e) {
|
||||
fail("wrong exception caught: " + e.getMessage());
|
||||
}
|
||||
}
|
||||
|
||||
public void testOrthogonal() {
|
||||
Vector3D v1 = new Vector3D(0.1, 2.5, 1.3);
|
||||
assertEquals(0.0, Vector3D.dotProduct(v1, v1.orthogonal()), 1.0e-12);
|
||||
Vector3D v2 = new Vector3D(2.3, -0.003, 7.6);
|
||||
assertEquals(0.0, Vector3D.dotProduct(v2, v2.orthogonal()), 1.0e-12);
|
||||
Vector3D v3 = new Vector3D(-1.7, 1.4, 0.2);
|
||||
assertEquals(0.0, Vector3D.dotProduct(v3, v3.orthogonal()), 1.0e-12);
|
||||
try {
|
||||
new Vector3D(0, 0, 0).orthogonal();
|
||||
fail("an exception should have been thrown");
|
||||
} catch (ArithmeticException ae) {
|
||||
// expected behavior
|
||||
} catch (Exception e) {
|
||||
fail("wrong exception caught: " + e.getMessage());
|
||||
}
|
||||
}
|
||||
|
||||
public void testAngle() {
|
||||
assertEquals(0.22572612855273393616,
|
||||
Vector3D.angle(new Vector3D(1, 2, 3), new Vector3D(4, 5, 6)),
|
||||
1.0e-12);
|
||||
assertEquals(7.98595620686106654517199e-8,
|
||||
Vector3D.angle(new Vector3D(1, 2, 3), new Vector3D(2, 4, 6.000001)),
|
||||
1.0e-12);
|
||||
assertEquals(3.14159257373023116985197793156,
|
||||
Vector3D.angle(new Vector3D(1, 2, 3), new Vector3D(-2, -4, -6.000001)),
|
||||
1.0e-12);
|
||||
try {
|
||||
Vector3D.angle(new Vector3D(), Vector3D.plusI);
|
||||
fail("an exception should have been thrown");
|
||||
} catch (ArithmeticException ae) {
|
||||
// expected behavior
|
||||
} catch (Exception e) {
|
||||
fail("wrong exception caught: " + e.getMessage());
|
||||
}
|
||||
}
|
||||
|
||||
private void checkVector(Vector3D v, double x, double y, double z) {
|
||||
assertEquals(x, v.getX(), 1.0e-12);
|
||||
assertEquals(y, v.getY(), 1.0e-12);
|
||||
assertEquals(z, v.getZ(), 1.0e-12);
|
||||
}
|
||||
|
||||
public static Test suite() {
|
||||
|
|
|
|||
Loading…
Reference in New Issue