Fix calculation of "nearest integer" function (bug #67339)

The internal function x_nint in lo-mappers.h was being used to find the nearest
integer value to a given input x, using the expression 'std::floor (x + 0.5)'.
This expression was giving wrong results for x > 0.5 * flintmax, because the
ratio 0.5 / x was becoming lower than eps at that point, and that in turn was
causing incorrect rounding for odd numbers. In turn, it was causing problems
with mod() and rem() with numbers near (but still lower than) flintmax where
those functions were returning zero for mod (x-1, x) instead of x-1 itself.

* lo-mappers.h (x_nint): Use std::round instead of handrolled code.

* data.cc (Fmod, Frem): New BISTs for inputs near flintmax().

Author: arungiridhar

libinterp/corefcn/data.cc

@@ -756,6 +756,13 @@ periodic, @code{mod} is a better choice.
 
 %!assert <*42627> (rem (0.94, 0.01), 0.0)
 
+## Test rem (x-1, x) for x close to flintmax. Should return x-1 and not zero.
+%!test <*67339>
+%! x = flintmax - (10:-1:1);
+%! assert (rem (x-1, x), x-1);
+%! x = flintmax ("single") - (10:-1:1);
+%! assert (rem (x-1, x), x-1);
+
 %!error rem (uint (8), int8 (5))
 %!error rem (uint8 ([1, 2]), uint8 ([3, 4, 5]))
 %!error rem ()
@@ -958,6 +965,13 @@ negative numbers or when the values are periodic.
 %!assert <*54602> (mod (int8 (-125), int8 (0)), int8 (-125))
 %!assert <*54602> (mod (int8 (0), int8 (-25)), int8 (0))
 
+## Test mod (x-1, x) for x close to flintmax. Should return x-1 and not zero.
+%!test <*67339>
+%! x = flintmax - (10:-1:1);
+%! assert (mod (x-1, x), x-1);
+%! x = flintmax ("single") - (10:-1:1);
+%! assert (mod (x-1, x), x-1);
+
 */
 
 #define DATA_REDUCTION(FCN)                                             \

liboctave/numeric/lo-mappers.h

@@ -274,13 +274,13 @@ x_nint (T x)
 template <>
 inline double x_nint (double x)
 {
-  return (isfinite (x) ? std::floor (x + 0.5) : x);
+  return std::round (x);
 }
 
 template <>
 inline float x_nint (float x)
 {
-  return (isfinite (x) ? std::floor (x + 0.5f) : x);
+  return std::round (x);
 }
 
 extern OCTAVE_API octave_idx_type nint_big (double x);