Unit test magic-constant thresholds as cmake variables.

Add GTSAM_UNITTEST_TOLERANCE_LOOSE=1e-5 and GTSAM_UNITTEST_TOLERANCE_TIGHT=1e-8 by default.

cmake/GtsamTesting.cmake

@@ -121,6 +121,10 @@ option(GTSAM_BUILD_EXAMPLES_ALWAYS       "Build examples with 'make all' (build
 
 
 # Implementations of this file's macros:
+set(GTSAM_UNITTEST_TOLERANCE_TIGHT 1e-8 CACHE STRING "Tolerance for unit tests (tight version)")
+set(GTSAM_UNITTEST_TOLERANCE_LOOSE 1e-5 CACHE STRING "Tolerance for unit tests (loose version)")
+mark_as_advanced(GTSAM_UNITTEST_TOLERANCE_TIGHT)
+mark_as_advanced(GTSAM_UNITTEST_TOLERANCE_LOOSE)
 
 macro(gtsamAddTestsGlob_impl groupName globPatterns excludedFiles linkLibraries)
 	if(GTSAM_BUILD_TESTS)
@@ -168,6 +172,10 @@ macro(gtsamAddTestsGlob_impl groupName globPatterns excludedFiles linkLibraries)
 				# Add executable
 				add_executable(${script_name} ${script_src} ${script_headers})
 				target_link_libraries(${script_name} CppUnitLite ${linkLibraries})
+				target_compile_definitions(${script_name} PRIVATE 
+					GTSAM_UNITTEST_TOLERANCE_TIGHT=${GTSAM_UNITTEST_TOLERANCE_TIGHT}
+					GTSAM_UNITTEST_TOLERANCE_LOOSE=${GTSAM_UNITTEST_TOLERANCE_LOOSE}
+					)
 
 				# Apply user build flags from CMake cache variables:
 				gtsam_apply_build_flags(${script_name})

gtsam/base/tests/testGroup.cpp

@@ -118,7 +118,7 @@ struct traits<Dih6> : internal::MultiplicativeGroupTraits<Dih6> {
   static void Print(const Dih6& m, const string& s = "") {
     cout << s << m << endl;
   }
-  static bool Equals(const Dih6& m1, const Dih6& m2, double tol = 1e-8) {
+  static bool Equals(const Dih6& m1, const Dih6& m2, double tol = GTSAM_UNITTEST_TOLERANCE_TIGHT) {
     return m1 == m2;
   }
 };

gtsam/base/tests/testMatrix.cpp

@@ -919,8 +919,8 @@ TEST(Matrix, weighted_elimination )
     double di, sigma;
     boost::tie(r, di, sigma) = tuple;
     EXPECT(assert_equal(r, expectedR.row(i))); // verify r
-    DOUBLES_EQUAL(d(i), di, 1e-8); // verify d
-    DOUBLES_EQUAL(newSigmas(i), sigma, 1e-5); // verify sigma
+    DOUBLES_EQUAL(d(i), di, GTSAM_UNITTEST_TOLERANCE_TIGHT); // verify d
+    DOUBLES_EQUAL(newSigmas(i), sigma, GTSAM_UNITTEST_TOLERANCE_LOOSE); // verify sigma
     i += 1;
   }
 }
@@ -1147,7 +1147,7 @@ TEST(Matrix, DLT )
   boost::tie(rank,error,actual) = DLT(A);
   Vector expected = (Vector(9) << -0.0, 0.2357, 0.4714, -0.2357, 0.0, - 0.4714,-0.4714, 0.4714, 0.0).finished();
   EXPECT_LONGS_EQUAL(8,rank);
-  EXPECT_DOUBLES_EQUAL(0,error,1e-8);
+  EXPECT_DOUBLES_EQUAL(0,error,GTSAM_UNITTEST_TOLERANCE_TIGHT);
   EXPECT(assert_equal(expected, actual, 1e-4));
 }
 

gtsam/base/tests/testNumericalDerivative.cpp

@@ -37,7 +37,7 @@ TEST(testNumericalDerivative, numericalGradient) {
 
   Vector actual = numericalGradient<Vector2>(f, x);
 
-  EXPECT(assert_equal(expected, actual, 1e-5));
+  EXPECT(assert_equal(expected, actual, GTSAM_UNITTEST_TOLERANCE_LOOSE));
 }
 
 /* ************************************************************************* */
