Merge pull request InsightSoftwareConsortium#5797 from InsightSoftwareConsortium/constexpr-math-operations

ENH: Add constexpr overloads for `itk::Math::abs`

Author: hjmjohnson

Modules/Core/Common/include/itkMath.h

@@ -29,7 +29,9 @@
 #define itkMath_h
 
 #include <cassert>
+#include <complex>
 #include <cmath>
+#include <type_traits>
 #include "itkMathDetail.h"
 #include "itkConceptChecking.h"
 #include <vnl/vnl_math.h>
@@ -823,60 +825,104 @@ using vnl_math::cube;
 using vnl_math::squared_magnitude;
 
 
-/*============================================
-Decouple dependence and exposure of vnl_math::abs operations
-in ITK.  Placing this small amount of duplicate vnl_math
-code directly in ITK removes backward compatibility
-issues with system installed VXL versions.
-*/
-inline bool
-abs(bool x)
-{
-  return x;
-}
-inline unsigned char
-abs(unsigned char x)
-{
-  return x;
-}
-inline unsigned char
-abs(signed char x)
-{
-  return x < 0 ? static_cast<unsigned char>(-x) : x;
-}
-inline unsigned char
-abs(char x)
-{
-  return static_cast<unsigned char>(x);
-}
-inline unsigned short
-abs(short x)
-{
-  return x < 0 ? static_cast<unsigned short>(-x) : x;
-}
-inline unsigned short
-abs(unsigned short x)
-{
-  return x;
-}
-inline unsigned int
-abs(unsigned int x)
+/**
+ * @brief Returns the absolute value of a number.
+ *
+ * This function provides a c++17 implementation of the vnl_math::abs absolute value functionality.
+ * safe_abs preserves backward compatibility with vnl_math::abs that was originally used in ITK.
+ *
+ * Where std::abs returns the absolute value in the same type as the input, itk::safe_abs
+ * returns the absolute value in the unsigned equivalent of the input type.
+ *
+ * @tparam T The type of the input number.
+ * @param x The input number.
+ * @return The absolute value of the input number as an unsigned type for integer types.
+ */
+template <typename T>
+constexpr auto
+safe_abs(T x) noexcept
 {
-  return x;
+  if constexpr (std::is_same_v<T, bool>)
+  {
+    // std::abs does not provide abs for bool, but ITK depends on bool support for abs.
+    return x;
+  }
+  else if constexpr (std::is_integral_v<T>)
+  {
+    if constexpr (std::is_signed_v<T>)
+    {
+      // Using promotion to std::int32_t instead of std::make_unsigned_t<T>
+      // to avoid potential overflow when T is a signed 8bit minimum (value -128)
+      // or signed 15 bit minimum (value -32768).
+      // Note that -(-128) is still -128 for an 8-bit signed char.
+      if constexpr (sizeof(T) <= sizeof(int))
+      {
+#if __cplusplus >= 202302L
+        return static_cast<std::make_unsigned_t<T>>(std::abs(static_cast<int>(x)));
+#else
+        return static_cast<std::make_unsigned_t<T>>((x < T(0)) ? -x : x);
+#endif
+      }
+      else if constexpr (sizeof(T) <= sizeof(long int))
+      {
+#if __cplusplus >= 202302L
+        return static_cast<std::make_unsigned_t<T>>(std::abs(static_cast<long int>(x)));
+#else
+        return static_cast<std::make_unsigned_t<T>>((x < T(0)) ? -x : x);
+#endif
+      }
+      else if constexpr (sizeof(T) == sizeof(long long int))
+      {
+        // NOTE: overflow is not resolved if LONG_LONG_INT_MIN value is converted
+#if __cplusplus >= 202302L
+        return static_cast<std::make_unsigned_t<T>>(std::abs(static_cast<long long int>(x)));
+#else
+        return static_cast<std::make_unsigned_t<T>>((x < T(0)) ? -x : x);
+#endif
+      }
+    }
+    else
+    { // In C++17, the std::abs() integer overloads are only for : int, long, and long long.
+      // unsigned type values std::abs() are supported through implicit type conversions to
+      // the next larger sized integer type.  The 'unsigned long long' failed due to an
+      // lack of larger sized signed integer type to be promoted to.
+      // type of x  | default std::abs() called
+      // uint8_t    | std::abs( (int32_t) x)
+      // uint16_t   | std::abs( (int32_t) x)
+      // uint32_t   | std::abs( (int64_t) x)
+      // uint64_t   | // compiler error
+      // This explicit override provides direct support for all unsigned integer types with type promotion.
+      return x;
+    }
+  }
+  else if constexpr (std::is_floating_point_v<T>) // floating point or complex<> types
+  {                                               // floating point std::abs is constexpr in c++23 and later
+#if __cplusplus >= 202302L
+    return std::abs(x);
+#else
+    return (x < 0) ? -x : x;
+#endif
+  }
 }
