--- a/liboctave/numeric/lo-mappers.h	Thu Dec 01 14:23:45 2022 -0800
+++ b/liboctave/numeric/lo-mappers.h	Thu Dec 01 18:02:15 2022 -0800
@@ -40,427 +40,427 @@
 
 OCTAVE_BEGIN_NAMESPACE(math)
 
-    extern OCTAVE_API bool isna (double x);
-    extern OCTAVE_API bool isna (float x);
-    extern OCTAVE_API bool isna (const Complex& x);
-    extern OCTAVE_API bool isna (const FloatComplex& x);
+extern OCTAVE_API bool isna (double x);
+extern OCTAVE_API bool isna (float x);
+extern OCTAVE_API bool isna (const Complex& x);
+extern OCTAVE_API bool isna (const FloatComplex& x);
 
-    extern OCTAVE_API bool is_NaN_or_NA (const Complex& x);
-    extern OCTAVE_API bool is_NaN_or_NA (const FloatComplex& x);
+extern OCTAVE_API bool is_NaN_or_NA (const Complex& x);
+extern OCTAVE_API bool is_NaN_or_NA (const FloatComplex& x);
 
-    inline double copysign (double x, double y) { return std::copysign (x, y); }
-    inline float copysign (float x, float y) { return std::copysignf (x, y); }
+inline double copysign (double x, double y) { return std::copysign (x, y); }
+inline float copysign (float x, float y) { return std::copysignf (x, y); }
+
+inline double signbit (double x) { return std::signbit (x); }
+inline float signbit (float x) { return std::signbit (x); }
 
-    inline double signbit (double x) { return std::signbit (x); }
-    inline float signbit (float x) { return std::signbit (x); }
+// Test for negative sign.
+extern OCTAVE_API bool negative_sign (double x);
+extern OCTAVE_API bool negative_sign (float x);
+
+// Test for positive sign.
+inline bool positive_sign (double x) { return ! negative_sign (x); }
+inline bool positive_sign (float x) { return ! negative_sign (x); }
 
-    // Test for negative sign.
-    extern OCTAVE_API bool negative_sign (double x);
-    extern OCTAVE_API bool negative_sign (float x);
+extern OCTAVE_API Complex acos (const Complex& x);
+extern OCTAVE_API FloatComplex acos (const FloatComplex& x);
 
-    // Test for positive sign.
-    inline bool positive_sign (double x) { return ! negative_sign (x); }
-    inline bool positive_sign (float x) { return ! negative_sign (x); }
+extern OCTAVE_API Complex asin (const Complex& x);
+extern OCTAVE_API FloatComplex asin (const FloatComplex& x);
+
+inline Complex atan (const Complex& x) { return std::atan (x); }
+inline FloatComplex atan (const FloatComplex& x) { return std::atan (x); }
 
-    extern OCTAVE_API Complex acos (const Complex& x);
-    extern OCTAVE_API FloatComplex acos (const FloatComplex& x);
+// The C++ standard would normally return a std::complex value for conj
+// even when the input is fully real.  Octave overrides this.
+inline double conj (double x) { return x; }
+inline float conj (float x) { return x; }
 
-    extern OCTAVE_API Complex asin (const Complex& x);
-    extern OCTAVE_API FloatComplex asin (const FloatComplex& x);
+template <typename T>
+std::complex<T>
+conj (const std::complex<T>& x)
+{
+  return std::conj (x);
+}
 
-    inline Complex atan (const Complex& x) { return std::atan (x); }
-    inline FloatComplex atan (const FloatComplex& x) { return std::atan (x); }
+inline double log2 (double x) { return std::log2 (x); }
+inline float log2 (float x) { return std::log2f (x); }
 
-    // The C++ standard would normally return a std::complex value for conj
-    // even when the input is fully real.  Octave overrides this.
-    inline double conj (double x) { return x; }
-    inline float conj (float x) { return x; }
+extern OCTAVE_API Complex log2 (const Complex& x);
+extern OCTAVE_API FloatComplex log2 (const FloatComplex& x);
+
+extern OCTAVE_API double log2 (double x, int& exp);
+extern OCTAVE_API float log2 (float x, int& exp);
+
+extern OCTAVE_API Complex log2 (const Complex& x, int& exp);
+extern OCTAVE_API FloatComplex log2 (const FloatComplex& x, int& exp);
 
