Change implementation of fnearest()

This implementation does not need to modify rounding direction to work
correctly under any rounding direction.

lib/fizzy/execute.cpp

@@ -10,7 +10,6 @@
 #include "types.hpp"
 #include <algorithm>
 #include <cassert>
-#include <cfenv>
 #include <cmath>
 #include <cstring>
 #include <stack>
@@ -590,34 +589,13 @@ T fnearest(T value) noexcept
     if (std::isnan(value))
         return std::numeric_limits<T>::quiet_NaN();  // Positive canonical NaN.
 
-    // This implementation uses std::nearbyint() which rounds to integer using current rounding
-    // direction. The rounding direction is temporarily set to "to nearest" for the case when
-    // the current rounding direction is different.
+    static constexpr auto is_even = [](auto i) noexcept { return std::fmod(i, 2.0f) == 0; };
 
-    // The future C standard has roundeven() function which is much better for the job.
-    // But not generally available yet. Glibc has it already. GCC 10 has __builtin_roundeven().
-    // The LLVM has @llvm.roundeven intrinsic, but seems not to be exposed in Clang yet.
-
-    // Save the current rounding direction. This may be invalid negative value meaning a failure
-    // (probably due to changing rounding direction not being supported on the platform).
-    // volatile is used to prevent calls reordering by the compiler.
-    const volatile auto current_rounding_direction = std::fegetround();
-
-    // Temporarily change the rounding direction to "to nearest" if needed.
-    if (current_rounding_direction != FE_TONEAREST)
-    {
-        [[maybe_unused]] const auto set_succeeded = std::fesetround(FE_TONEAREST);
-        assert(set_succeeded == 0);
-    }
-
-    // volatile is used to prevent compiler from moving the last std::fesetround() before.
-    const volatile auto result = std::nearbyint(value);
-
-    // Reset the rounding direction if we know the previous value and it was actually modified.
-    if (current_rounding_direction >= 0 && current_rounding_direction != FE_TONEAREST)
-        std::fesetround(current_rounding_direction);
-
-    return result;
+    const auto t = std::trunc(value);
+    if (const auto diff = std::abs(value - t); diff > 0.5f || (diff == 0.5f && !is_even(t)))
+        return t + std::copysign(1.0f, value);
+    else
+        return t;
 }
 
 template <typename T>