-inline unsigned long
-abs(unsigned long x)
+template <typename T>
+auto
+safe_abs(const std::complex<T> & x) noexcept
 {
-  return x;
+  // std::abs<T>(std::complex<T>) is not constexpr in in any proposed c++ standard
+  return std::abs<T>(x);
 }
-// long long - target type will have width of at least 64 bits. (since C++11)
-inline unsigned long long
-abs(unsigned long long x)
+
+
+// itk::Math::abs has different behavior than std::abs.  The use of
+// abs() in the ITK context without namespace resolution can be confusing
+// The abs() version is provided for backwards compatibility.
+template <typename T>
+auto
+abs(T x) noexcept
 {
-  return x;
+  return safe_abs(x);
 }
 
-using std::abs;
 
 } // namespace itk::Math
 

Modules/Core/Common/test/itkMathTest.cxx

@@ -853,6 +853,65 @@ main(int, char *[])
     std::cout << "Test passed" << std::endl;
   }
 
+  // Test the itk::Math::abs methods
+  std::cout << "Testing itk::Math::abs integral overloads" << std::endl;
+  // Specify template arguments to avoid choosing non-constexpr std::abs overloads
+  static_assert(itk::Math::safe_abs(false) == false);
+  static_assert(itk::Math::safe_abs(true) == true);
+  static_assert(itk::Math::safe_abs((unsigned char)5) == 5);
+  static_assert(itk::Math::safe_abs((unsigned short)5) == 5);
+  static_assert(itk::Math::safe_abs((unsigned int)5) == 5);
+  static_assert(itk::Math::safe_abs((unsigned long)5) == 5);
+  static_assert(itk::Math::safe_abs((unsigned long long)5) == 5);
+
+  static_assert(itk::Math::safe_abs((signed char)-5) == 5);
+  static_assert(itk::Math::safe_abs((signed char)-128) == 128);
+
+  static_assert(itk::Math::safe_abs((short)-5) == 5);
+
+  static_assert(itk::Math::safe_abs<int>(-5) == 5u);
+  static_assert(itk::Math::safe_abs<long>(-5L) == 5ul);
+  static_assert(itk::Math::safe_abs<long long>(-5LL) == 5ull);
+
+  static_assert(itk::Math::safe_abs<double>(-5.0) == 5.0);
+  static_assert(itk::Math::safe_abs<float>(-5.0f) == 5.0f);
+
+  // complex types are never constexpr for abs or safe_abs
+  const auto cf = std::complex<float>(-3, -4);
+  ITK_TEST_EXPECT_EQUAL(itk::Math::safe_abs(cf), 5);
+  const auto cd = std::complex<double>(-3, -4);
+  ITK_TEST_EXPECT_EQUAL(itk::Math::safe_abs(cd), 5);
+  const auto cld = std::complex<long double>(-3, -4);
+  ITK_TEST_EXPECT_EQUAL(itk::Math::safe_abs(cld), 5);
+
+  // test backward compatible non-constexpr abs function
+  ITK_TEST_EXPECT_EQUAL(itk::Math::abs(false), false);
+  ITK_TEST_EXPECT_EQUAL(itk::Math::abs(true), true);
+  ITK_TEST_EXPECT_EQUAL(itk::Math::abs((unsigned char)5), 5);
+  ITK_TEST_EXPECT_EQUAL(itk::Math::abs((signed char)-5), 5);
+  ITK_TEST_EXPECT_EQUAL(itk::Math::abs((signed char)-128), 128);
+  ITK_TEST_EXPECT_EQUAL(itk::Math::abs((short)-5), 5);
+  // Specify template arguments to avoid choosing non-constexpr std::abs overloads
+  ITK_TEST_EXPECT_EQUAL(itk::Math::abs<int>(-5), 5u);
+  ITK_TEST_EXPECT_EQUAL(itk::Math::abs<long>(-5L), 5ul);
+  ITK_TEST_EXPECT_EQUAL(itk::Math::abs<long long>(-5LL), 5ull);
+
+  ITK_TEST_EXPECT_EQUAL(itk::Math::abs<double>(-5.0), 5.0);
+  ITK_TEST_EXPECT_EQUAL(itk::Math::abs<float>(-5.0f), 5.0f);
+
+
+  if (itk::Math::abs((signed char)-128) != 128)
+  {
+    std::cout << "itk::Math::abs((signed char)-128) FAILED!" << std::endl;
+    testPassStatus = EXIT_FAILURE;
+  }
+
+  if (itk::Math::abs(-5) != 5)
+  {
+    std::cout << "itk::Math::abs(-5) FAILED!" << std::endl;
+    testPassStatus = EXIT_FAILURE;
+  }
+
 
   return testPassStatus;
 }