-    template <typename T>
-    std::complex<T>
-    conj (const std::complex<T>& x)
-    {
-      return std::conj (x);
-    }
+inline double exp2 (double x) { return std::exp2 (x); }
+inline float exp2 (float x) { return std::exp2f (x); }
 
-    inline double log2 (double x) { return std::log2 (x); }
-    inline float log2 (float x) { return std::log2f (x); }
-
-    extern OCTAVE_API Complex log2 (const Complex& x);
-    extern OCTAVE_API FloatComplex log2 (const FloatComplex& x);
+template <typename T>
+std::complex<T>
+ceil (const std::complex<T>& x)
+{
+  return std::complex<T> (std::ceil (std::real (x)),
+                          std::ceil (std::imag (x)));
+}
 
-    extern OCTAVE_API double log2 (double x, int& exp);
-    extern OCTAVE_API float log2 (float x, int& exp);
+template <typename T>
+std::complex<T>
+trunc (const std::complex<T>& x)
+{
+  return std::complex<T> (std::trunc (std::real (x)),
+                          std::trunc (std::imag (x)));
+}
 
-    extern OCTAVE_API Complex log2 (const Complex& x, int& exp);
-    extern OCTAVE_API FloatComplex log2 (const FloatComplex& x, int& exp);
-
-    inline double exp2 (double x) { return std::exp2 (x); }
-    inline float exp2 (float x) { return std::exp2f (x); }
+// Provide alias for trunc under the more familiar name of fix.
+inline double fix (double x) { return std::trunc (x); }
+inline float fix (float x) { return std::trunc (x); }
 
-    template <typename T>
-    std::complex<T>
-    ceil (const std::complex<T>& x)
-    {
-      return std::complex<T> (std::ceil (std::real (x)),
-                              std::ceil (std::imag (x)));
-    }
+template <typename T>
+std::complex<T>
+fix (const std::complex<T>& x)
+{
+  return trunc (x);
+}
 
-    template <typename T>
-    std::complex<T>
-    trunc (const std::complex<T>& x)
-    {
-      return std::complex<T> (std::trunc (std::real (x)),
-                              std::trunc (std::imag (x)));
-    }
+template <typename T>
+std::complex<T>
+floor (const std::complex<T>& x)
+{
+  return std::complex<T> (std::floor (std::real (x)),
+                          std::floor (std::imag (x)));
+}
+
+inline double round (double x) { return std::round (x); }
+inline float round (float x) { return std::roundf (x); }
 
-    // Provide alias for trunc under the more familiar name of fix.
-    inline double fix (double x) { return std::trunc (x); }
-    inline float fix (float x) { return std::trunc (x); }
+template <typename T>
+std::complex<T>
+round (const std::complex<T>& x)
+{
+  return std::complex<T> (round (std::real (x)), round (std::imag (x)));
+}
 
-    template <typename T>
-    std::complex<T>
-    fix (const std::complex<T>& x)
-    {
-      return trunc (x);
-    }
+inline double
+roundb (double x)
+{
+  double t = round (x);
+
+  if (fabs (x - t) == 0.5)
+    t = 2 * std::trunc (0.5 * t);
+
+  return t;
+}
 
-    template <typename T>
-    std::complex<T>
-    floor (const std::complex<T>& x)
-    {
-      return std::complex<T> (std::floor (std::real (x)),
-                              std::floor (std::imag (x)));
-    }
+inline float
+roundb (float x)
+{
+  float t = round (x);
+
+  if (fabsf (x - t) == 0.5f)
+    t = 2 * std::trunc (0.5f * t);
 
-    inline double round (double x) { return std::round (x); }
-    inline float round (float x) { return std::roundf (x); }
+  return t;
+}
 
