Fix weak_less and weak_greater with floating-point numbers

They simply never worked for floating-point numbers because the overload
was ambiguous. Adding simple tests revealed the bug.

Author: Morwenn

include/cpp-sort/comparators/weak_greater.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016-2025 Morwenn
+ * Copyright (c) 2016-2026 Morwenn
  * SPDX-License-Identifier: MIT
  */
 #ifndef CPPSORT_COMPARATORS_WEAK_GREATER_H_
@@ -42,7 +42,10 @@ namespace cppsort
         template<typename T>
         auto weak_greater(const T& lhs, const T& rhs)
             noexcept(noexcept(cppsort::total_greater(lhs, rhs)))
-            -> decltype(cppsort::total_greater(lhs, rhs))
+            -> detail::enable_if_t<
+                not std::is_floating_point_v<T>,
+                decltype(cppsort::total_greater(lhs, rhs))
+            >
         {
             return cppsort::total_greater(lhs, rhs);
         }

include/cpp-sort/comparators/weak_less.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016-2025 Morwenn
+ * Copyright (c) 2016-2026 Morwenn
  * SPDX-License-Identifier: MIT
  */
 #ifndef CPPSORT_COMPARATORS_WEAK_LESS_H_
@@ -42,7 +42,10 @@ namespace cppsort
         template<typename T>
         auto weak_less(const T& lhs, const T& rhs)
             noexcept(noexcept(cppsort::total_less(lhs, rhs)))
-            -> decltype(cppsort::total_less(lhs, rhs))
+            -> detail::enable_if_t<
+                not std::is_floating_point_v<T>,
+                decltype(cppsort::total_less(lhs, rhs))
+            >
         {
             return cppsort::total_less(lhs, rhs);
         }

tests/CMakeLists.txt

@@ -189,6 +189,7 @@ add_executable(main-tests
     comparators/projection_compare.cpp
     comparators/total_order.cpp
     comparators/transparent_comparators.cpp
+    comparators/weak_order.cpp
 
     # Distributions tests
     distributions/all_equal.cpp

tests/comparators/weak_order.cpp

@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2026 Morwenn
+ * SPDX-License-Identifier: MIT
+ */
+#include <cmath>
+#include <limits>
+#include <catch2/catch_test_macros.hpp>
+#include <cpp-sort/comparators/weak_greater.h>
+#include <cpp-sort/comparators/weak_less.h>
+#include <cpp-sort/sorters/heap_sorter.h>
+
+TEST_CASE( "Weak ordering of floating-point numbers", "[comparison]" )
+{
+    constexpr double inf = std::numeric_limits<double>::infinity();
+
+    double array[] = { +1.0, +inf, -1.0, -std::nan("2"), +0.0, -inf, +std::nan("1"), -0.0 };
+
+    SECTION( "weak_less" )
+    {
+        cppsort::heap_sort(array, cppsort::weak_less);
+
+        // Check that equivalent values compare equivalent,
+        // regardless of their representation
+        CHECK( std::isnan(array[0]) );
+        CHECK( std::signbit(array[0]) );
+        CHECK( std::isinf(array[1]) );
+        CHECK( std::signbit(array[1]) );
+        CHECK( array[2] == -1.0 );
+        CHECK( array[3] == 0.0 );
+        CHECK( array[4] == 0.0 );
+        CHECK( array[5] == +1.0 );
+        CHECK( std::isinf(array[6]) );
+        CHECK( not std::signbit(array[6]) );
+        CHECK( std::isnan(array[7]) );
+        CHECK( not std::signbit(array[7]) );
+    }
+
+    SECTION( "weak_greater" )
+    {
+        cppsort::heap_sort(array, cppsort::weak_greater);
+
+        // Check that equivalent values compare equivalent,
+        // regardless of their representation
+        CHECK( not std::signbit(array[0]) );
+        CHECK( std::isnan(array[0]) );
+        CHECK( std::isinf(array[1]) );
+        CHECK( not std::signbit(array[1]) );
+        CHECK( array[2] == +1.0 );
+        CHECK( array[3] == 0.0 );
+        CHECK( array[4] == 0.0 );
+        CHECK( array[5] == -1.0 );
+        CHECK( std::isinf(array[6]) );
+        CHECK( std::signbit(array[6]) );
+        CHECK( std::isnan(array[7]) );
+        CHECK( std::signbit(array[7]) );
+    }
+}