Update comparison functions to be more standard conforming

Signed-off-by: Ian <[email protected]>

Author: Rinzii

include/ccmath/math/compare/isgreater.hpp

@@ -13,7 +13,7 @@
 #include <type_traits>
 
 #include "ccmath/internal/math/generic/builtins/compare/isgreater.hpp"
-
+#include "ccmath/math/compare/isunordered.hpp"
 
 namespace ccm
 {
@@ -24,29 +24,26 @@ namespace ccm
 	 * @param y A floating-point or integer value.
 	 * @return true if the first argument is greater than the second, false otherwise.
 	 */
-	template <typename T>
+	template <typename T, std::enable_if_t<std::is_floating_point_v<T>, bool> = true>
 	constexpr bool isgreater(T x, T y) noexcept
 	{
 		if constexpr (ccm::builtin::has_constexpr_isgreater<T>) { return ccm::builtin::isgreater(x, y); }
-		else
-		{
-			return x > y;
-		}
+		else { return !ccm::isunordered(x, y) && (x > y); }
 	}
 
 	/**
 	 * @brief Checks if the first argument is greater than the second.
-	 * @tparam T Type of the left-hand side.
-	 * @tparam U Type of the right-hand side.
+	 * @tparam Arithmetic1 Arithmetic type of the left-hand side.
+	 * @tparam Arithmetic2 Arithmetic type of the right-hand side.
 	 * @param x Value of the left-hand side of the comparison.
 	 * @param y Value of the right-hand side of the comparison.
 	 * @return true if the first argument is greater than the second, false otherwise.
 	 */
-	template <typename T, typename U>
-	constexpr bool isgreater(T x, U y) noexcept
+	template <typename Arithmetic1, typename Arithmetic2, std::enable_if_t<std::is_arithmetic_v<Arithmetic1> && std::is_arithmetic_v<Arithmetic2>, bool> = true>
+	constexpr bool isgreater(Arithmetic1 x, Arithmetic2 y) noexcept
 	{
 		// Find the common type of the two arguments
-		using shared_type = std::common_type_t<T, U>;
+		using shared_type = std::common_type_t<Arithmetic1, Arithmetic2>;
 
 		// Then cast the arguments to the common type and call the single argument version
 		return static_cast<shared_type>(isgreater<shared_type>(static_cast<shared_type>(x), static_cast<shared_type>(y)));

include/ccmath/math/compare/isgreaterequal.hpp

@@ -11,6 +11,7 @@
 #pragma once
 
 #include "ccmath/internal/math/generic/builtins/compare/isgreaterequal.hpp"
+#include "ccmath/math/compare/isunordered.hpp"
 
 #include <type_traits>
 
@@ -23,29 +24,29 @@ namespace ccm
 	 * @param y A floating-point or integer value.
 	 * @return true if the first argument is greater than or equal to the second, false otherwise.
 	 */
-	template <typename T>
+	template <typename T, std::enable_if_t<std::is_floating_point_v<T>, bool> = true>
 	constexpr bool isgreaterequal(T x, T y) noexcept
 	{
 		if constexpr (ccm::builtin::has_constexpr_isgreaterequal<T>) { return ccm::builtin::isgreaterequal(x, y); }
 		else
 		{
-			return x >= y;
+			return !ccm::isunordered(x,y) && (x >= y);
 		}
 	}
 
 	/**
 	 * @brief Checks if the first argument is greater than or equal to the second.
-	 * @tparam T Type of the left-hand side.
-	 * @tparam U Type of the right-hand side.
+	 * @tparam Arithmetic1 Arithmetic type of the left-hand side.
+	 * @tparam Arithmetic2 Arithmetic type of the right-hand side.
 	 * @param x Value of the left-hand side of the comparison.
 	 * @param y Value of the right-hand side of the comparison.
 	 * @return true if the first argument is greater than or equal to the second, false otherwise.
 	 */
-	template <typename T, typename U>
-	constexpr bool isgreaterequal(T x, U y) noexcept
+	template <typename Arithmetic1, typename Arithmetic2, std::enable_if_t<std::is_arithmetic_v<Arithmetic1> && std::is_arithmetic_v<Arithmetic2>, bool> = true>
+	constexpr bool isgreaterequal(Arithmetic1 x, Arithmetic2 y) noexcept
 	{
 		// Find the common type of the two arguments
-		using shared_type = std::common_type_t<T, U>;
+		using shared_type = std::common_type_t<Arithmetic1, Arithmetic2>;
 
 		// Then cast the arguments to the common type and call the single argument version
 		return static_cast<shared_type>(isgreaterequal<shared_type>(static_cast<shared_type>(x), static_cast<shared_type>(y)));

include/ccmath/math/compare/isless.hpp

@@ -11,6 +11,7 @@
 #pragma once
 
 #include "ccmath/internal/math/generic/builtins/compare/isless.hpp"
+#include "ccmath/math/compare/isunordered.hpp"
 
 #include <type_traits>
 
@@ -23,29 +24,26 @@ namespace ccm
 	 * @param y A floating-point or integer value.
 	 * @return true if the first argument is less than the second, false otherwise.
 	 */
-	template <typename T>
+	template <typename T, std::enable_if_t<std::is_floating_point_v<T>, bool> = true>
 	constexpr bool isless(T x, T y) noexcept
 	{
 		if constexpr (ccm::builtin::has_constexpr_isless<T>) { return ccm::builtin::isless(x, y); }
-		else
-		{
-			return x < y;
-		}
+		else { return !ccm::isunordered(x, y) && (x < y); }
 	}
 
 	/**
 	 * @brief Checks if the first argument is less than the second.
-	 * @tparam T Type of the left-hand side.
-	 * @tparam U Type of the right-hand side.
+	 * @tparam Arithmetic1 Arithmetic type of the left-hand side.
+	 * @tparam Arithmetic2 Arithmetic type of the right-hand side.
 	 * @param x Value of the left-hand side of the comparison.
 	 * @param y Value of the right-hand side of the comparison.
 	 * @return true if the first argument is less than the second, false otherwise.
 	 */
-	template <typename T, typename U>
-	constexpr bool isless(T x, U y) noexcept
+	template <typename Arithmetic1, typename Arithmetic2, std::enable_if_t<std::is_arithmetic_v<Arithmetic1> && std::is_arithmetic_v<Arithmetic2>, bool> = true>
+	constexpr bool isless(Arithmetic1 x, Arithmetic2 y) noexcept
 	{
 		// Find the common type of the two arguments
-		using shared_type = std::common_type_t<T, U>;
+		using shared_type = std::common_type_t<Arithmetic1, Arithmetic2>;
 
 		// Then cast the arguments to the common type and call the single argument version
 		return static_cast<shared_type>(isless<shared_type>(static_cast<shared_type>(x), static_cast<shared_type>(y)));

include/ccmath/math/compare/islessequal.hpp

@@ -11,6 +11,7 @@
 #pragma once
 
 #include "ccmath/internal/math/generic/builtins/compare/islessequal.hpp"
+#include "ccmath/math/compare/isunordered.hpp"
 
 #include <type_traits>
 
@@ -23,29 +24,26 @@ namespace ccm
 	 * @param y A floating-point or integer value.
 	 * @return true if the first argument is less than or equal to the second, false otherwise.
 	 */
-	template <typename T>
+	template <typename T, std::enable_if_t<std::is_floating_point_v<T>, bool> = true>
 	constexpr bool islessequal(T x, T y) noexcept
 	{
 		if constexpr (ccm::builtin::has_constexpr_islessequal<T>) { return ccm::builtin::islessequal(x, y); }
-		else
-		{
-			return x <= y;
-		}
+		else { return !ccm::isunordered(x, y) && (x <= y); }
 	}
 
 	/**
 	 * @brief Checks if the first argument is less than or equal to the second.
-	 * @tparam T Type of the left-hand side.
-	 * @tparam U Type of the right-hand side.
+	 * @tparam Arithmetic1 Arithmetic type of the left-hand side.
+	 * @tparam Arithmetic2 Arithmetic type of the right-hand side.
 	 * @param x Value of the left-hand side of the comparison.
 	 * @param y Value of the right-hand side of the comparison.
 	 * @return true if the first argument is less than or equal to the second, false otherwise.
 	 */
-	template <typename T, typename U>
-	constexpr bool islessequal(T x, U y) noexcept
+	template <typename Arithmetic1, typename Arithmetic2, std::enable_if_t<std::is_arithmetic_v<Arithmetic1> && std::is_arithmetic_v<Arithmetic2>, bool> = true>
+	constexpr bool islessequal(Arithmetic1 x, Arithmetic2 y) noexcept
 	{
 		// Find the common type of the two arguments
-		using shared_type = std::common_type_t<T, U>;
+		using shared_type = std::common_type_t<Arithmetic1, Arithmetic2>;
 
 		// Then cast the arguments to the common type and call the single argument version
 		return static_cast<shared_type>(islessequal<shared_type>(static_cast<shared_type>(x), static_cast<shared_type>(y)));

include/ccmath/math/compare/islessgreater.hpp

@@ -11,6 +11,7 @@
 #pragma once
 
 #include "ccmath/internal/math/generic/builtins/compare/islessgreater.hpp"
+#include "ccmath/math/compare/isunordered.hpp"
 
 #include <type_traits>
 
@@ -23,28 +24,25 @@ namespace ccm
 	 * @param y A floating-point or integer value.
 	 * @return true if the first argument is less than the second or greater than the second, false otherwise.
 	 */
-	template <typename T>
+	template <typename T, std::enable_if_t<std::is_floating_point_v<T>, bool> = true>
 	constexpr bool islessgreater(T x, T y) noexcept
 	{
 		if constexpr (ccm::builtin::has_constexpr_islessgreater<T>) { return ccm::builtin::islessgreater(x, y); }
-		else
-		{
-			return x < y || x > y;
-		}
+		else { return !ccm::isunordered(x, y) && (x < y || x > y); }
 	}
 
 	/**
 	 * @brief Checks if the first argument is less than the second or greater than the second.
-	 * @tparam T Type of the left-hand side.
-	 * @tparam U Type of the right-hand side.
+	 * @tparam Arithmetic1 Arithmetic type of the left-hand side.
+	 * @tparam Arithmetic2 Arithmetic type of the right-hand side.
 	 * @param x Value of the left-hand side of the comparison.
 	 * @param y Value of the right-hand side of the comparison.
 	 * @return true if the first argument is less than the second or greater than the second, false otherwise.
 	 */
-	template <typename T, typename U>
-	constexpr bool islessgreater(T x, U y) noexcept
+	template <typename Arithmetic1, typename Arithmetic2, std::enable_if_t<std::is_arithmetic_v<Arithmetic1> && std::is_arithmetic_v<Arithmetic2>, bool> = true>
+	constexpr bool islessgreater(Arithmetic1 x, Arithmetic2 y) noexcept
 	{
-		using shared_type = std::common_type_t<T, U>;
+		using shared_type = std::common_type_t<Arithmetic1, Arithmetic2>;
 		return static_cast<shared_type>(islessgreater<shared_type>(static_cast<shared_type>(x), static_cast<shared_type>(y)));
 	}
 } // namespace ccm

include/ccmath/math/compare/isunordered.hpp

@@ -10,9 +10,8 @@
 
 #pragma once
 
-#include "ccmath/math/compare/isnan.hpp"
 #include "ccmath/internal/math/generic/builtins/compare/isunordered.hpp"
-
+#include "ccmath/math/compare/isnan.hpp"
 
 #include <type_traits>
 
@@ -29,10 +28,7 @@ namespace ccm
 	constexpr bool isunordered(T x, T y) noexcept
 	{
 		if constexpr (ccm::builtin::has_constexpr_isunordered<T>) { return ccm::builtin::isunordered(x, y); }
-		else
-		{
-			return ccm::isnan(x) || ccm::isnan(y);
-		}
+		else { return ccm::isnan(x) || ccm::isnan(y); }
 	}
 
 	/**