-    template <typename T>
-    std::complex<T>
-    round (const std::complex<T>& x)
-    {
-      return std::complex<T> (round (std::real (x)), round (std::imag (x)));
-    }
+template <typename T>
+std::complex<T>
+roundb (const std::complex<T>& x)
+{
+  return std::complex<T> (roundb (std::real (x)), roundb (std::imag (x)));
+}
+
+extern OCTAVE_API double frexp (double x, int *expptr);
+extern OCTAVE_API float frexp (float x, int *expptr);
 
-    inline double
-    roundb (double x)
-    {
-      double t = round (x);
+inline bool isnan (bool) { return false; }
+inline bool isnan (char) { return false; }
+
+inline bool isnan (double x) { return std::isnan (x); }
+inline bool isnan (float x) { return std::isnan (x); }
 
-      if (fabs (x - t) == 0.5)
-        t = 2 * std::trunc (0.5 * t);
-
-      return t;
-    }
+// FIXME: Do we need the isnan overload for complex?
+template <typename T>
+bool
+isnan (const std::complex<T>& x)
+{
+  return (isnan (std::real (x)) || isnan (std::imag (x)));
+}
 
-    inline float
-    roundb (float x)
-    {
-      float t = round (x);
+inline bool isfinite (double x) { return std::isfinite (x); }
+inline bool isfinite (float x) { return std::isfinite (x); }
 
-      if (fabsf (x - t) == 0.5f)
-        t = 2 * std::trunc (0.5f * t);
+// FIXME: Do we need isfinite overload for complex?
+template <typename T>
+bool
+isfinite (const std::complex<T>& x)
+{
+  return (isfinite (std::real (x)) && isfinite (std::imag (x)));
+}
 
-      return t;
-    }
+inline bool isinf (double x) { return std::isinf (x); }
+inline bool isinf (float x) { return std::isinf (x); }
 
-    template <typename T>
-    std::complex<T>
-    roundb (const std::complex<T>& x)
-    {
-      return std::complex<T> (roundb (std::real (x)), roundb (std::imag (x)));
-    }
+template <typename T>
+bool
+isinf (const octave_int<T>&)
+{
+  return false;
+}
 
-    extern OCTAVE_API double frexp (double x, int *expptr);
-    extern OCTAVE_API float frexp (float x, int *expptr);
+// FIXME: Do we need isinf overload for complex?
+template <typename T>
+bool
+isinf (const std::complex<T>& x)
+{
+  return (isinf (std::real (x)) || isinf (std::imag (x)));
+}
 
-    inline bool isnan (bool) { return false; }
-    inline bool isnan (char) { return false; }
+// Some useful tests, that are commonly repeated.
+// Test for a finite integer.
 
-    inline bool isnan (double x) { return std::isnan (x); }
-    inline bool isnan (float x) { return std::isnan (x); }
+// FIXME: Benchmark whether trunc might be faster than round here.
+inline bool isinteger (double x) { return isfinite (x) && x == round (x); }
+inline bool isinteger (float x) { return isfinite (x) && x == round (x); }
+
+inline double
+signum (double x)
+{
+  double tmp = 0.0;
 
-    // FIXME: Do we need the isnan overload for complex?
-    template <typename T>
-    bool
-    isnan (const std::complex<T>& x)
-    {
-      return (isnan (std::real (x)) || isnan (std::imag (x)));
-    }
+  if (x < 0.0)
+    tmp = -1.0;
+  else if (x > 0.0)
+    tmp = 1.0;
 
-    inline bool isfinite (double x) { return std::isfinite (x); }
-    inline bool isfinite (float x) { return std::isfinite (x); }
+  return isnan (x) ? numeric_limits<double>::NaN () : tmp;
+}
+
+inline float
+signum (float x)
+{
+  float tmp = 0.0f;
 
-    // FIXME: Do we need isfinite overload for complex?
-    template <typename T>
-    bool
-    isfinite (const std::complex<T>& x)
-    {
-      return (isfinite (std::real (x)) && isfinite (std::imag (x)));
-    }
+  if (x < 0.0f)
+    tmp = -1.0f;
+  else if (x > 0.0f)
+    tmp = 1.0f;
+
+  return isnan (x) ? numeric_limits<float>::NaN () : tmp;
+}
 
