Fix compiler warnings and errors related to recent changes (bug #67714)

* Change all instances of former 'abs' (replaced by 'mapper_abs') to 'std::abs'
everywhere expect for the 'intNDArray' path.

* Replace 'abs' with 'std::abs' in the 'mapper_abs' function to avoid clang
compiler warnings and possible truncation of long long integers.

* Add integer-specific functions for min/max and cummin/cummaxin in
'mx-inlines.cc' that do not have a nanflag path for speed improvement.

The following files are changed:

* intNDArray.cc : Add unused flag for nanflag argument and only forward the
                  comparison method to the min/max and cummin/cummax ops.

* mappers.h : Replace mapper_abs with std::abs on non-integer paths.

* mx_inlines.cc (mx_inline_int*) : New *min/max/cummin/cummax functions.

Author: pr0m1th3as

liboctave/array/intNDArray.cc

@@ -261,66 +261,62 @@ intNDArray<T>::sumsq (int dim) const
 
 template <typename T>
 intNDArray<T>
-intNDArray<T>::max (int dim, bool nanflag, bool realabs) const
+intNDArray<T>::max (int dim, [[maybe_unused]] bool nanflag, bool realabs) const
 {
-  return do_mx_minmax_op<T> (*this, dim, nanflag, realabs, mx_inline_max);
+  return do_mx_minmax_op<T> (*this, dim, realabs, mx_inline_intmax);
 }
 
 template <typename T>
 intNDArray<T>
 intNDArray<T>::max (Array<octave_idx_type>& idx_arg,
-                    int dim, bool nanflag, bool realabs) const
+                    int dim, [[maybe_unused]] bool nanflag, bool realabs) const
 {
-  return do_mx_minmax_op<T> (*this, idx_arg, dim,
-                             nanflag, realabs, mx_inline_max);
+  return do_mx_minmax_op<T> (*this, idx_arg, dim, realabs, mx_inline_intmax);
 }
 
 template <typename T>
 intNDArray<T>
-intNDArray<T>::min (int dim, bool nanflag, bool realabs) const
+intNDArray<T>::min (int dim, [[maybe_unused]] bool nanflag, bool realabs) const
 {
-  return do_mx_minmax_op<T> (*this, dim, nanflag, realabs, mx_inline_min);
+  return do_mx_minmax_op<T> (*this, dim, realabs, mx_inline_intmin);
 }
 
 template <typename T>
 intNDArray<T>
 intNDArray<T>::min (Array<octave_idx_type>& idx_arg,
-                    int dim, bool nanflag, bool realabs) const
+                    int dim, [[maybe_unused]] bool nanflag, bool realabs) const
 {
-  return do_mx_minmax_op<T> (*this, idx_arg, dim,
-                             nanflag, realabs, mx_inline_min);
+  return do_mx_minmax_op<T> (*this, idx_arg, dim, realabs, mx_inline_intmin);
 }
 
 template <typename T>
 intNDArray<T>
-intNDArray<T>::cummax (int dim, bool nanflag, bool realabs) const
+intNDArray<T>::cummax (int dim, [[maybe_unused]] bool nanflag, bool realabs) const
 {
-  return do_mx_cumminmax_op<T> (*this, dim, nanflag, realabs, mx_inline_cummax);
+  return do_mx_cumminmax_op<T> (*this, dim, realabs, mx_inline_intcummax);
 }
 
 template <typename T>
 intNDArray<T>
 intNDArray<T>::cummax (Array<octave_idx_type>& idx_arg,
-                       int dim, bool nanflag, bool realabs) const
+                       int dim, [[maybe_unused]] bool nanflag, bool realabs) const
 {
-  return do_mx_cumminmax_op<T> (*this, idx_arg, dim, nanflag,
-                                realabs, mx_inline_cummax);
+  return do_mx_cumminmax_op<T> (*this, idx_arg, dim, realabs, mx_inline_intcummax);
 }
 
 template <typename T>
 intNDArray<T>
-intNDArray<T>::cummin (int dim, bool nanflag, bool realabs) const
+intNDArray<T>::cummin (int dim, [[maybe_unused]] bool nanflag, bool realabs) const
 {
-  return do_mx_cumminmax_op<T> (*this, dim, nanflag, realabs, mx_inline_cummin);
+  return do_mx_cumminmax_op<T> (*this, dim, realabs, mx_inline_intcummin);
 }
 
 template <typename T>
 intNDArray<T>
 intNDArray<T>::cummin (Array<octave_idx_type>& idx_arg,
-                       int dim, bool nanflag, bool realabs) const
+                       int dim, [[maybe_unused]] bool nanflag, bool realabs) const
 {
-  return do_mx_cumminmax_op<T> (*this, idx_arg, dim, nanflag,
-                                realabs, mx_inline_cummin);
+  return do_mx_cumminmax_op<T> (*this, idx_arg, dim, realabs, mx_inline_intcummin);
 }
 
 template <typename T>

liboctave/numeric/mappers.h

