review #553

Author: schaumb

src/base/anim/interpolated.h

@@ -34,13 +34,12 @@ template <typename Type> class Weighted
 		return value == other.value && weight == other.weight;
 	}
 
-	template <typename Comparator =
-	              std::conditional_t<std::floating_point<Type>,
-	                  decltype(Math::Floating::less),
-	                  std::less<Type>>>
 	bool operator<(const Weighted<Type> &other) const
 	{
-		return Comparator{}(value, other.value);
+		using Less = std::conditional_t<std::floating_point<Type>,
+		    decltype(Math::Floating::less),
+		    std::less<Type>>;
+		return Less{}(value, other.value);
 	}
 
 	[[nodiscard]] bool hasValue() const { return weight > 0.0; }
@@ -224,28 +223,26 @@ template <typename Type> class Interpolated
 		return res;
 	}
 
-	template <typename T = Type,
-	    typename Cmp = std::conditional_t<std::floating_point<T>,
-	        decltype(Math::Floating::less),
-	        std::less<T>>>
-	[[nodiscard]] T min() const
+	template <typename T = Type> [[nodiscard]] T min() const
 	{
+		using Less = std::conditional_t<std::floating_point<T>,
+		    decltype(Math::Floating::less),
+		    std::less<T>>;
 		return !has_second ? this->values[0].value
 		                   : std::min(this->values[0].value,
 		                       this->values[1].value,
-		                       Cmp{});
+		                       Less{});
 	}
 
-	template <typename T = Type,
-	    typename Cmp = std::conditional_t<std::floating_point<T>,
-	        decltype(Math::Floating::less),
-	        std::less<T>>>
-	[[nodiscard]] T max() const
+	template <typename T = Type> [[nodiscard]] T max() const
 	{
+		using Less = std::conditional_t<std::floating_point<T>,
+		    decltype(Math::Floating::less),
+		    std::less<T>>;
 		return !has_second ? this->values[0].value
 		                   : std::max(this->values[0].value,
 		                       this->values[1].value,
-		                       Cmp{});
+		                       Less{});
 	}
 };
 

src/base/math/floating.h

@@ -1,10 +1,8 @@
 #ifndef MATH_FLOATING
 #define MATH_FLOATING
 
-#include <bit>
 #include <compare>
 #include <concepts>
-#include <cstdint>
 #include <limits>
 
 namespace Math::Floating
@@ -18,43 +16,11 @@ constexpr auto inline less = [](auto a, auto b)
 	return std::is_lt(std::strong_order(a, b));
 };
 
-template <std::floating_point F,
-    std::size_t v =
-        std::numeric_limits<F>::is_iec559
-                        &&std::numeric_limits<F>::radix
-                    == 2
-                && std::numeric_limits<unsigned char>::digits == 8
-            ? sizeof(F)
-            : std::size_t{}>
-constexpr auto inline can_be_used_as_short_check =
-    std::bool_constant<false>{};
-
-template <std::floating_point F>
-constexpr auto inline can_be_used_as_short_check<F, 4> =
-    std::integral_constant<std::uint32_t,
-        std::bit_cast<std::uint32_t>(F{0.0}) == std::uint32_t{}
-            && std::bit_cast<std::uint32_t>(F{-0.0})
-                       + std::bit_cast<std::uint32_t>(F{-0.0})
-                   == std::uint32_t{}>{};
-
-template <std::floating_point F>
-constexpr auto inline can_be_used_as_short_check<F, 8> =
-    std::integral_constant<std::uint64_t,
-        std::bit_cast<std::uint64_t>(F{0.0}) == std::uint64_t{}
-            && std::bit_cast<std::uint64_t>(F{-0.0})
-                       + std::bit_cast<std::uint64_t>(F{-0.0})
-                   == std::uint64_t{}>{};
-
 constexpr auto inline is_zero = [](auto value)
 {
 	using F = decltype(value);
 	static_assert(std::floating_point<F>);
-	if constexpr (auto v = can_be_used_as_short_check<F>; v()) {
-		const auto val =
-		    std::bit_cast<typename decltype(v)::value_type>(value);
-		return val + val == 0;
-	}
-	else if constexpr (std::numeric_limits<F>::is_iec559) {
+	if constexpr (std::numeric_limits<F>::is_iec559) {
 		return value == F{};
 	}
 	else {