-    inline bool isinf (double x) { return std::isinf (x); }
-    inline bool isinf (float x) { return std::isinf (x); }
+template <typename T>
+std::complex<T>
+signum (const std::complex<T>& x)
+{
+  T tmp = abs (x);
+
+  return tmp == 0 ? 0.0 : x / tmp;
+}
 
-    template <typename T>
-    bool
-    isinf (const octave_int<T>&)
-    {
-      return false;
-    }
+// Convert X to the nearest integer value.  Should not pass NaN to
+// this function.
 
-    // FIXME: Do we need isinf overload for complex?
-    template <typename T>
-    bool
-    isinf (const std::complex<T>& x)
-    {
-      return (isinf (std::real (x)) || isinf (std::imag (x)));
-    }
+// For integer types?  Hmm.  Need to be sure T is an integer type...
+template <typename T>
+T
+x_nint (T x)
+{
+  return x;
+}
 
-    // Some useful tests, that are commonly repeated.
-    // Test for a finite integer.
+template <>
+inline double x_nint (double x)
+{
+  return (isfinite (x) ? std::floor (x + 0.5) : x);
+}
 
-    // FIXME: Benchmark whether trunc might be faster than round here.
-    inline bool isinteger (double x) { return isfinite (x) && x == round (x); }
-    inline bool isinteger (float x) { return isfinite (x) && x == round (x); }
+template <>
+inline float x_nint (float x)
+{
+  return (isfinite (x) ? std::floor (x + 0.5f) : x);
+}
+
+extern OCTAVE_API octave_idx_type nint_big (double x);
+extern OCTAVE_API octave_idx_type nint_big (float x);
 
-    inline double
-    signum (double x)
-    {
-      double tmp = 0.0;
+extern OCTAVE_API int nint (double x);
+extern OCTAVE_API int nint (float x);
 
-      if (x < 0.0)
-        tmp = -1.0;
-      else if (x > 0.0)
-        tmp = 1.0;
+template <typename T>
+T
+mod (T x, T y)
+{
+  T retval;
 
-      return isnan (x) ? numeric_limits<double>::NaN () : tmp;
-    }
-
-    inline float
-    signum (float x)
+  if (y == 0)
+    retval = x;
+  else
     {
-      float tmp = 0.0f;
+      T q = x / y;
 
-      if (x < 0.0f)
-        tmp = -1.0f;
-      else if (x > 0.0f)
-        tmp = 1.0f;
+      if (x_nint (y) != y
+          && (std::abs ((q - x_nint (q)) / x_nint (q))
+              < std::numeric_limits<T>::epsilon ()))
+        retval = 0;
+      else
+        {
+          T n = std::floor (q);
 
-      return isnan (x) ? numeric_limits<float>::NaN () : tmp;
+          // Prevent use of extra precision.
+          volatile T tmp = y * n;
+
+          retval = x - tmp;
+        }
     }
 
-    template <typename T>
-    std::complex<T>
-    signum (const std::complex<T>& x)
-    {
-      T tmp = abs (x);
+  if (x != y && y != 0)
+    retval = copysign (retval, y);
 
-      return tmp == 0 ? 0.0 : x / tmp;
-    }
+  return retval;
+}
 
