[SYCL] Change the behavior of sycl::maximum and sycl::minimum to be consistent with std::max and std::min (#10094)

The behavior of sycl::maximum and sycl::minimum used to be different
from std::max and std::min in the case of one of two operand was NaN
since sycl::maximum was implemented with std::greater<> while std::max
used operator <.
KhronosGroup/SYCL-Docs#285

---------

Signed-off-by: Kim, Euna <[email protected]>
Co-authored-by: euna.kim <[email protected]>

Author: eunakim0103

sycl/include/sycl/functional.hpp

@@ -35,36 +35,39 @@ template <typename T = void> struct logical_or {
 
 template <> struct logical_or<void> : std::logical_or<void> {};
 
+// sycl::minimum definition should be consistent with std::min
 template <typename T = void> struct minimum {
   T operator()(const T &lhs, const T &rhs) const {
-    return std::less<T>()(lhs, rhs) ? lhs : rhs;
+    return (rhs < lhs) ? rhs : lhs;
   }
 };
 
 template <> struct minimum<void> {
   struct is_transparent {};
   template <typename T, typename U>
-  auto operator()(T &&lhs, U &&rhs) const -> std::common_type_t<T &&, U &&> {
-    return std::less<>()(std::forward<const T>(lhs), std::forward<const U>(rhs))
-               ? std::forward<T>(lhs)
-               : std::forward<U>(rhs);
+  auto operator()(T &&lhs, U &&rhs) const ->
+      typename std::common_type<T &&, U &&>::type {
+    return (std::forward<const U>(rhs) < std::forward<const T>(lhs))
+               ? std::forward<U>(rhs)
+               : std::forward<T>(lhs);
   }
 };
 
+// sycl::maximum definition should be consistent with std::max
 template <typename T = void> struct maximum {
   T operator()(const T &lhs, const T &rhs) const {
-    return std::greater<T>()(lhs, rhs) ? lhs : rhs;
+    return (lhs < rhs) ? rhs : lhs;
   }
 };
 
 template <> struct maximum<void> {
   struct is_transparent {};
   template <typename T, typename U>
-  auto operator()(T &&lhs, U &&rhs) const -> std::common_type_t<T &&, U &&> {
-    return std::greater<>()(std::forward<const T>(lhs),
-                            std::forward<const U>(rhs))
-               ? std::forward<T>(lhs)
-               : std::forward<U>(rhs);
+  auto operator()(T &&lhs, U &&rhs) const ->
+      typename std::common_type<T &&, U &&>::type {
+    return (std::forward<const T>(lhs) < std::forward<const U>(rhs))
+               ? std::forward<U>(rhs)
+               : std::forward<T>(lhs);
   }
 };
 

sycl/test/basic_tests/sycl_maximum_minimum.cpp

@@ -0,0 +1,25 @@
+// RUN: %clangxx -fsycl %s -o %t.out
+// RUN: %t.out
+#include <sycl/sycl.hpp>
+
+#include <algorithm>
+#include <cassert>
+#include <limits>
+
+int main() {
+  double f1 = 1.0f;
+  double f2 = std::numeric_limits<double>::quiet_NaN();
+
+  assert(((std::max(f1, f2) == sycl::maximum{}(f1, f2)) &&
+          "sycl::maximum result is wrong"));
+  assert(((std::isnan((std::max(f2, f1)))) &&
+          (std::isnan(sycl::maximum{}(f2, f1)))) &&
+         "sycl::maximum result is wrong");
+  assert(((std::min(f1, f2) == sycl::minimum{}(f1, f2)) &&
+          "sycl::minimum result is wrong"));
+  assert(((std::isnan((std::min(f2, f1)))) &&
+          (std::isnan(sycl::minimum{}(f2, f1)))) &&
+         "sycl::minimum result is wrong");
+
+  return 0;
+}