@@ -38,22 +38,14 @@
 
 // Provides some commonly repeated, basic loop templates.
 
-template <typename T>
-inline auto mappers_abs (const T& x)
-{
-    if constexpr (std::is_unsigned_v<T>)
-        return x;  // abs doesn't make sense for unsigned types
-    else
-        return std::abs(x);
-}
 // Specialization for octave_int types
 template <typename T>
 inline auto mappers_abs (const octave_int<T>& x)
 {
     if constexpr (std::is_unsigned_v<T>)
         return x;  // abs doesn't make sense for unsigned types
     else
-        return abs(x.value());
+        return std::abs (x.value ());
 }
 
 
@@ -283,7 +275,7 @@ template <typename T>
 std::complex<T>
 signum (const std::complex<T>& x)
 {
-  T tmp = mappers_abs (x);
+  T tmp = std::abs (x);
 
   return tmp == 0 ? 0.0 : x / tmp;
 }
@@ -524,7 +516,8 @@ min (float x, float y, const bool nanflag, const bool realabs)
     out = isnan (y) ? x : (x <= y ? x : y);
   else
     out = isnan (y) ? x :
-          (std::abs (x) < std::abs (y) ? x : (std::abs (x) == std::abs (y) && x <= y ? x : y));
+          (std::abs (x) < std::abs (y) ? x :
+          (std::abs (x) == std::abs (y) && x <= y ? x : y));
   return out;
 }
 
@@ -538,22 +531,23 @@ max (float x, float y, const bool nanflag, const bool realabs)
     out = isnan (y) ? x : (x >= y ? x : y);
   else
     out = isnan (y) ? x :
-          (std::abs (x) > std::abs (y) ? x : (std::abs (x) == std::abs (y) && x >= y ? x : y));
+          (std::abs (x) > std::abs (y) ? x :
+          (std::abs (x) == std::abs (y) && x >= y ? x : y));
   return out;
 }
 
 inline std::complex<double>
 min (const std::complex<double>& x, const std::complex<double>& y)
 {
-  return isnan (y) ? x : (mappers_abs (x) < mappers_abs (y) ? x :
-         (mappers_abs (x) == mappers_abs (y) && std::arg (x) <= std::arg (y) ? x : y));
+  return isnan (y) ? x : (std::abs (x) < std::abs (y) ? x :
+         (std::abs (x) == std::abs (y) && std::arg (x) <= std::arg (y) ? x : y));
 }
 
 inline std::complex<double>
 max (const std::complex<double>& x, const std::complex<double>& y)
 {
-  return isnan (y) ? x : (mappers_abs (x) > mappers_abs (y) ? x :
-         (mappers_abs (x) == mappers_abs (y) && std::arg (x) >= std::arg (y) ? x : y));
+  return isnan (y) ? x : (std::abs (x) > std::abs (y) ? x :
+         (std::abs (x) == std::abs (y) && std::arg (x) >= std::arg (y) ? x : y));
 }
 
 inline std::complex<double>
@@ -564,8 +558,8 @@ min (const std::complex<double>& x, const std::complex<double>& y,
   if (! nanflag && (isnan (x) || isnan (y)))
     out = NAN;
   else
-    out = isnan (y) ? x : (mappers_abs (x) < mappers_abs (y) ? x :
-          (mappers_abs (x) == mappers_abs (y) && std::arg (x) <= std::arg (y) ? x : y));
+    out = isnan (y) ? x : (std::abs (x) < std::abs (y) ? x :
+          (std::abs (x) == std::abs (y) && std::arg (x) <= std::arg (y) ? x : y));
   return out;
 }
 
@@ -577,8 +571,8 @@ max (const std::complex<double>& x, const std::complex<double>& y,
   if (! nanflag && (isnan (x) || isnan (y)))
     out = NAN;
   else
-    out = isnan (y) ? x : (mappers_abs (x) > mappers_abs (y) ? x :
-          (mappers_abs (x) == mappers_abs (y) && std::arg (x) >= std::arg (y) ? x : y));
+    out = isnan (y) ? x : (std::abs (x) > std::abs (y) ? x :
+          (std::abs (x) == std::abs (y) && std::arg (x) >= std::arg (y) ? x : y));
   return out;
 }
 
@@ -594,8 +588,8 @@ min (const std::complex<double>& x, const std::complex<double>& y,
           (std::real (x) == std::real (y) &&
            std::imag (x) <= std::imag (y) ? x : y));
   else
-    out = isnan (y) ? x : (mappers_abs (x) < mappers_abs (y) ? x :
-          (mappers_abs (x) == mappers_abs (y) && std::arg (x) <= std::arg (y) ? x : y));
+    out = isnan (y) ? x : (std::abs (x) < std::abs (y) ? x :
+          (std::abs (x) == std::abs (y) && std::arg (x) <= std::arg (y) ? x : y));
   return out;
 }
 
@@ -611,23 +605,23 @@ max (const std::complex<double>& x, const std::complex<double>& y,
           (std::real (x) == std::real (y) &&
            std::imag (x) >= std::imag (y) ? x : y));
   else