-    // Convert X to the nearest integer value.  Should not pass NaN to
-    // this function.
+template <typename T>
+T
+rem (T x, T y)
+{
+  T retval;
 
-    // For integer types?  Hmm.  Need to be sure T is an integer type...
-    template <typename T>
-    T
-    x_nint (T x)
-    {
-      return x;
-    }
-
-    template <>
-    inline double x_nint (double x)
+  if (y == 0)
+    retval = numeric_limits<T>::NaN ();
+  else
     {
-      return (isfinite (x) ? std::floor (x + 0.5) : x);
-    }
-
-    template <>
-    inline float x_nint (float x)
-    {
-      return (isfinite (x) ? std::floor (x + 0.5f) : x);
-    }
-
-    extern OCTAVE_API octave_idx_type nint_big (double x);
-    extern OCTAVE_API octave_idx_type nint_big (float x);
+      T q = x / y;
 
-    extern OCTAVE_API int nint (double x);
-    extern OCTAVE_API int nint (float x);
-
-    template <typename T>
-    T
-    mod (T x, T y)
-    {
-      T retval;
-
-      if (y == 0)
-        retval = x;
+      if (x_nint (y) != y
+          && (std::abs ((q - x_nint (q)) / x_nint (q))
+              < std::numeric_limits<T>::epsilon ()))
+        retval = 0;
       else
         {
-          T q = x / y;
-
-          if (x_nint (y) != y
-              && (std::abs ((q - x_nint (q)) / x_nint (q))
-                  < std::numeric_limits<T>::epsilon ()))
-            retval = 0;
-          else
-            {
-              T n = std::floor (q);
-
-              // Prevent use of extra precision.
-              volatile T tmp = y * n;
-
-              retval = x - tmp;
-            }
-        }
-
-      if (x != y && y != 0)
-        retval = copysign (retval, y);
-
-      return retval;
-    }
+          T n = std::trunc (q);
 
-    template <typename T>
-    T
-    rem (T x, T y)
-    {
-      T retval;
-
-      if (y == 0)
-        retval = numeric_limits<T>::NaN ();
-      else
-        {
-          T q = x / y;
+          // Prevent use of extra precision.
+          volatile T tmp = y * n;
 
-          if (x_nint (y) != y
-              && (std::abs ((q - x_nint (q)) / x_nint (q))
-                  < std::numeric_limits<T>::epsilon ()))
-            retval = 0;
-          else
-            {
-              T n = std::trunc (q);
-
-              // Prevent use of extra precision.
-              volatile T tmp = y * n;
-
-              retval = x - tmp;
-            }
+          retval = x - tmp;
         }
-
-      if (x != y && y != 0)
-        retval = copysign (retval, x);
-
-      return retval;
     }
 
-    // Generic min, max definitions
-    template <typename T>
-    T
-    min (T x, T y)
-    {
-      return x <= y ? x : y;
-    }
+  if (x != y && y != 0)
+    retval = copysign (retval, x);
+
+  return retval;
+}
 
-    template <typename T>
-    T
-    max (T x, T y)
-    {
-      return x >= y ? x : y;
-    }
+// Generic min, max definitions
+template <typename T>
+T
+min (T x, T y)
+{
+  return x <= y ? x : y;
+}
 
-    // This form is favorable.  GCC will translate (x <= y ? x : y) without a
-    // jump, hence the only conditional jump involved will be the first
-    // (isnan), infrequent and hence friendly to branch prediction.
+template <typename T>
+T
+max (T x, T y)
+{
+  return x >= y ? x : y;
+}
+
+// This form is favorable.  GCC will translate (x <= y ? x : y) without a
+// jump, hence the only conditional jump involved will be the first
+// (isnan), infrequent and hence friendly to branch prediction.
 
-    inline double
-    min (double x, double y)
-    {
-      return isnan (y) ? x : (x <= y ? x : y);
-    }
+inline double
+min (double x, double y)
+{
+  return isnan (y) ? x : (x <= y ? x : y);
+}
 
-    inline double
-    max (double x, double y)
-    {
-      return isnan (y) ? x : (x >= y ? x : y);
-    }
+inline double
+max (double x, double y)
+{
+  return isnan (y) ? x : (x >= y ? x : y);
+}
 
-    inline float
-    min (float x, float y)
-    {
-      return isnan (y) ? x : (x <= y ? x : y);
-    }
+inline float
+min (float x, float y)
+{
+  return isnan (y) ? x : (x <= y ? x : y);
+}
 
-    inline float
-    max (float x, float y)
-    {
-      return isnan (y) ? x : (x >= y ? x : y);
-    }
+inline float
+max (float x, float y)
+{
+  return isnan (y) ? x : (x >= y ? x : y);
+}
 
-    inline std::complex<double>
-    min (const std::complex<double>& x, const std::complex<double>& y)
-    {
-      return abs (x) <= abs (y) ? x : (isnan (x) ? x : y);
-    }
+inline std::complex<double>
+min (const std::complex<double>& x, const std::complex<double>& y)
+{
+  return abs (x) <= abs (y) ? x : (isnan (x) ? x : y);
+}
 