@@ -49,7 +49,7 @@ TEST(testNumericalDerivative, numericalHessian) {
 
   Matrix actual = numericalHessian<Vector2>(f, x);
 
-  EXPECT(assert_equal(expected, actual, 1e-5));
+  EXPECT(assert_equal(expected, actual, GTSAM_UNITTEST_TOLERANCE_LOOSE));
 }
 
 /* ************************************************************************* */
@@ -69,7 +69,7 @@ TEST(testNumericalDerivative, numericalHessian2) {
 
   Matrix actual = numericalHessian(f2, x);
 
-  EXPECT(assert_equal(expected, actual, 1e-5));
+  EXPECT(assert_equal(expected, actual, GTSAM_UNITTEST_TOLERANCE_LOOSE));
 }
 
 /* ************************************************************************* */
@@ -84,15 +84,15 @@ TEST(testNumericalDerivative, numericalHessian211) {
 
   Matrix expected11 = (Matrix(1, 1) << -sin(x1) * cos(x2)).finished();
   Matrix actual11 = numericalHessian211<double, double>(f3, x1, x2);
-  EXPECT(assert_equal(expected11, actual11, 1e-5));
+  EXPECT(assert_equal(expected11, actual11, GTSAM_UNITTEST_TOLERANCE_LOOSE));
 
   Matrix expected12 = (Matrix(1, 1) << -cos(x1) * sin(x2)).finished();
   Matrix actual12 = numericalHessian212<double, double>(f3, x1, x2);
-  EXPECT(assert_equal(expected12, actual12, 1e-5));
+  EXPECT(assert_equal(expected12, actual12, GTSAM_UNITTEST_TOLERANCE_LOOSE));
 
   Matrix expected22 = (Matrix(1, 1) << -sin(x1) * cos(x2)).finished();
   Matrix actual22 = numericalHessian222<double, double>(f3, x1, x2);
-  EXPECT(assert_equal(expected22, actual22, 1e-5));
+  EXPECT(assert_equal(expected22, actual22, GTSAM_UNITTEST_TOLERANCE_LOOSE));
 }
 
 TEST(testNumericalDerivative, numericalHessian212) {
@@ -112,27 +112,27 @@ TEST(testNumericalDerivative, numericalHessian311) {
   double x = 1, y = 2, z = 3;
   Matrix expected11 = (Matrix(1, 1) << -sin(x) * cos(y) * z * z).finished();
   Matrix actual11 = numericalHessian311<double, double, double>(f4, x, y, z);
-  EXPECT(assert_equal(expected11, actual11, 1e-5));
+  EXPECT(assert_equal(expected11, actual11, GTSAM_UNITTEST_TOLERANCE_LOOSE));
 
   Matrix expected12 = (Matrix(1, 1) << -cos(x) * sin(y) * z * z).finished();
   Matrix actual12 = numericalHessian312<double, double, double>(f4, x, y, z);
-  EXPECT(assert_equal(expected12, actual12, 1e-5));
+  EXPECT(assert_equal(expected12, actual12, GTSAM_UNITTEST_TOLERANCE_LOOSE));
 
   Matrix expected13 = (Matrix(1, 1) << cos(x) * cos(y) * 2 * z).finished();
   Matrix actual13 = numericalHessian313<double, double, double>(f4, x, y, z);
-  EXPECT(assert_equal(expected13, actual13, 1e-5));
+  EXPECT(assert_equal(expected13, actual13, GTSAM_UNITTEST_TOLERANCE_LOOSE));
 
   Matrix expected22 = (Matrix(1, 1) << -sin(x) * cos(y) * z * z).finished();
   Matrix actual22 = numericalHessian322<double, double, double>(f4, x, y, z);
-  EXPECT(assert_equal(expected22, actual22, 1e-5));
+  EXPECT(assert_equal(expected22, actual22, GTSAM_UNITTEST_TOLERANCE_LOOSE));
 
   Matrix expected23 = (Matrix(1, 1) << -sin(x) * sin(y) * 2 * z).finished();
   Matrix actual23 = numericalHessian323<double, double, double>(f4, x, y, z);
-  EXPECT(assert_equal(expected23, actual23, 1e-5));
+  EXPECT(assert_equal(expected23, actual23, GTSAM_UNITTEST_TOLERANCE_LOOSE));
 
   Matrix expected33 = (Matrix(1, 1) << sin(x) * cos(y) * 2).finished();
   Matrix actual33 = numericalHessian333<double, double, double>(f4, x, y, z);
-  EXPECT(assert_equal(expected33, actual33, 1e-5));
+  EXPECT(assert_equal(expected33, actual33, GTSAM_UNITTEST_TOLERANCE_LOOSE));
 }
 
 /* ************************************************************************* */
@@ -152,7 +152,7 @@ TEST(testNumericalDerivative, numeriDerivative61) {
   Matrix61 actual61 = numericalDerivative61<Vector6, double, double,
       double, double, double, double>(f6, x1, x2, x3, x4, x5, x6);
 
-  EXPECT(assert_equal(expected61, actual61, 1e-5));
+  EXPECT(assert_equal(expected61, actual61, GTSAM_UNITTEST_TOLERANCE_LOOSE));
 }
 
 /* ************************************************************************* */
@@ -164,7 +164,7 @@ TEST(testNumericalDerivative, numeriDerivative62) {
   Matrix61 actual62 = numericalDerivative62<Vector6, double, double, double,
      double, double, double>(f6, x1, x2, x3, x4, x5, x6);
 
-  EXPECT(assert_equal(expected62, actual62, 1e-5));
+  EXPECT(assert_equal(expected62, actual62, GTSAM_UNITTEST_TOLERANCE_LOOSE));
 }
 
 /* ************************************************************************* */
@@ -176,7 +176,7 @@ TEST(testNumericalDerivative, numeriDerivative63) {
   Matrix61 actual63 = numericalDerivative63<Vector6, double, double, double,
      double, double, double>(f6, x1, x2, x3, x4, x5, x6);
 
-  EXPECT(assert_equal(expected63, actual63, 1e-5));
+  EXPECT(assert_equal(expected63, actual63, GTSAM_UNITTEST_TOLERANCE_LOOSE));
 }
 
 /* ************************************************************************* */
@@ -188,7 +188,7 @@ TEST(testNumericalDerivative, numeriDerivative64) {
   Matrix61 actual64 = numericalDerivative64<Vector6, double, double, double,
      double, double, double>(f6, x1, x2, x3, x4, x5, x6);
 
-  EXPECT(assert_equal(expected64, actual64, 1e-5));
+  EXPECT(assert_equal(expected64, actual64, GTSAM_UNITTEST_TOLERANCE_LOOSE));
 }
 
 /* ************************************************************************* */
@@ -200,7 +200,7 @@ TEST(testNumericalDerivative, numeriDerivative65) {
   Matrix61 actual65 = numericalDerivative65<Vector6, double, double, double,
      double, double, double>(f6, x1, x2, x3, x4, x5, x6);
 
-  EXPECT(assert_equal(expected65, actual65, 1e-5));
+  EXPECT(assert_equal(expected65, actual65, GTSAM_UNITTEST_TOLERANCE_LOOSE));
 }
 
 /* ************************************************************************* */
@@ -212,7 +212,7 @@ TEST(testNumericalDerivative, numeriDerivative66) {
   Matrix61 actual66 = numericalDerivative66<Vector6, double, double, double, 
       double, double, double>(f6, x1, x2, x3, x4, x5, x6);
 
-  EXPECT(assert_equal(expected66, actual66, 1e-5));
+  EXPECT(assert_equal(expected66, actual66, GTSAM_UNITTEST_TOLERANCE_LOOSE));
 }
 
 /* ************************************************************************* */

gtsam/base/tests/testVector.cpp

@@ -115,7 +115,7 @@ TEST(Vector, householder )
   pair<double, Vector> result = house(x);
 
   EXPECT(result.first==0.5);
-  EXPECT(equal_with_abs_tol(expected,result.second,1e-5));
+  EXPECT(equal_with_abs_tol(expected,result.second,GTSAM_UNITTEST_TOLERANCE_LOOSE));
 }
 
 /* ************************************************************************* */