-    out = isnan (y) ? x : (mappers_abs (x) > mappers_abs (y) ? x :
-          (mappers_abs (x) == mappers_abs (y) && std::arg (x) >= std::arg (y) ? x : y));
+    out = isnan (y) ? x : (std::abs (x) > std::abs (y) ? x :
+          (std::abs (x) == std::abs (y) && std::arg (x) >= std::arg (y) ? x : y));
   return out;
 }
 
 inline std::complex<float>
 min (const std::complex<float>& x, const std::complex<float>& y)
 {
   return isnan (y) ? x : (abs (x) < abs (y) ? x :
-         (mappers_abs (x) == mappers_abs (y) && std::arg (x) <= std::arg (y) ? x : y));
+         (std::abs (x) == std::abs (y) && std::arg (x) <= std::arg (y) ? x : y));
 }
 
 inline std::complex<float>
 max (const std::complex<float>& x, const std::complex<float>& y)
 {
   return isnan (y) ? x : (abs (x) > abs (y) ? x :
-         (mappers_abs (x) == mappers_abs (y) && std::arg (x) >= std::arg (y) ? x : y));
+         (std::abs (x) == std::abs (y) && std::arg (x) >= std::arg (y) ? x : y));
 }
 
 inline std::complex<float>
@@ -638,8 +632,8 @@ min (const std::complex<float>& x, const std::complex<float>& y,
   if (! nanflag && (isnan (x) || isnan (y)))
     out = NAN;
   else
-    out = isnan (y) ? x : (mappers_abs (x) < mappers_abs (y) ? x :
-          (mappers_abs (x) == mappers_abs (y) && std::arg (x) <= std::arg (y) ? x : y));
+    out = isnan (y) ? x : (std::abs (x) < std::abs (y) ? x :
+          (std::abs (x) == std::abs (y) && std::arg (x) <= std::arg (y) ? x : y));
   return out;
 }
 
@@ -651,8 +645,8 @@ max (const std::complex<float>& x, const std::complex<float>& y,
   if (! nanflag && (isnan (x) || isnan (y)))
     out = NAN;
   else
-    out = isnan (y) ? x : (mappers_abs (x) > mappers_abs (y) ? x :
-          (mappers_abs (x) == mappers_abs (y) && std::arg (x) >= std::arg (y) ? x : y));
+    out = isnan (y) ? x : (std::abs (x) > std::abs (y) ? x :
+          (std::abs (x) == std::abs (y) && std::arg (x) >= std::arg (y) ? x : y));
   return out;
 }
 
@@ -668,8 +662,8 @@ min (const std::complex<float>& x, const std::complex<float>& y,
           (std::real (x) == std::real (y) &&
            std::imag (x) <= std::imag (y) ? x : y));
   else
-    out = isnan (y) ? x : (mappers_abs (x) < mappers_abs (y) ? x :
-          (mappers_abs (x) == mappers_abs (y) && std::arg (x) <= std::arg (y) ? x : y));
+    out = isnan (y) ? x : (std::abs (x) < std::abs (y) ? x :
+          (std::abs (x) == std::abs (y) && std::arg (x) <= std::arg (y) ? x : y));
   return out;
 }
 
@@ -685,8 +679,8 @@ max (const std::complex<float>& x, const std::complex<float>& y,
           (std::real (x) == std::real (y) &&
            std::imag (x) >= std::imag (y) ? x : y));
   else
-    out = isnan (y) ? x : (mappers_abs (x) > mappers_abs (y) ? x :
-          (mappers_abs (x) == mappers_abs (y) && std::arg (x) >= std::arg (y) ? x : y));
+    out = isnan (y) ? x : (std::abs (x) > std::abs (y) ? x :
+          (std::abs (x) == std::abs (y) && std::arg (x) >= std::arg (y) ? x : y));
   return out;
 }
 
@@ -729,8 +723,8 @@ min (const octave_int<T>& x, const octave_int<T>& y,
   if (realabs)
     out = x.value () <= y.value () ? x : y;
   else
-    out = mappers_abs (x.value ()) < mappers_abs (y.value ()) ? x :
-          (mappers_abs (x.value ()) == mappers_abs (y.value ()) &&
+    out = mappers_abs (x) < mappers_abs (y) ? x :
+          (mappers_abs (x) == mappers_abs (y) &&
            x.value () <= y.value () ? x : y);
   return out;
 }
@@ -744,8 +738,8 @@ max (const octave_int<T>& x, const octave_int<T>& y,
   if (realabs)
     out = x.value () >= y.value () ? x : y;
   else
-    out = mappers_abs (x.value ()) > mappers_abs (y.value ()) ? x :
-          (mappers_abs (x.value ()) == mappers_abs (y.value ()) &&
+    out = mappers_abs (x) > mappers_abs (y) ? x :
+          (mappers_abs (x) == mappers_abs (y) &&
            x.value () >= y.value () ? x : y);
   return out;
 }