-    inline std::complex<float>
-    min (const std::complex<float>& x, const std::complex<float>& y)
-    {
-      return abs (x) <= abs (y) ? x : (isnan (x) ? x : y);
-    }
+inline std::complex<float>
+min (const std::complex<float>& x, const std::complex<float>& y)
+{
+  return abs (x) <= abs (y) ? x : (isnan (x) ? x : y);
+}
 
-    inline std::complex<double>
-    max (const std::complex<double>& x, const std::complex<double>& y)
-    {
-      return abs (x) >= abs (y) ? x : (isnan (x) ? x : y);
-    }
+inline std::complex<double>
+max (const std::complex<double>& x, const std::complex<double>& y)
+{
+  return abs (x) >= abs (y) ? x : (isnan (x) ? x : y);
+}
 
-    inline std::complex<float>
-    max (const std::complex<float>& x, const std::complex<float>& y)
-    {
-      return abs (x) >= abs (y) ? x : (isnan (x) ? x : y);
-    }
+inline std::complex<float>
+max (const std::complex<float>& x, const std::complex<float>& y)
+{
+  return abs (x) >= abs (y) ? x : (isnan (x) ? x : y);
+}
 
-    template <typename T>
-    inline octave_int<T>
-    min (const octave_int<T>& x, const octave_int<T>& y)
-    {
-      return xmin (x, y);
-    }
+template <typename T>
+inline octave_int<T>
+min (const octave_int<T>& x, const octave_int<T>& y)
+{
+  return xmin (x, y);
+}
 
-    template <typename T>
-    inline octave_int<T>
-    max (const octave_int<T>& x, const octave_int<T>& y)
-    {
-      return xmax (x, y);
-    }
+template <typename T>
+inline octave_int<T>
+max (const octave_int<T>& x, const octave_int<T>& y)
+{
+  return xmax (x, y);
+}
 
-    // These map reals to Complex.
+// These map reals to Complex.
 
-    extern OCTAVE_API Complex rc_acos (double);
-    extern OCTAVE_API FloatComplex rc_acos (float);
+extern OCTAVE_API Complex rc_acos (double);
+extern OCTAVE_API FloatComplex rc_acos (float);
 
-    extern OCTAVE_API Complex rc_acosh (double);
-    extern OCTAVE_API FloatComplex rc_acosh (float);
+extern OCTAVE_API Complex rc_acosh (double);
+extern OCTAVE_API FloatComplex rc_acosh (float);
 
-    extern OCTAVE_API Complex rc_asin (double);
-    extern OCTAVE_API FloatComplex rc_asin (float);
+extern OCTAVE_API Complex rc_asin (double);
+extern OCTAVE_API FloatComplex rc_asin (float);
 
-    extern OCTAVE_API Complex rc_atanh (double);
-    extern OCTAVE_API FloatComplex rc_atanh (float);
+extern OCTAVE_API Complex rc_atanh (double);
+extern OCTAVE_API FloatComplex rc_atanh (float);
 
-    extern OCTAVE_API Complex rc_log (double);
-    extern OCTAVE_API FloatComplex rc_log (float);
+extern OCTAVE_API Complex rc_log (double);
+extern OCTAVE_API FloatComplex rc_log (float);
 
-    extern OCTAVE_API Complex rc_log2 (double);
-    extern OCTAVE_API FloatComplex rc_log2 (float);
+extern OCTAVE_API Complex rc_log2 (double);
+extern OCTAVE_API FloatComplex rc_log2 (float);
 
-    extern OCTAVE_API Complex rc_log10 (double);
-    extern OCTAVE_API FloatComplex rc_log10 (float);
+extern OCTAVE_API Complex rc_log10 (double);
+extern OCTAVE_API FloatComplex rc_log10 (float);
 
-    extern OCTAVE_API Complex rc_sqrt (double);
-    extern OCTAVE_API FloatComplex rc_sqrt (float);
+extern OCTAVE_API Complex rc_sqrt (double);
+extern OCTAVE_API FloatComplex rc_sqrt (float);
 
 OCTAVE_END_NAMESPACE(math)
 OCTAVE_END_NAMESPACE(octave)