Mailing-List: contact commits-help@commons.apache.org; run by ezmlm
Precedence: bulk
Reply-To: dev@commons.apache.org
Content-Type: text/plain; charset="utf-8"
MIME-Version: 1.0
Content-Transfer-Encoding: 7bit
Subject: svn commit: r574265 - in
 /commons/proper/math/trunk/src/test/org/apache/commons/math/geometry:
 RotationOrderTest.java RotationTest.java Vector3DTest.java
Date: Mon, 10 Sep 2007 14:40:43 -0000
To: commits@commons.apache.org
From: luc@apache.org
Message-Id: <20070910144043.AA47C1A9832@eris.apache.org>

Author: luc
Date: Mon Sep 10 07:40:42 2007
New Revision: 574265

URL: http://svn.apache.org/viewvc?rev=574265&view=rev
Log:
improved test coverage

Added:
    commons/proper/math/trunk/src/test/org/apache/commons/math/geometry/RotationOrderTest.java   (with props)
Modified:
    commons/proper/math/trunk/src/test/org/apache/commons/math/geometry/RotationTest.java
    commons/proper/math/trunk/src/test/org/apache/commons/math/geometry/Vector3DTest.java

Added: commons/proper/math/trunk/src/test/org/apache/commons/math/geometry/RotationOrderTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/org/apache/commons/math/geometry/RotationOrderTest.java?rev=574265&view=auto
==============================================================================
--- commons/proper/math/trunk/src/test/org/apache/commons/math/geometry/RotationOrderTest.java (added)
+++ commons/proper/math/trunk/src/test/org/apache/commons/math/geometry/RotationOrderTest.java Mon Sep 10 07:40:42 2007
@@ -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);
+  }
+
+}

Propchange: commons/proper/math/trunk/src/test/org/apache/commons/math/geometry/RotationOrderTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Modified: commons/proper/math/trunk/src/test/org/apache/commons/math/geometry/RotationTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/org/apache/commons/math/geometry/RotationTest.java?rev=574265&r1=574264&r2=574265&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/org/apache/commons/math/geometry/RotationTest.java (original)
+++ commons/proper/math/trunk/src/test/org/apache/commons/math/geometry/RotationTest.java Mon Sep 10 07:40:42 2007
@@ -80,6 +80,17 @@
     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 @@
 
     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 @@
     }
     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 @@
       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 @@
       }
     }
 
+    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 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 @@
         }
       }
     }
+
+    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() {
@@ -341,6 +492,11 @@
   private void checkAngle(double a1, double a2) {
     a2 -= 2 * Math.PI * Math.floor((a2 + Math.PI - a1) / (2 * Math.PI));
     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() {

Modified: commons/proper/math/trunk/src/test/org/apache/commons/math/geometry/Vector3DTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/org/apache/commons/math/geometry/Vector3DTest.java?rev=574265&r1=574264&r2=574265&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/org/apache/commons/math/geometry/Vector3DTest.java (original)
+++ commons/proper/math/trunk/src/test/org/apache/commons/math/geometry/Vector3DTest.java Mon Sep 10 07:40:42 2007
@@ -28,6 +28,24 @@
     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 @@
     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 @@
     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 @@
     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 @@
 
   }
 
-  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() {