Make constants::eps and variants constexpr

In the constants, pi() and phi() were declared constexpr but eps and its
variants were not. This was an oversight; there is no reason they couldn't
be declared constexpr.

Furthermore, call sites have been updated to clearly state that the values
are constexpr so future developers can easily recognize that no runtime
cost is paid to acquire those values of epsilon.

Author: SeanCurtis-TRI

include/fcl/math/constants.h

@@ -142,36 +142,31 @@ static constexpr S phi() { return S(1.618033988749894848204586834365638117720309
 /// for floats (2e-14 vs 9e-7, respectively). The choice of ε^(7/8) as the
 /// default GJK tolerance reflects a tolerance that is a *slightly* tighter
 /// bound than the historical value of 1e-6 used for 32-bit floats.
-static Real gjk_default_tolerance() {
-  static const Real value = eps_78();
-  return value;
+static constexpr Real gjk_default_tolerance() {
+  return eps_78();
 }
 
 /// Returns ε for the precision of the underlying scalar type.
-static Real eps() {
+static constexpr Real eps() {
   static_assert(std::is_floating_point<Real>::value,
                 "Constants can only be evaluated for scalars with floating "
                 "point implementations");
-  static const Real value = std::numeric_limits<Real>::epsilon();
-  return value;
+  return std::numeric_limits<Real>::epsilon();
 }
 
 /// Returns ε^(7/8) for the precision of the underlying scalar type.
-static Real eps_78() {
-  static const Real value = std::pow(eps(), 7./8.);
-  return value;
+static constexpr Real eps_78() {
+  return std::pow(eps(), 7./8.);
 }
 
 /// Returns ε^(3/4) for the precision of the underlying scalar type.
-static Real eps_34() {
-  static const Real value = std::pow(eps(), 3./4.);
-  return value;
+static constexpr Real eps_34() {
+  return std::pow(eps(), 3./4.);
 }
 
 /// Returns ε^(1/2) for the precision of the underlying scalar type.
-static Real eps_12() {
-  static const Real value = std::pow(eps(), 1./2.);
-  return value;
+static constexpr Real eps_12() {
+  return std::pow(eps(), 1./2.);
 }
 
 };

include/fcl/narrowphase/detail/convexity_based_algorithm/gjk_libccd-inl.h

@@ -313,7 +313,7 @@ _ccd_inline void tripleCross(const ccd_vec3_t *a, const ccd_vec3_t *b,
 static int doSimplex2(ccd_simplex_t *simplex, ccd_vec3_t *dir) {
   // Used to define numerical thresholds near zero; typically scaled to the size
   // of the quantities being tested.
-  const ccd_real_t eps = constants<ccd_real_t>::eps();
+  constexpr ccd_real_t eps = constants<ccd_real_t>::eps();
 
   const Vector3<ccd_real_t> p_OA(simplex->ps[simplex->last].v.v);
   const Vector3<ccd_real_t> p_OB(simplex->ps[0].v.v);
@@ -922,7 +922,7 @@ static bool are_coincident(const ccd_vec3_t& p, const ccd_vec3_t& q) {
   using std::abs;
   using std::max;
 
-  const ccd_real_t eps = constants<ccd_real_t>::eps();
+  constexpr ccd_real_t eps = constants<ccd_real_t>::eps();
   // NOTE: Wrapping "1.0" with ccd_real_t accounts for mac problems where ccd
   // is actually float based.
   for (int i = 0; i < 3; ++i) {
@@ -960,7 +960,7 @@ static bool triangle_area_is_zero(const ccd_vec3_t& a, const ccd_vec3_t& b,
   ccdVec3Normalize(&AB);
   ccdVec3Normalize(&AC);
   ccdVec3Cross(&n, &AB, &AC);
-  const ccd_real_t eps = constants<ccd_real_t>::eps();
+  constexpr ccd_real_t eps = constants<ccd_real_t>::eps();
   // Second co-linearity condition.
   if (ccdVec3Len2(&n) < eps * eps) return true;
   return false;

include/fcl/narrowphase/detail/primitive_shape_algorithm/capsule_capsule-inl.h

@@ -81,8 +81,8 @@ S closestPtSegmentSegment(const Vector3<S>& p_FP1, const Vector3<S>& p_FQ1,
                           S* s, S* t, Vector3<S>* p_FC1, Vector3<S>* p_FC2) {
   // TODO(SeanCurtis-TRI): Document the match underlying this function -- the
   //  variables: a, b, c, e, and f are otherwise overly inscrutable.
-  const auto kEps = constants<S>::eps_78();
-  const auto kEpsSquared = kEps * kEps;
+  constexpr auto kEps = constants<S>::eps_78();
+  constexpr auto kEpsSquared = kEps * kEps;
 
   Vector3<S> p_P1Q1 = p_FQ1 - p_FP1;  // Segment 1's displacement vector: D1.
   Vector3<S> p_P2Q2 = p_FQ2 - p_FP2;  // Segment 2's displacement vector: D2.
@@ -207,7 +207,7 @@ bool capsuleCapsuleDistance(const Capsule<S>& s1, const Transform3<S>& X_FC1,
   const S segment_dist = sqrt(squared_dist);
   *dist = segment_dist - s1.radius - s2.radius;
   Vector3<S> vhat_C1C2_F;
-  const auto eps = constants<S>::eps_78();
+  constexpr auto eps = constants<S>::eps_78();
   // We can only use the vector between the center-line nearest points to find
   // the witness points if they are sufficiently far apart.
   if (segment_dist > eps) {

include/fcl/narrowphase/detail/primitive_shape_algorithm/sphere_box-inl.h

@@ -135,7 +135,7 @@ FCL_EXPORT bool sphereBoxIntersect(const Sphere<S>& sphere,
     // Furthermore, in finding the *near* face, a better candidate must be more
     // than this epsilon closer to the sphere center (see the test in the
     // else branch).
-    auto eps = 16 * constants<S>::eps();
+    constexpr auto eps = 16 * constants<S>::eps();
     if (N_is_not_C && squared_distance > eps * eps) {
       // The center is on the outside. Normal direction is from C to N (computed
       // above) and penetration depth is r - |p_BN - p_BC|. The contact position

include/fcl/narrowphase/detail/primitive_shape_algorithm/sphere_cylinder-inl.h

@@ -155,7 +155,7 @@ FCL_EXPORT bool sphereCylinderIntersect(
     // Furthermore, in finding the *near* face, a better candidate must be more
     // than this epsilon closer to the sphere center (see the test in the
     // else branch).
-    const auto eps = 16 * constants<S>::eps();
+    constexpr auto eps = 16 * constants<S>::eps();
     if (S_is_outside && p_SN_squared_dist > eps * eps) {
       // The sphere center is *measurably outside* the cylinder. There are three
       // possibilities: nearest point lies on the cap face, cap edge, or barrel.