@@ -165,7 +165,7 @@ TEST(Vector, weightedPseudoinverse )
 
   // verify
   EXPECT(assert_equal(expected,actual));
-  EXPECT(std::abs(expPrecision-precision) < 1e-5);
+  EXPECT(std::abs(expPrecision-precision) < GTSAM_UNITTEST_TOLERANCE_LOOSE);
 }
 
 /* ************************************************************************* */
@@ -203,7 +203,7 @@ TEST(Vector, weightedPseudoinverse_nan )
 
   Vector expected = (Vector(4) << 1., 0., 0.,0.).finished();
   EXPECT(assert_equal(expected, pseudo));
-  DOUBLES_EQUAL(100, precision, 1e-5);
+  DOUBLES_EQUAL(100, precision, GTSAM_UNITTEST_TOLERANCE_LOOSE);
 }
 
 /* ************************************************************************* */

gtsam/discrete/tests/testDecisionTreeFactor.cpp

@@ -82,7 +82,7 @@ TEST( DecisionTreeFactor, sum_max)
 
   DecisionTreeFactor expected(v1, "9 12");
   DecisionTreeFactor::shared_ptr actual = f1.sum(1);
-  CHECK(assert_equal(expected, *actual, 1e-5));
+  CHECK(assert_equal(expected, *actual, GTSAM_UNITTEST_TOLERANCE_LOOSE));
 //  f1.print("f1:");
 //  actual->print("actual: ");
 //  actual->printCache("actual cache: ");

