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

Include bool, integral, and floating-point support

Refactored `itk::Math::abs` to use `std::enable_if_t` for type constraints,
supporting both integral and floating-point types. Improved compile-time
evaluation with `constexpr`. Enhanced test coverage for `itk::Math::abs`.

Author: hjmjohnson

Modules/Core/Common/include/itkMath.h

@@ -30,6 +30,7 @@
 
 #include <cassert>
 #include <cmath>
+#include <type_traits>
 #include "itkMathDetail.h"
 #include "itkConceptChecking.h"
 #include <vnl/vnl_math.h>
@@ -825,55 +826,48 @@ 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.
+in ITK.  Replacing the vnl_math::abs operations with
+c++17 equivalent implementations can provide compile time
+performance improvements.
 */
-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)
+
+
+constexpr bool
+abs(bool x) noexcept
 {
   return x;
 }
-inline unsigned long
-abs(unsigned long x)
+
+template <typename T, typename = std::enable_if_t<std::is_integral_v<T>>>
+constexpr std::make_unsigned_t<T>
+abs(T x) noexcept
 {
-  return x;
+  if constexpr (std::is_unsigned_v<T>)
+  {
+    return x;
+  }
+  else
+  {
+    if constexpr (sizeof(T) <= sizeof(int))
+    {
+      // Using unsigned int instead of std::make_unsigned_t<T>
+      // to avoid potential overflow when T is a signed char (value -128).
+      // Note that -(-128) is still -128 for an 8-bit signed char.
+      return static_cast<std::make_unsigned_t<T>>(x < 0 ? static_cast<unsigned int>(-static_cast<int>(x))
+                                                        : static_cast<unsigned int>(x));
+    }
+    else
+    {
+      return x < 0 ? static_cast<std::make_unsigned_t<T>>(-x) : static_cast<std::make_unsigned_t<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)
+
+template <typename T, typename = std::enable_if_t<std::is_floating_point_v<T>>>
+constexpr T
+abs(T x) noexcept
 {
-  return x;
+  return x < 0 ? -x : x;
 }
 
 using std::abs;

Modules/Core/Common/test/itkMathTest.cxx

@@ -853,6 +853,34 @@ 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;
+  static_assert(itk::Math::abs(false) == false);
+  static_assert(itk::Math::abs(true) == true);
+  static_assert(itk::Math::abs((unsigned char)5) == 5);
+  static_assert(itk::Math::abs((signed char)-5) == 5);
+  static_assert(itk::Math::abs((signed char)-128) == 128);
+  static_assert(itk::Math::abs((short)-5) == 5);
+  // Specify template arguments to avoid choosing non-constexpr std::abs overloads
+  static_assert(itk::Math::abs<int>(-5) == 5u);
+  static_assert(itk::Math::abs<long>(-5L) == 5ul);
+  static_assert(itk::Math::abs<long long>(-5LL) == 5ull);
+
+  static_assert(itk::Math::abs<double>(-5.0) == 5.0);
+  static_assert(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;
 }