fix: Implement safe numeric casting and error handling for numeric conversions

Signed-off-by: FrozenlemonTee <1115306170@qq.com>

Author: FrozenLemonTee

src/operations/operators.cppm

@@ -333,16 +333,17 @@ constexpr auto apply_assign(Lhs &lhs, Rhs const &rhs)
 
   auto const assigned_common = out->load();
   if constexpr (std::same_as<lhs_value_policy, policy::value::checked> &&
-                std::integral<lhs_rep> && std::integral<common_rep>) {
+                std::integral<lhs_rep>) {
     if (auto const kind =
-            policy::details::narrow_integral_error<lhs_rep>(assigned_common);
+            policy::details::narrow_numeric_error<lhs_rep>(assigned_common);
         kind.has_value()) {
       return std::unexpected(
           policy::details::to_error_payload<ErrorPayload>(*kind));
     }
   }
 
-  auto const assigned_rep = static_cast<lhs_rep>(assigned_common);
+  auto const assigned_rep =
+      policy::details::safe_numeric_cast<lhs_rep>(assigned_common);
   lhs.store(underlying::traits<lhs_value_type>::from_rep(assigned_rep));
   return out;
 }

src/policy/impl.cppm

@@ -1,5 +1,6 @@
 module;
 #include <atomic>
+#include <cmath>
 #include <cstdint>
 #include <concepts>
 #include <exception>
@@ -574,6 +575,64 @@ constexpr auto narrow_integral_error(SrcRep value)
     return std::nullopt;
   }
 }
+
+template <typename DestRep, typename SrcRep>
+constexpr auto narrow_numeric_error(SrcRep value)
+    -> std::optional<error::kind> {
+  using dest_type = std::remove_cv_t<DestRep>;
+  using src_type = std::remove_cv_t<SrcRep>;
+
+  if constexpr (std::integral<dest_type> && std::integral<src_type>) {
+    return narrow_integral_error<dest_type>(value);
+  } else if constexpr (std::integral<dest_type> &&
+                       std::floating_point<src_type>) {
+    if (std::isnan(value)) {
+      return error::kind::domain_error;
+    }
+    if (std::isinf(value)) {
+      return value < static_cast<src_type>(0) ? error::kind::underflow
+                                              : error::kind::overflow;
+    }
+
+    auto const normalized = static_cast<long double>(value);
+    auto const min_value =
+        static_cast<long double>(std::numeric_limits<dest_type>::lowest());
+    auto const max_value =
+        static_cast<long double>(std::numeric_limits<dest_type>::max());
+
+    if (normalized < min_value) {
+      return error::kind::underflow;
+    }
+    if (normalized > max_value) {
+      return error::kind::overflow;
+    }
+    return std::nullopt;
+  } else {
+    static_cast<void>(value);
+    return std::nullopt;
+  }
+}
+
+template <typename DestRep, typename SrcRep>
+constexpr auto safe_numeric_cast(SrcRep value) noexcept -> DestRep {
+  using dest_type = std::remove_cv_t<DestRep>;
+  using src_type = std::remove_cv_t<SrcRep>;
+
+  if constexpr (std::integral<dest_type> && std::floating_point<src_type>) {
+    if (auto const kind = narrow_numeric_error<dest_type>(value);
+        kind.has_value()) {
+      if (*kind == error::kind::overflow) {
+        return std::numeric_limits<dest_type>::max();
+      }
+      if (*kind == error::kind::underflow) {
+        return std::numeric_limits<dest_type>::lowest();
+      }
+      return dest_type{};
+    }
+  }
+
+  return static_cast<dest_type>(value);
+}
 } // namespace details
 
 template <operations::operation OpTag, typename CommonRep,