gtsam/discrete/tests/testDiscreteConditional.cpp

@@ -104,7 +104,7 @@ TEST( DiscreteConditional, Combine) {
   DiscreteConditional expected(2, factor);
   DiscreteConditional::shared_ptr actual = DiscreteConditional::Combine(
       c.begin(), c.end());
-  EXPECT(assert_equal(expected, *actual,1e-5));
+  EXPECT(assert_equal(expected, *actual,GTSAM_UNITTEST_TOLERANCE_LOOSE));
 }
 
 /* ************************************************************************* */

gtsam/discrete/tests/testDiscreteMarginals.cpp

@@ -136,12 +136,12 @@ TEST_UNSAFE( DiscreteMarginals, truss ) {
   // test 0
   DecisionTreeFactor expectedM0(key[0],"0.666667 0.333333");
   DiscreteFactor::shared_ptr actualM0 = marginals(0);
-  EXPECT(assert_equal(expectedM0, *boost::dynamic_pointer_cast<DecisionTreeFactor>(actualM0),1e-5));
+  EXPECT(assert_equal(expectedM0, *boost::dynamic_pointer_cast<DecisionTreeFactor>(actualM0),GTSAM_UNITTEST_TOLERANCE_LOOSE));
 
   // test 1
   DecisionTreeFactor expectedM1(key[1],"0.333333 0.666667");
   DiscreteFactor::shared_ptr actualM1 = marginals(1);
-  EXPECT(assert_equal(expectedM1, *boost::dynamic_pointer_cast<DecisionTreeFactor>(actualM1),1e-5));
+  EXPECT(assert_equal(expectedM1, *boost::dynamic_pointer_cast<DecisionTreeFactor>(actualM1),GTSAM_UNITTEST_TOLERANCE_LOOSE));
 }
 
 /* ************************************************************************* */

gtsam/geometry/tests/testCal3Bundler.cpp

@@ -52,7 +52,7 @@ TEST( Cal3Bundler, calibrate )
   Point2 pn(0.5, 0.5);
   Point2 pi = K.uncalibrate(pn);
   Point2 pn_hat = K.calibrate(pi);
-  CHECK( traits<Point2>::Equals(pn, pn_hat, 1e-5));
+  CHECK( traits<Point2>::Equals(pn, pn_hat, GTSAM_UNITTEST_TOLERANCE_LOOSE));
 }
 
 /* ************************************************************************* */

gtsam/geometry/tests/testCal3DS2.cpp

@@ -48,7 +48,7 @@ TEST( Cal3DS2, calibrate )
   Point2 pn(0.5, 0.5);
   Point2 pi = K.uncalibrate(pn);
   Point2 pn_hat = K.calibrate(pi);
-  CHECK( traits<Point2>::Equals(pn, pn_hat, 1e-5));
+  CHECK( traits<Point2>::Equals(pn, pn_hat, GTSAM_UNITTEST_TOLERANCE_LOOSE));
 }
 
 Point2 uncalibrate_(const Cal3DS2& k, const Point2& pt) { return k.uncalibrate(pt); }
@@ -59,25 +59,25 @@ TEST( Cal3DS2, Duncalibrate1)
   Matrix computed;
   K.uncalibrate(p, computed, boost::none);
   Matrix numerical = numericalDerivative21(uncalibrate_, K, p, 1e-7);
-  CHECK(assert_equal(numerical,computed,1e-5));
+  CHECK(assert_equal(numerical,computed,GTSAM_UNITTEST_TOLERANCE_LOOSE));
   Matrix separate = K.D2d_calibration(p);
