fix templating, skip bad tests

Author: rboston628

Framework/DataObjects/inc/MantidDataObjects/TableColumn.h

@@ -244,32 +244,6 @@ template <class Type> class TableColumn : public API::Column {
   }
 };
 
-/// Template specialisation for long64
-template <>
-inline bool TableColumn<int64_t>::compareVectors(const std::vector<int64_t> &newVector, double tolerance,
-                                                 bool const) const {
-  int64_t roundedTol = llround(tolerance);
-  for (size_t i = 0; i < m_data.size(); i++) {
-    if (std::llabs(m_data[i] - newVector[i]) > roundedTol) {
-      return false;
-    }
-  }
-  return true;
-}
-
-/// Template specialisation for unsigned long int
-template <>
-inline bool TableColumn<unsigned long>::compareVectors(const std::vector<unsigned long> &newVector, double tolerance,
-                                                       bool const) const {
-  long long roundedTol = llround(tolerance);
-  for (size_t i = 0; i < m_data.size(); i++) {
-    if (std::llabs((long long)m_data[i] - (long long)newVector[i]) > roundedTol) {
-      return false;
-    }
-  }
-  return true;
-}
-
 /// Template specialisation for strings for comparison
 template <>
 inline bool TableColumn<std::string>::compareVectors(const std::vector<std::string> &newVector, double tolerance,
@@ -311,40 +285,6 @@ inline bool TableColumn<Kernel::V3D>::compareVectors(const std::vector<Kernel::V
   return true;
 }
 
-/// Template specialisation for long64 with relative error
-template <>
-inline bool TableColumn<int64_t>::compareVectorsRelError(const std::vector<int64_t> &newVector, double tolerance,
-                                                         bool const) const {
-  int64_t roundedTol = llround(tolerance);
-  for (size_t i = 0; i < m_data.size(); i++) {
-    int64_t num = llabs(m_data[i] - newVector[i]);
-    int64_t den = (llabs(m_data[i]) + llabs(newVector[i])) / 2;
-    if (den < roundedTol && num > roundedTol) {
-      return false;
-    } else if (num / den > roundedTol) {
-      return false;
-    }
-  }
-  return true;
-}
-
-/// Template specialisation for unsigned long int
-template <>
-inline bool TableColumn<unsigned long>::compareVectorsRelError(const std::vector<unsigned long> &newVector,
-                                                               double tolerance, bool const) const {
-  long long roundedTol = lround(tolerance);
-  for (size_t i = 0; i < m_data.size(); i++) {
-    long long num = labs((long long)m_data[i] - (long long)newVector[i]);
-    long long den = (m_data[i] + newVector[i]) / 2;
-    if (den < roundedTol && num > roundedTol) {
-      return false;
-    } else if (num / den > roundedTol) {
-      return false;
-    }
-  }
-  return true;
-}
-
 /// Template specialisation for strings for comparison
 template <>
 inline bool TableColumn<std::string>::compareVectorsRelError(const std::vector<std::string> &newVector,

Framework/Kernel/inc/MantidKernel/FloatingPointComparison.h

@@ -16,6 +16,8 @@ namespace Mantid {
 namespace Kernel {
 /// Test for equality of doubles using compiler-defined precision
 template <typename T> MANTID_KERNEL_DLL bool equals(T const x, T const y);
+template <typename T> MANTID_KERNEL_DLL inline bool equals(T const x, T const y, std::true_type);
+template <typename T> MANTID_KERNEL_DLL inline bool equals(T const x, T const y, std::false_type);
 /// Test whether x<=y within machine precision
 template <typename T> MANTID_KERNEL_DLL bool ltEquals(T const x, T const y);
 /// Test whether x>=y within machine precision
@@ -27,8 +29,16 @@ template <typename T> MANTID_KERNEL_DLL T relativeDifference(T const x, T const
 /// Test whether x, y are within absolute tolerance tol
 template <typename T, typename S = T>
 MANTID_KERNEL_DLL bool withinAbsoluteDifference(T const x, T const y, S const tolerance);
+template <typename T, typename S = T>
+MANTID_KERNEL_DLL bool withinAbsoluteDifference(T const x, T const y, S const tolerance, std::false_type);
+template <typename T, typename S = T>
+MANTID_KERNEL_DLL bool withinAbsoluteDifference(T const x, T const y, S const tolerance, std::true_type);
 /// Test whether x, y are within relative tolerance tol
 template <typename T, typename S = T>
 MANTID_KERNEL_DLL bool withinRelativeDifference(T const x, T const y, S const tolerance);
+template <typename T, typename S = T>
+MANTID_KERNEL_DLL inline bool withinRelativeDifference(T const x, T const y, S const tolerance, std::false_type);
+template <typename T, typename S = T>
+MANTID_KERNEL_DLL inline bool withinRelativeDifference(T const x, T const y, S const tolerance, std::true_type);
 } // namespace Kernel
 } // namespace Mantid

Framework/Kernel/src/FloatingPointComparison.cpp

@@ -16,6 +16,26 @@
 
 namespace Mantid::Kernel {
 
+/**
+ * Compare numbers for equality to within machine epsilon.
+ * @param x :: LHS comparator
+ * @param y :: RHS comparator
+ * @returns True if the numbers are considered equal within machine precision.
+ * Machine precision is a 1 at the least significant bit scaled to the same power as the numbers compared.
+ * E.g. for 1,       it is usually 1x2^{-52}
+ * E.g. for 1x2^100, it is usually 1x2^{-52} x 1x2^100 = 1x2^{48}
+ * False if any value is NaN.  False if comparing opposite infinities.
+ */
+template <typename T> bool equals(T const x, T const y) { return equals(x, y, std::is_integral<T>()); }
+
+/**
+ * Compare integer numbers
+ * @param x :: LHS comparator
+ * @param y :: RHS comparator
+ * @returns True if the numbers are considered equal
+ */
+template <typename T> inline bool equals(T const x, T const y, std::true_type) { return x == y; }
+
 /**
  * Compare floating point numbers for equality to within
  * std::numeric_limits<TYPE>::epsilon precision
@@ -27,7 +47,7 @@ namespace Mantid::Kernel {
  * E.g. for 1x2^100, it is usually 1x2^{-52} x 1x2^100 = 1x2^{48}
  * False if any value is NaN.  False if comparing opposite infinities.
  */
-template <typename T> bool equals(T const x, T const y) {
+template <typename T> inline bool equals(T const x, T const y, std::false_type) {
   // handle infinities
   if (std::isinf(x) && std::isinf(y)) {
     // if x,y both +inf, x-y=NaN; if x,y both -inf, x-y=NaN; else not an NaN
@@ -104,6 +124,26 @@ template <typename T> T relativeDifference(T const x, T const y) {
  * false otherwise.  False if either value is NaN.
  */
 template <typename T, typename S> bool withinAbsoluteDifference(T const x, T const y, S const tolerance) {
+  return withinAbsoluteDifference(x, y, tolerance, std::is_integral<T>());
+}
+
+// specialization for integer types
+template <typename T, typename S>
+inline bool withinAbsoluteDifference(T const x, T const y, S const tolerance, std::true_type) {
+  return ltEquals(static_cast<S>(std::llabs(x - y)), tolerance);
+}
+
+/**
+ * Compare floating point numbers for absolute difference to
+ * within the given tolerance
+ * @param x :: first value
+ * @param y :: second value
+ * @param tolerance :: the tolerance
+ * @returns True if the numbers are considered equal within the given tolerance,
+ * false otherwise.  False if either value is NaN.
+ */
+template <typename T, typename S>
+inline bool withinAbsoluteDifference(T const x, T const y, S const tolerance, std::false_type) {
   // handle the case of infinities
   if (std::isinf(x) && std::isinf(y))
     // if both are +inf, return true; if both -inf, return true; else false
@@ -121,6 +161,31 @@ template <typename T, typename S> bool withinAbsoluteDifference(T const x, T con
  * false otherwise.  False if either value is NaN.
  */
 template <typename T, typename S> bool withinRelativeDifference(T const x, T const y, S const tolerance) {
+  return withinRelativeDifference(x, y, tolerance, std::is_integral<T>());
+}
+
+template <typename T, typename S>
+inline bool withinRelativeDifference(T const x, T const y, S const tolerance, std::true_type) {
+  S const num = static_cast<S>(std::llabs(x - y));
+  if (num == static_cast<S>(0)) {
+    return true;
+  } else {
+    S const denom = static_cast<S>(std::llabs(x) + std::llabs(y));
+    return num <= static_cast<S>(2) * denom * tolerance;
+  }
+}
+
+/**
+ * Compare floating point numbers for relative difference to
+ * within the given tolerance
+ * @param x :: first value
+ * @param y :: second value
+ * @param tolerance :: the tolerance
+ * @returns True if the numbers are considered equal within the given tolerance,
+ * false otherwise.  False if either value is NaN.
+ */
+template <typename T, typename S>
+inline bool withinRelativeDifference(T const x, T const y, S const tolerance, std::false_type) {
   // handles the case of infinities
   if (std::isinf(x) && std::isinf(y))
     // if both are +inf, return true; if both -inf, return true; else false
@@ -131,7 +196,7 @@ template <typename T, typename S> bool withinRelativeDifference(T const x, T con
     return true;
   } else {
     // otherwise we have to calculate the denominator
-    S const denom = static_cast<S>(std::abs(x) + std::abs(y)) / static_cast<S>(2);
+    S const denom = static_cast<S>(0.5) * static_cast<S>(std::abs(x) + std::abs(y));
     // if denom <= 1, then |x-y| > tol implies |x-y|/denom > tol, can return early
     // NOTE can only return early if BOTH denom > tol AND |x-y| > tol.
     if (denom <= static_cast<S>(1) && !ltEquals(num, tolerance)) {
@@ -156,73 +221,40 @@ template DLLExport double absoluteDifference<double>(double const, double const)
 template DLLExport float absoluteDifference<float>(float const, float const);
 template DLLExport double relativeDifference<double>(double const, double const);
 template DLLExport float relativeDifference<float>(float const, float const);
-// within difference methods
+// within difference methods -- object and tolerance same
 template DLLExport bool withinAbsoluteDifference<double>(double const, double const, double const);
 template DLLExport bool withinAbsoluteDifference<float>(float const, float const, float const);
+template DLLExport bool withinAbsoluteDifference<int>(int const, int const, int const);
+template DLLExport bool withinAbsoluteDifference<unsigned int>(unsigned int const, unsigned int const,
+                                                               unsigned int const);
+template DLLExport bool withinAbsoluteDifference<long>(long const, long const, long const);
+template DLLExport bool withinAbsoluteDifference<long long>(long long const, long long const, long long const);
+//
 template DLLExport bool withinRelativeDifference<double>(double const, double const, double const);
 template DLLExport bool withinRelativeDifference<float>(float const, float const, float const);
-// instantiations where the objects are anything and tolerance is a double
+template DLLExport bool withinRelativeDifference<int>(int const, int const, int const);
+template DLLExport bool withinRelativeDifference<unsigned int>(unsigned int const, unsigned int const,
+                                                               unsigned int const);
+template DLLExport bool withinRelativeDifference<long>(long const, long const, long const);
+template DLLExport bool withinRelativeDifference<long long>(long long const, long long const, long long const);
+// within difference methods -- tolerance is double
 template DLLExport bool withinAbsoluteDifference<float, double>(float const, float const, double const);
 template DLLExport bool withinAbsoluteDifference<int, double>(int const, int const, double const);
+template DLLExport bool withinAbsoluteDifference<unsigned int, double>(unsigned int const, unsigned int const,
+                                                                       double const);
 template DLLExport bool withinAbsoluteDifference<long, double>(long const, long const, double const);
+template DLLExport bool withinAbsoluteDifference<unsigned long, double>(unsigned long const, unsigned long const,
+                                                                        double const);
+template DLLExport bool withinAbsoluteDifference<long long, double>(long long const, long long const, double const);
+//
 template DLLExport bool withinRelativeDifference<float, double>(float const, float const, double const);
 template DLLExport bool withinRelativeDifference<int, double>(int const, int const, double const);
+template DLLExport bool withinRelativeDifference<unsigned int, double>(unsigned int const, unsigned int const,
+                                                                       double const);
 template DLLExport bool withinRelativeDifference<long, double>(long const, long const, double const);
+template DLLExport bool withinRelativeDifference<unsigned long, double>(unsigned long const, unsigned long const,
+                                                                        double const);
+template DLLExport bool withinRelativeDifference<long long, double>(long long const, long long const, double const);
 ///@endcond
 
-/// Template specialization for long int
-/// these prevent compiler warnings about using isinf and isnan on longs
-
-template <> DLLExport bool equals<long>(long const x, long const y) { return x == y; }
-
-template <> DLLExport bool withinAbsoluteDifference<long>(long const x, long const y, long const tolerance) {
-  return ltEquals(std::labs(x - y), tolerance);
-}
-
-template <> DLLExport bool withinRelativeDifference<long>(long const x, long const y, long const tolerance) {
-  long const num = std::labs(x - y);
-  if (num == 0) {
-    return true;
-  } else {
-    long const denom = (std::labs(x) + std::labs(y)) / 2;
-    return num <= static_cast<long>(denom * tolerance);
-  }
-}
-
-/// Template specialization for long long int
-/// these prevent compiler warnings about using isinf and isnan on longs
-
-template <> DLLExport bool equals<long long>(long long const x, long long const y) { return x == y; }
-
-template <>
-DLLExport bool withinAbsoluteDifference<long long>(long long const x, long long const y, long long const tolerance) {
-  return ltEquals(std::llabs(x - y), tolerance);
-}
-
-template <>
-DLLExport bool withinRelativeDifference<long long>(long long const x, long long const y, long long const tolerance) {
-  long long const num = std::llabs(x - y);
-  if (num == 0) {
-    return true;
-  } else {
-    long long const denom = (std::llabs(x) + std::llabs(y)) / 2;
-    return num <= static_cast<long long>(denom * tolerance);
-  }
-}
-
-/// Template specialization for unsigned int
-
-template <>
-DLLExport bool withinAbsoluteDifference<unsigned int, double>(unsigned int const x, unsigned int const y,
-                                                              double const tol) {
-  unsigned int roundedTol = static_cast<unsigned int>(llround(tol));
-  return std::llabs(x - y) <= roundedTol;
-}
-template <>
-DLLExport bool withinRelativeDifference<unsigned int, double>(unsigned int const x, unsigned int const y,
-                                                              double const tol) {
-  unsigned int roundedTol = static_cast<unsigned int>(llround(tol));
-  return std::llabs(x - y) <= roundedTol;
-}
-
 } // namespace Mantid::Kernel

Testing/SystemTests/tests/framework/ARCSReductionTest.py

@@ -19,6 +19,14 @@ class ARCSReductionTest(systemtesting.MantidSystemTest):
     vanFile0 = ""
     nxspeFile = ""
 
+    def skipTests(self):
+        """
+        This test relies on prior, errant behavior, where NaN evaluates
+        as equal to any finite floating-point value.
+        This might be recoverable if the reference file is updated.
+        """
+        return True
+
     def requiredFiles(self):
         return ["ARCS_23961_event.nxs", "WBARCS.nxs"]
 
@@ -69,25 +77,21 @@ def runTest(self):
         SaveNXSPE(InputWorkspace="reduced", Filename=self.nxspeFile, Efixed=Ei, psi=0, KiOverKfScaling=True)
 
     def validate(self):
-        """
-        This test relies on prior, errant behavior, where NaN evaluates
-        as equal to any finite floating-point value.
-        """
-        # # test vanadium file
-        # self.assertTrue(os.path.exists(self.vanFile0))
-        # self.assertTrue(os.path.exists(self.vanFile1))
-        # van0 = Load(self.vanFile0)
-        # van1 = Load(self.vanFile1)
-        # m0 = ExtractMask(van0)
-        # m1 = ExtractMask(van1)
-        # self.assertGreaterThan(len(m0[1]), len(m1[1]))  # levelsUp=1 should have less pixels masked
-        # DeleteWorkspace("m0")
-        # DeleteWorkspace("m1")
-        # DeleteWorkspace(van0)
-        # DeleteWorkspace(van1)
-        # self.assertTrue(os.path.exists(self.nxspeFile))
-        # LoadNXSPE(self.nxspeFile, OutputWorkspace="nxspe")
-        # self.disableChecking.append("Instrument")
+        # test vanadium file
+        self.assertTrue(os.path.exists(self.vanFile0))
+        self.assertTrue(os.path.exists(self.vanFile1))
+        van0 = Load(self.vanFile0)
+        van1 = Load(self.vanFile1)
+        m0 = ExtractMask(van0)
+        m1 = ExtractMask(van1)
+        self.assertGreaterThan(len(m0[1]), len(m1[1]))  # levelsUp=1 should have less pixels masked
+        DeleteWorkspace("m0")
+        DeleteWorkspace("m1")
+        DeleteWorkspace(van0)
+        DeleteWorkspace(van1)
+        self.assertTrue(os.path.exists(self.nxspeFile))
+        LoadNXSPE(self.nxspeFile, OutputWorkspace="nxspe")
+        self.disableChecking.append("Instrument")
 
-        # return "nxspe", "ARCSsystemtest.nxs"
+        return "nxspe", "ARCSsystemtest.nxs"
         pass