-  CHECK(assert_equal(numerical,separate,1e-5));
+  CHECK(assert_equal(numerical,separate,GTSAM_UNITTEST_TOLERANCE_LOOSE));
 }
 
 /* ************************************************************************* */
 TEST( Cal3DS2, Duncalibrate2)
 {
   Matrix computed; K.uncalibrate(p, boost::none, computed);
   Matrix numerical = numericalDerivative22(uncalibrate_, K, p, 1e-7);
-  CHECK(assert_equal(numerical,computed,1e-5));
+  CHECK(assert_equal(numerical,computed,GTSAM_UNITTEST_TOLERANCE_LOOSE));
   Matrix separate = K.D2d_intrinsic(p);
-  CHECK(assert_equal(numerical,separate,1e-5));
+  CHECK(assert_equal(numerical,separate,GTSAM_UNITTEST_TOLERANCE_LOOSE));
 }
 
 /* ************************************************************************* */
 TEST( Cal3DS2, assert_equal)
 {
-  CHECK(assert_equal(K,K,1e-5));
+  CHECK(assert_equal(K,K,GTSAM_UNITTEST_TOLERANCE_LOOSE));
 }
 
 /* ************************************************************************* */

gtsam/geometry/tests/testCal3Unified.cpp

@@ -59,7 +59,7 @@ TEST( Cal3Unified, calibrate)
 {
   Point2 pi = K.uncalibrate(p);
   Point2 pn_hat = K.calibrate(pi);
-  CHECK( traits<Point2>::Equals(p, pn_hat, 1e-8));
+  CHECK( traits<Point2>::Equals(p, pn_hat, GTSAM_UNITTEST_TOLERANCE_TIGHT));
 }
 
 Point2 uncalibrate_(const Cal3Unified& k, const Point2& pt) { return k.uncalibrate(pt); }

gtsam/geometry/tests/testCal3_S2.cpp

@@ -64,7 +64,7 @@ TEST( Cal3_S2, Duncalibrate1)
 {
   Matrix25 computed; K.uncalibrate(p, computed, boost::none);
   Matrix numerical = numericalDerivative21(uncalibrate_, K, p);
-  CHECK(assert_equal(numerical,computed,1e-8));
+  CHECK(assert_equal(numerical,computed,GTSAM_UNITTEST_TOLERANCE_TIGHT));
 }
 
 /* ************************************************************************* */
@@ -82,8 +82,8 @@ TEST(Cal3_S2, Dcalibrate1)
     Matrix computed;
     Point2 expected = K.calibrate(p_uv, computed, boost::none);
     Matrix numerical = numericalDerivative21(calibrate_, K, p_uv);
-    CHECK(assert_equal(expected, p_xy, 1e-8));
-    CHECK(assert_equal(numerical, computed, 1e-8));
+    CHECK(assert_equal(expected, p_xy, GTSAM_UNITTEST_TOLERANCE_TIGHT));
+    CHECK(assert_equal(numerical, computed, GTSAM_UNITTEST_TOLERANCE_TIGHT));
 }
 
 /* ************************************************************************* */
@@ -92,8 +92,8 @@ TEST(Cal3_S2, Dcalibrate2)
     Matrix computed;
     Point2 expected = K.calibrate(p_uv, boost::none, computed);
     Matrix numerical = numericalDerivative22(calibrate_, K, p_uv);
-    CHECK(assert_equal(expected, p_xy, 1e-8));
-    CHECK(assert_equal(numerical, computed, 1e-8));
+    CHECK(assert_equal(expected, p_xy, GTSAM_UNITTEST_TOLERANCE_TIGHT));
+    CHECK(assert_equal(numerical, computed, GTSAM_UNITTEST_TOLERANCE_TIGHT));
 }
 
 /* ************************************************************************* */

gtsam/geometry/tests/testCyclic.cpp

@@ -97,7 +97,7 @@ struct traits<K4> : internal::AdditiveGroupTraits<K4> {
   static void Print(const K4& m, const string& s = "") {
     cout << s << "(" << m.first << "," << m.second << ")" << endl;
   }
-  static bool Equals(const K4& m1, const K4& m2, double tol = 1e-8) {
+  static bool Equals(const K4& m1, const K4& m2, double tol = GTSAM_UNITTEST_TOLERANCE_TIGHT) {
     return m1 == m2;
   }
 };