diff --git a/Makefile.am b/Makefile.am
index ead0a906a2..cbd9eab2d0 100755
--- a/Makefile.am
+++ b/Makefile.am
@@ -349,6 +349,7 @@ test_libbitcoin_system_test_SOURCES = \
     test/math/byteswap.cpp \
     test/math/cast.cpp \
     test/math/division.cpp \
+    test/math/expectations.cpp \
     test/math/limits.cpp \
     test/math/logarithm.cpp \
     test/math/multiplication.cpp \
diff --git a/builds/cmake/CMakeLists.txt b/builds/cmake/CMakeLists.txt
index 0d09958a8c..3a4185e353 100644
--- a/builds/cmake/CMakeLists.txt
+++ b/builds/cmake/CMakeLists.txt
@@ -828,6 +828,7 @@ if (with-tests)
         "../../test/math/byteswap.cpp"
         "../../test/math/cast.cpp"
         "../../test/math/division.cpp"
+        "../../test/math/expectations.cpp"
         "../../test/math/limits.cpp"
         "../../test/math/logarithm.cpp"
         "../../test/math/multiplication.cpp"
diff --git a/builds/msvc/vs2022/libbitcoin-system-test/libbitcoin-system-test.vcxproj b/builds/msvc/vs2022/libbitcoin-system-test/libbitcoin-system-test.vcxproj
index 0ff280e3ba..cbdfbdb00e 100644
--- a/builds/msvc/vs2022/libbitcoin-system-test/libbitcoin-system-test.vcxproj
+++ b/builds/msvc/vs2022/libbitcoin-system-test/libbitcoin-system-test.vcxproj
@@ -275,6 +275,7 @@
     </ClCompile>
     <ClCompile Include="..\..\..\..\test\math\cast.cpp" />
     <ClCompile Include="..\..\..\..\test\math\division.cpp" />
+    <ClCompile Include="..\..\..\..\test\math\expectations.cpp" />
     <ClCompile Include="..\..\..\..\test\math\limits.cpp" />
     <ClCompile Include="..\..\..\..\test\math\logarithm.cpp" />
     <ClCompile Include="..\..\..\..\test\math\multiplication.cpp" />
diff --git a/builds/msvc/vs2022/libbitcoin-system-test/libbitcoin-system-test.vcxproj.filters b/builds/msvc/vs2022/libbitcoin-system-test/libbitcoin-system-test.vcxproj.filters
index 55ea6c40bb..5f4d08ba0f 100644
--- a/builds/msvc/vs2022/libbitcoin-system-test/libbitcoin-system-test.vcxproj.filters
+++ b/builds/msvc/vs2022/libbitcoin-system-test/libbitcoin-system-test.vcxproj.filters
@@ -477,6 +477,9 @@
     <ClCompile Include="..\..\..\..\test\math\division.cpp">
       <Filter>src\math</Filter>
     </ClCompile>
+    <ClCompile Include="..\..\..\..\test\math\expectations.cpp">
+      <Filter>src\math</Filter>
+    </ClCompile>
     <ClCompile Include="..\..\..\..\test\math\limits.cpp">
       <Filter>src\math</Filter>
     </ClCompile>
diff --git a/include/bitcoin/system/constraints.hpp b/include/bitcoin/system/constraints.hpp
index f6e8abac77..e20a7aed3f 100644
--- a/include/bitcoin/system/constraints.hpp
+++ b/include/bitcoin/system/constraints.hpp
@@ -255,6 +255,8 @@ using if_little_endian_integral_integer = bool_if<
     is_integral_integer<Integer> &&
     is_little_endian>;
 
+/// Floating pont types (native, floating point, non-bool).
+
 template <typename Integer>
 using if_floating_point = bool_if<
     is_floating_point<Integer>>;
diff --git a/include/bitcoin/system/impl/math/cast.ipp b/include/bitcoin/system/impl/math/cast.ipp
index e627e9aac7..d6f8d13756 100644
--- a/include/bitcoin/system/impl/math/cast.ipp
+++ b/include/bitcoin/system/impl/math/cast.ipp
@@ -209,31 +209,71 @@ constexpr Unsigned to_unsigned(Unsigned value) NOEXCEPT
 
 // Floating point casts.
 // ----------------------------------------------------------------------------
+// inlines below be not constant until c++23.
 
 template <typename Integer, typename Float,
     if_integral_integer<Integer>,
     if_floating_point<Float>>
-constexpr bool to_integer(Integer& out, Float value) NOEXCEPT
+inline bool to_integer(Integer& out, Float value, bool whole) NOEXCEPT
 {
     if (!std::isfinite(value))
         return false;
 
+    // TODO: Could use tolerance for fp epsilon to handle representation error.
     Float integer{};
-    const Float fractional = std::modf(value, &integer);
-    if (fractional != 0.0)
+    if ((std::modf(value, &integer) != 0.0) && whole)
         return false;
 
     if (integer > static_cast<Float>(std::numeric_limits<Integer>::max()) ||
         integer < static_cast<Float>(std::numeric_limits<Integer>::min()))
         return false;
 
-    // Floating point conversion in c++ requires explicit or implicit cast.
-    BC_PUSH_WARNING(NO_CASTS_FOR_ARITHMETIC_CONVERSION)
-    out = static_cast<Integer>(integer);
-    BC_POP_WARNING()
+    out = to_integer<Integer>(integer);
     return true;
 }
 
+template <typename Integer, typename Float,
+    if_integral_integer<Integer>,
+    if_floating_point<Float>>
+inline Integer to_ceilinged_integer(Float value) NOEXCEPT
+{
+    return to_truncated_integer<Integer>(std::ceil(value));
+}
+
+template <typename Integer, typename Float,
+    if_integral_integer<Integer>,
+    if_floating_point<Float>>
+inline Integer to_floored_integer(Float value) NOEXCEPT
+{
+    return to_truncated_integer<Integer>(std::floor(value));
+}
+
+template <typename Integer, typename Float,
+    if_integral_integer<Integer>,
+    if_floating_point<Float>>
+inline Integer to_rounded_integer(Float value) NOEXCEPT
+{
+    return to_truncated_integer<Integer>(std::round(value));
+}
+
+template <typename Integer, typename Float,
+    if_integral_integer<Integer>,
+    if_floating_point<Float>>
+inline Integer to_truncated_integer(Float value) NOEXCEPT
+{
+    if (!std::isfinite(value))
+        return std::numeric_limits<Integer>::max();
+
+    const auto integer = std::trunc(value);
+    if (integer > static_cast<Float>(std::numeric_limits<Integer>::max()))
+        return std::numeric_limits<Integer>::max();
+
+    if (integer < static_cast<Float>(std::numeric_limits<Integer>::min()))
+        return std::numeric_limits<Integer>::min();
+
+    return to_integer<Integer>(integer);
+}
+
 template <typename Integer, typename Float,
     if_integral_integer<Integer>,
     if_floating_point<Float>>
diff --git a/include/bitcoin/system/math/cast.hpp b/include/bitcoin/system/math/cast.hpp
index 4e44d64747..3a680ecf56 100644
--- a/include/bitcoin/system/math/cast.hpp
+++ b/include/bitcoin/system/math/cast.hpp
@@ -142,19 +142,53 @@ constexpr Unsigned to_unsigned(Unsigned value) NOEXCEPT;
 /// Floating point casts.
 /// ---------------------------------------------------------------------------
 
-/// Cast floating point to integral integer, overflow guarded.
+/// Cast floating point to integral integer (truncated).
+/// True for any finite value that falls within Integer domain.
+/// False if fractional part is non-zero when whole is set true.
 template <typename Integer = size_t, typename Float,
     if_integral_integer<Integer> = true,
     if_floating_point<Float> = true>
-constexpr bool to_integer(Integer& out, Float value) NOEXCEPT;
+inline bool to_integer(Integer& out, Float value, bool whole=true) NOEXCEPT;
 
-/// Cast floating point to integral integer, overflow unguarded.
+/// Cast floating point to integral integer (ceilinged).
+/// Any non-finite value returns the integer domain maximum.
+/// Overflow/underflow is clamped to respective integer upper/lower limit.
+template <typename Integer = size_t, typename Float,
+    if_integral_integer<Integer> = true,
+    if_floating_point<Float> = true>
+inline Integer to_ceilinged_integer(Float value) NOEXCEPT;
+
+/// Cast floating point to integral integer (floored).
+/// Any non-finite value returns the integer domain maximum.
+/// Overflow/underflow is clamped to respective integer upper/lower limit.
+template <typename Integer = size_t, typename Float,
+    if_integral_integer<Integer> = true,
+    if_floating_point<Float> = true>
+inline Integer to_floored_integer(Float value) NOEXCEPT;
+
+/// Cast floating point to integral integer (rounded).
+/// Any non-finite value returns the integer domain maximum.
+/// Overflow/underflow is clamped to respective integer upper/lower limit.
+template <typename Integer = size_t, typename Float,
+    if_integral_integer<Integer> = true,
+    if_floating_point<Float> = true>
+inline Integer to_rounded_integer(Float value) NOEXCEPT;
+
+/// Cast floating point to integral integer (truncated).
+/// Any non-finite value returns the integer domain maximum.
+/// Overflow/underflow is clamped to respective integer upper/lower limit.
+template <typename Integer = size_t, typename Float,
+    if_integral_integer<Integer> = true,
+    if_floating_point<Float> = true>
+inline Integer to_truncated_integer(Float value) NOEXCEPT;
+
+/// Cast floating point to integral integer, overflow/underflow UNGUARDED.
 template <typename Integer = size_t, typename Float,
     if_integral_integer<Integer> = true,
     if_floating_point<Float> = true>
 constexpr Integer to_integer(Float value) NOEXCEPT;
 
-/// Cast integral integer to floating point, overflow unguarded.
+/// Cast integral integer to floating point, overflow/underflow not possible.
 template <typename Float = double, typename Integer,
     if_floating_point<Float> = true,
     if_integral_integer<Integer> = true>
diff --git a/test/math/addition.cpp b/test/math/addition.cpp
index 3ea0625df9..f124b6f7a9 100644
--- a/test/math/addition.cpp
+++ b/test/math/addition.cpp
@@ -18,7 +18,7 @@
  */
 #include "../test.hpp"
 
- // creates addition_tests namespace
+// creates addition_tests namespace
 BOOST_AUTO_TEST_SUITE(addition_tests)
 
 constexpr uint32_t pos_uint32 = 42;
diff --git a/test/math/cast.cpp b/test/math/cast.cpp
index 7ef6fc9504..e93b051791 100644
--- a/test/math/cast.cpp
+++ b/test/math/cast.cpp
@@ -17,6 +17,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 #include "../test.hpp"
+#include <cfloat>
 
 // promote
 // depromote
@@ -76,281 +77,162 @@ static_assert(is_same_type<decltype(to_floating(1u)), double>);
 static_assert(is_same_type<decltype(to_floating<float>(1u)), float>);
 static_assert(is_same_type<decltype(to_floating<double>(2u)), double>);
 
-// Verify compiler "usual arithmetic conversion" expectations.
-// ----------------------------------------------------------------------------
-// Shift works like a unary op (right operand is not incorporated).
-// Order of operands does not affect (other) binary ops.
-// self-assigning (e.g. >>=, /=) ops obviously do not (cannot) promote.
-// ! and comparison are not mathematical ops.
-
-// Unary ops (+/-/~) change to unsigned upon width promotion, not otherwise.
-// + is a unary op and produces promotion.
-// std::common_type does not support unary operators.
-// std::common_type<Left, Right>::type == decltype(left - right)
-// std::common_type<Value>::type != decltype(-value)
-using integer = decltype(-'a');
-using character = std::common_type_t<char>;
-using common_character = std::common_type_t<char, char>;
-static_assert(!is_same_type<integer, character>);
-static_assert(!is_same_type<integer, common_character>);
-
-// Compiler warns on bool safety for -b, ~b, <<b, >>b, /b, %b, b/, b% (assertions disabled).
-
-// invert
-static_assert(is_same_type<decltype(!char{0}),                   bool>, "boolean");
-static_assert(is_same_type<decltype(!int8_t{0}),                 bool>, "boolean");
-static_assert(is_same_type<decltype(!int16_t{0}),                bool>, "boolean");
-static_assert(is_same_type<decltype(!int32_t{0}),                bool>, "boolean");
-static_assert(is_same_type<decltype(!int64_t{0}),                bool>, "boolean");
-static_assert(is_same_type<decltype(!bool{false}),               bool>, "boolean");
-static_assert(is_same_type<decltype(!uint8_t{0}),                bool>, "boolean");
-static_assert(is_same_type<decltype(!uint16_t{0}),               bool>, "boolean");
-static_assert(is_same_type<decltype(!uint32_t{0}),               bool>, "boolean");
-static_assert(is_same_type<decltype(!uint64_t{0}),               bool>, "boolean");
-
-// comparison
-static_assert(is_same_type<decltype(uint8_t{0}  == char{0}),     bool>, "boolean");
-static_assert(is_same_type<decltype(uint8_t{0}  != uint8_t{0}),  bool>, "boolean");
-static_assert(is_same_type<decltype(uint8_t{0}  >= uint16_t{0}), bool>, "boolean");
-static_assert(is_same_type<decltype(uint16_t{0} <= uint32_t{0}), bool>, "boolean");
-static_assert(is_same_type<decltype(uint32_t{0} == uint64_t{0}), bool>, "boolean");
-static_assert(is_same_type<decltype(uint64_t{0} == uint64_t{0}), bool>, "boolean");
-static_assert(is_same_type<decltype(uint8_t{0}  == bool{false}), bool>, "boolean");
-static_assert(is_same_type<decltype(bool{false} == uint32_t{0}), bool>, "boolean");
-static_assert(is_same_type<decltype(uint8_t{0}  == int8_t{0}),   bool>, "boolean");
-static_assert(is_same_type<decltype(uint8_t{0}  == int16_t{0}),  bool>, "boolean");
-static_assert(is_same_type<decltype(uint16_t{0} == int32_t{0}),  bool>, "boolean");
-static_assert(is_same_type<decltype(uint32_t{0} == int64_t{0}),  bool>, "boolean");
-static_assert(is_same_type<decltype(int64_t{0}  == uint32_t{0}), bool>, "boolean");
-
-// positive
-static_assert(is_same_type<decltype(+char{1}),                   int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(+int8_t{1}),                 int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(+int16_t{1}),                int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(+int32_t{1}),                int32_t>,  "unpromoted (>=32");
-static_assert(is_same_type<decltype(+int64_t{1}),                int64_t>,  "unpromoted (>=32");
-static_assert(is_same_type<decltype(+bool{false}),               int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(+uint8_t{1}),                int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(+uint16_t{1}),               int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(+uint32_t{1}),               uint32_t>, "unpromoted (>=32");
-static_assert(is_same_type<decltype(+uint64_t{1}),               uint64_t>, "unpromoted (>=32");
-
-// negate (signed)
-static_assert(is_same_type<decltype(-char{1}),                   int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(-int8_t{1}),                 int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(-int16_t{1}),                int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(-int32_t{1}),                int32_t>,  "unpromoted (>=32");
-static_assert(is_same_type<decltype(-int64_t{1}),                int64_t>,  "unpromoted (>=32");
-////static_assert(is_same_type<decltype(-bool{false}),               int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(-uint8_t{1}),                int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(-uint16_t{1}),               int>,      "promoted   (<32)");
-////static_assert(is_same_type<decltype(-uint32_t{1}),               uint32_t>, "unpromoted (>=32");
-////static_assert(is_same_type<decltype(-uint64_t{1}),               uint64_t>, "unpromoted (>=32");
-
-// negate (unsigned)
-static_assert(is_same_type<decltype(-char{1u}),                  int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(-int8_t{1u}),                int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(-int16_t{1u}),               int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(-int32_t{1u}),               int32_t>,  "unpromoted (>=32");
-static_assert(is_same_type<decltype(-int64_t{1u}),               int64_t>,  "unpromoted (>=32");
-////static_assert(is_same_type<decltype(-bool{false}),               int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(-uint8_t{1u}),               int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(-uint16_t{1u}),              int>,      "promoted   (<32)");
-////static_assert(is_same_type<decltype(-uint32_t{1u}),              uint32_t>, "unpromoted (>=32");
-////static_assert(is_same_type<decltype(-uint64_t{1u}),              uint64_t>, "unpromoted (>=32");
-
-// ones_complement
-static_assert(is_same_type<decltype(~char{0}),                   int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(~int8_t{0}),                 int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(~int16_t{0}),                int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(~int32_t{0}),                int32_t>,  "unpromoted (>=32");
-static_assert(is_same_type<decltype(~int64_t{0}),                int64_t>,  "unpromoted (>=32");
-////static_assert(is_same_type<decltype(~bool{false}),               int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(~uint8_t{0}),                int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(~uint16_t{0}),               int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(~uint32_t{0}),               uint32_t>, "unpromoted (>=32");
-static_assert(is_same_type<decltype(~uint64_t{0}),               uint64_t>, "unpromoted (>=32");
-
-// shift_left
-static_assert(is_same_type<decltype(uint8_t{0}  << char{0}),     int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(uint8_t{0}  << uint8_t{0}),  int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(uint8_t{0}  << uint16_t{0}), int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(uint16_t{0} << uint32_t{0}), int >,     "promoted   (<32)");
-static_assert(is_same_type<decltype(uint32_t{0} << uint64_t{0}), uint32_t>, "unpromoted (>=32");
-static_assert(is_same_type<decltype(uint64_t{0} << uint64_t{0}), uint64_t>, "unpromoted (>=32");
-////static_assert(is_same_type<decltype(uint8_t{0}  << bool{false}), int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(bool{false} << uint32_t{0}), int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(uint8_t{0}  << int8_t{0}),   int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(uint8_t{0}  << int16_t{0}),  int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(uint16_t{0} << int32_t{0}),  int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(uint32_t{0} << int64_t{0}),  uint32_t>, "unpromoted (>=32");
-static_assert(is_same_type<decltype(int64_t{0}  << uint32_t{0}), int64_t>,  "unpromoted (>=32");
-
-// shift_right
-static_assert(is_same_type<decltype(uint8_t{0}  >> char{0}),     int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(uint8_t{0}  >> uint8_t{0}),  int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(uint8_t{0}  >> uint16_t{0}), int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(uint16_t{0} >> uint32_t{0}), int >,     "promoted   (<32)");
-static_assert(is_same_type<decltype(uint32_t{0} >> uint64_t{0}), uint32_t>, "unpromoted (>=32");
-static_assert(is_same_type<decltype(uint64_t{0} >> uint64_t{0}), uint64_t>, "unpromoted (>=32");
-////static_assert(is_same_type<decltype(uint8_t{0}  >> bool{false}), int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(bool{false} >> uint32_t{0}), int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(uint8_t{0}  >> int8_t{0}),   int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(uint8_t{0}  >> int16_t{0}),  int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(uint16_t{0} >> int32_t{0}),  int>,      "promoted   (<32)");
-static_assert(is_same_type<decltype(uint32_t{0} >> int64_t{0}),  uint32_t>, "unpromoted (>=32");
-static_assert(is_same_type<decltype(int64_t{0}  >> uint32_t{0}), int64_t>,  "unpromoted (>=32");
-
-// bit_and
-static_assert(is_same_type<decltype(uint8_t{0}  & char{0}),     int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint8_t{0}  & uint8_t{0}),  int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint8_t{0}  & uint16_t{0}), int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint16_t{0} & uint32_t{0}), uint32_t>, "widest   (one >=32)");
-static_assert(is_same_type<decltype(uint32_t{0} & uint64_t{0}), uint64_t>, "widest   (two >=32)");
-static_assert(is_same_type<decltype(uint64_t{0} & uint64_t{0}), uint64_t>, "widest   (two >=32)");
-static_assert(is_same_type<decltype(uint8_t{0}  & bool{false}), int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint8_t{0}  & int8_t{0}),   int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint8_t{0}  & int16_t{0}),  int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint16_t{0} & int32_t{0}),  int32_t>,  "widest   (one >=32)");
-static_assert(is_same_type<decltype(uint32_t{0} & int64_t{0}),  int64_t>,  "unsigned (two >=32, s/u)");
-static_assert(is_same_type<decltype(int64_t{0}  & uint32_t{0}), int64_t>,  "unsigned (two >=32, u/s)");
-
-// bit_or
-static_assert(is_same_type<decltype(uint8_t{0}  | char{0}),     int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint8_t{0}  | uint8_t{0}),  int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint8_t{0}  | uint16_t{0}), int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint16_t{0} | uint32_t{0}), uint32_t>, "widest   (one >=32)");
-static_assert(is_same_type<decltype(uint32_t{0} | uint64_t{0}), uint64_t>, "widest   (two >=32)");
-static_assert(is_same_type<decltype(uint64_t{0} | uint64_t{0}), uint64_t>, "widest   (two >=32)");
-static_assert(is_same_type<decltype(uint8_t{0}  | bool{false}), int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint8_t{0}  | int8_t{0}),   int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint8_t{0}  | int16_t{0}),  int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint16_t{0} | int32_t{0}),  int32_t>,  "widest   (one >=32)");
-static_assert(is_same_type<decltype(uint32_t{0} | int64_t{0}),  int64_t>,  "unsigned (two >=32, s/u)");
-static_assert(is_same_type<decltype(int64_t{0}  | uint32_t{0}), int64_t>,  "unsigned (two >=32, u/s)");
-
-// bit_xor
-static_assert(is_same_type<decltype(uint8_t{0}  ^ char{0}),     int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint8_t{0}  ^ uint8_t{0}),  int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint8_t{0}  ^ uint16_t{0}), int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint16_t{0} ^ uint32_t{0}), uint32_t>, "widest   (one >=32)");
-static_assert(is_same_type<decltype(uint32_t{0} ^ uint64_t{0}), uint64_t>, "widest   (two >=32)");
-static_assert(is_same_type<decltype(uint64_t{0} ^ uint64_t{0}), uint64_t>, "widest   (two >=32)");
-static_assert(is_same_type<decltype(uint8_t{0}  ^ bool{false}), int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint8_t{0}  ^ int8_t{0}),   int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint8_t{0}  ^ int16_t{0}),  int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint16_t{0} ^ int32_t{0}),  int32_t>,  "widest   (one >=32)");
-static_assert(is_same_type<decltype(uint32_t{0} ^ int64_t{0}),  int64_t>,  "unsigned (two >=32, s/u)");
-static_assert(is_same_type<decltype(int64_t{0}  ^ uint32_t{0}), int64_t>,  "unsigned (two >=32, u/s)");
-
-// add
-static_assert(is_same_type<decltype(uint8_t{0}  + char{0}),     int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint8_t{0}  + uint8_t{0}),  int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint8_t{0}  + uint16_t{0}), int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint16_t{0} + uint32_t{0}), uint32_t>, "widest   (one >=32)");
-static_assert(is_same_type<decltype(uint32_t{0} + uint64_t{0}), uint64_t>, "widest   (two >=32)");
-static_assert(is_same_type<decltype(uint64_t{0} + uint64_t{0}), uint64_t>, "widest   (two >=32)");
-static_assert(is_same_type<decltype(uint8_t{0}  + bool{false}), int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint8_t{0}  + int8_t{0}),   int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint8_t{0}  + int16_t{0}),  int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint16_t{0} + int32_t{0}),  int32_t>,  "widest   (one >=32)");
-static_assert(is_same_type<decltype(uint32_t{0} + int64_t{0}),  int64_t>,  "unsigned (two >=32, s/u)");
-static_assert(is_same_type<decltype(int64_t{0}  + uint32_t{0}), int64_t>,  "unsigned (two >=32, u/s)");
-
-// subtract
-static_assert(is_same_type<decltype(uint8_t{0}  - char{0}),     int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint8_t{0}  - uint8_t{0}),  int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint8_t{0}  - uint16_t{0}), int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint16_t{0} - uint32_t{0}), uint32_t>, "widest   (one >=32)");
-static_assert(is_same_type<decltype(uint32_t{0} - uint64_t{0}), uint64_t>, "widest   (two >=32)");
-static_assert(is_same_type<decltype(uint64_t{0} - uint64_t{0}), uint64_t>, "widest   (two >=32)");
-static_assert(is_same_type<decltype(uint8_t{0}  - bool{false}), int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint8_t{0}  - int8_t{0}),   int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint8_t{0}  - int16_t{0}),  int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint16_t{0} - int32_t{0}),  int32_t>,  "widest   (one >=32)");
-static_assert(is_same_type<decltype(uint32_t{0} - int64_t{0}),  int64_t>,  "unsigned (two >=32, s/u)");
-static_assert(is_same_type<decltype(int64_t{0}  - uint32_t{0}), int64_t>,  "unsigned (two >=32, u/s)");
-
-// subtract (reversed)
-static_assert(is_same_type<decltype(char{0}     - uint8_t{0}),  int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint8_t{0}  - uint8_t{0}),  int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint16_t{0} - uint8_t{0}),  int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint32_t{0} - uint16_t{0}), uint32_t>, "widest   (one >=32)");
-static_assert(is_same_type<decltype(uint64_t{0} - uint32_t{0}), uint64_t>, "widest   (two >=32)");
-static_assert(is_same_type<decltype(uint64_t{0} - uint64_t{0}), uint64_t>, "widest   (two >=32)");
-static_assert(is_same_type<decltype(bool{false} - uint8_t{0}),  int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(int8_t{0}   - uint8_t{0}),  int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(int16_t{0}  - uint8_t{0}),  int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(int32_t{0}  - uint16_t{0}), int32_t>,  "widest   (one >=32)");
-static_assert(is_same_type<decltype(int64_t{0}  - uint32_t{0}), int64_t>,  "unsigned (two >=32, s-u)");
-static_assert(is_same_type<decltype(uint32_t{0} - int64_t{0}),  int64_t>,  "unsigned (two >=32, u-s)");
-
-// multiply
-static_assert(is_same_type<decltype(uint8_t{0}  * char{0}),     int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint8_t{0}  * uint8_t{0}),  int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint8_t{0}  * uint16_t{0}), int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint16_t{0} * uint32_t{0}), uint32_t>, "widest   (one >=32)");
-static_assert(is_same_type<decltype(uint32_t{0} * uint64_t{0}), uint64_t>, "widest   (two >=32)");
-static_assert(is_same_type<decltype(uint64_t{0} * uint64_t{0}), uint64_t>, "widest   (two >=32)");
-static_assert(is_same_type<decltype(uint8_t{0}  * bool{false}), int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint8_t{0}  * int8_t{0}),   int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint8_t{0}  * int16_t{0}),  int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint16_t{0} * int32_t{0}),  int32_t>,  "widest   (one >=32)");
-static_assert(is_same_type<decltype(uint32_t{0} * int64_t{0}),  int64_t>,  "unsigned (two >=32, s/u)");
-static_assert(is_same_type<decltype(int64_t{0}  * uint32_t{0}), int64_t>,  "unsigned (two >=32, u/s)");
-
-// divide
-static_assert(is_same_type<decltype(uint8_t{0}  / char{1}),     int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint8_t{0}  / uint8_t{1}),  int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint8_t{0}  / uint16_t{1}), int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint16_t{0} / uint32_t{1}), uint32_t>, "widest   (one >=32)");
-static_assert(is_same_type<decltype(uint32_t{0} / uint64_t{1}), uint64_t>, "widest   (two >=32)");
-static_assert(is_same_type<decltype(uint64_t{0} / uint64_t{1}), uint64_t>, "widest   (two >=32)");
-////static_assert(is_same_type<decltype(uint8_t{0}  / bool{true}),  int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint8_t{0}  / int8_t{1}),   int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint8_t{0}  / int16_t{1}),  int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint16_t{0} / int32_t{1}),  int32_t>,  "widest   (one >=32)");
-static_assert(is_same_type<decltype(uint32_t{0} / int64_t{1}),  int64_t>,  "unsigned (two >=32, s/u)");
-static_assert(is_same_type<decltype(int64_t{0}  / uint32_t{1}), int64_t>,  "unsigned (two >=32, u/s)");
-
-// divide (reversed)
-static_assert(is_same_type<decltype(char{0}     / uint8_t{1}),  int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint8_t{0}  / uint8_t{1}),  int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint16_t{0} / uint8_t{1}),  int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint32_t{0} / uint16_t{1}), uint32_t>, "widest   (one >=32)");
-static_assert(is_same_type<decltype(uint64_t{0} / uint32_t{1}), uint64_t>, "widest   (two >=32)");
-static_assert(is_same_type<decltype(uint64_t{0} / uint64_t{1}), uint64_t>, "widest   (two >=32)");
-////static_assert(is_same_type<decltype(bool{false} / uint8_t{1}),  int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(int8_t{0}   / uint8_t{1}),  int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(int16_t{0}  / uint8_t{1}),  int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(int32_t{0}  / uint16_t{1}), int32_t>,  "widest   (one >=32)");
-static_assert(is_same_type<decltype(int64_t{0}  / uint32_t{1}), int64_t>,  "unsigned (two >=32, s/u)");
-static_assert(is_same_type<decltype(uint32_t{0} / int64_t{1}),  int64_t>,  "unsigned (two >=32, u/s)");
-
-// modulo
-static_assert(is_same_type<decltype(uint8_t{0}  % char{1}),     int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint8_t{0}  % uint8_t{1}),  int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint8_t{0}  % uint16_t{1}), int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint16_t{0} % uint32_t{1}), uint32_t>, "widest   (one >=32)");
-static_assert(is_same_type<decltype(uint32_t{0} % uint64_t{1}), uint64_t>, "widest   (two >=32)");
-static_assert(is_same_type<decltype(uint64_t{0} % uint64_t{1}), uint64_t>, "widest   (two >=32)");
-////static_assert(is_same_type<decltype(uint8_t{0}  % bool{true}),  int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint8_t{0}  % int8_t{1}),   int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint8_t{0}  % int16_t{1}),  int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint16_t{0} % int32_t{1}),  int32_t>,  "widest   (one >=32)");
-static_assert(is_same_type<decltype(uint32_t{0} % int64_t{1}),  int64_t>,  "unsigned (two >=32, s%u)");
-static_assert(is_same_type<decltype(int64_t{0}  % uint32_t{1}), int64_t>,  "unsigned (two >=32, u%s)");
-
-// modulo (reversed)
-static_assert(is_same_type<decltype(char{0}     % uint8_t{1}),  int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint8_t{0}  % uint8_t{1}),  int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint16_t{0} % uint8_t{1}),  int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(uint32_t{0} % uint16_t{1}), uint32_t>, "widest   (one >=32)");
-static_assert(is_same_type<decltype(uint64_t{0} % uint32_t{1}), uint64_t>, "widest   (two >=32)");
-static_assert(is_same_type<decltype(uint64_t{0} % uint64_t{1}), uint64_t>, "widest   (two >=32)");
-////static_assert(is_same_type<decltype(bool{false} % uint8_t{1}),  int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(int8_t{0}   % uint8_t{1}),  int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(int16_t{0}  % uint8_t{1}),  int>,      "promoted (two <32)");
-static_assert(is_same_type<decltype(int32_t{0}  % uint16_t{1}), int32_t>,  "widest   (one >=32)");
-static_assert(is_same_type<decltype(int64_t{0}  % uint32_t{1}), int64_t>,  "unsigned (two >=32, s%u)");
-static_assert(is_same_type<decltype(uint32_t{0} % int64_t{1}),  int64_t>,  "unsigned (two >=32, u%s)");
+// TODO: below can move to static_assert under c++23.
+
+BOOST_AUTO_TEST_SUITE(cast_tests)
+
+template <typename Type>
+using limit = std::numeric_limits<Type>;
+
+// to_integer2/3
+
+BOOST_AUTO_TEST_CASE(cast__to_integer__non_finites__false)
+{
+    size_t value{};
+    BOOST_REQUIRE(!to_integer(value, limit<float>::quiet_NaN()));
+    BOOST_REQUIRE(!to_integer(value, limit<float>::infinity()));
+    BOOST_REQUIRE(!to_integer(value, -limit<float>::infinity()));
+    BOOST_REQUIRE(!to_integer(value, limit<float>::quiet_NaN(), false));
+    BOOST_REQUIRE(!to_integer(value, limit<float>::infinity(), false));
+    BOOST_REQUIRE(!to_integer(value, -limit<float>::infinity(), false));
+}
+
+BOOST_AUTO_TEST_CASE(cast__to_integer__finites__expected)
+{
+    size_t value{};
+    BOOST_REQUIRE(to_integer(value, 1.0, true));
+    BOOST_REQUIRE_EQUAL(value, 1u);
+    BOOST_REQUIRE(to_integer(value, 2.0, false));
+    BOOST_REQUIRE_EQUAL(value, 2u);
+    BOOST_REQUIRE(to_integer(value, 3.1, false));
+    BOOST_REQUIRE_EQUAL(value, 3u);
+    BOOST_REQUIRE(!to_integer(value, 3.1, true));
+}
+
+// to_ceilinged_integer
+
+BOOST_AUTO_TEST_CASE(cast__to_ceilinged_integer__non_finites__max)
+{
+    BOOST_REQUIRE_EQUAL(to_ceilinged_integer<size_t>(limit<double>::quiet_NaN()), max_size_t);
+    BOOST_REQUIRE_EQUAL(to_ceilinged_integer<size_t>(limit<double>::infinity()), max_size_t);
+    BOOST_REQUIRE_EQUAL(to_ceilinged_integer<size_t>(-limit<double>::infinity()), max_size_t);
+}
+
+BOOST_AUTO_TEST_CASE(cast__to_ceilinged_integer__overflow_underflow__clamped)
+{
+    BOOST_REQUIRE_EQUAL(to_ceilinged_integer<size_t>(limit<double>::max()), max_size_t);
+    BOOST_REQUIRE_EQUAL(to_ceilinged_integer<size_t>(-limit<double>::max()), min_size_t);
+    BOOST_REQUIRE_EQUAL(to_ceilinged_integer<int64_t>(limit<double>::max()), max_int64);
+    BOOST_REQUIRE_EQUAL(to_ceilinged_integer<int64_t>(-limit<double>::max()), min_int64);
+}
+
+BOOST_AUTO_TEST_CASE(cast__to_ceilinged_integer__finites__expected)
+{
+    BOOST_REQUIRE_EQUAL(to_ceilinged_integer<size_t>(0.0), 0u);
+    BOOST_REQUIRE_EQUAL(to_ceilinged_integer<size_t>(1.0), 1u);
+    BOOST_REQUIRE_EQUAL(to_ceilinged_integer<size_t>(1.1), 2u);
+    BOOST_REQUIRE_EQUAL(to_ceilinged_integer<size_t>(1.9), 2u);
+    BOOST_REQUIRE_EQUAL(to_ceilinged_integer<size_t>(-0.1), 0u);  // Ceil to 0 for unsigned
+    BOOST_REQUIRE_EQUAL(to_ceilinged_integer<size_t>(-1.1), 0u);  // Clamped to min (0)
+    BOOST_REQUIRE_EQUAL(to_ceilinged_integer<int64_t>(-1.0), -1);
+    BOOST_REQUIRE_EQUAL(to_ceilinged_integer<int64_t>(-1.1), -1);
+    BOOST_REQUIRE_EQUAL(to_ceilinged_integer<int64_t>(-1.9), -1);
+}
+
+// to_floored_integer
+
+BOOST_AUTO_TEST_CASE(cast__to_floored_integer__non_finites__max)
+{
+    BOOST_REQUIRE_EQUAL(to_floored_integer<size_t>(limit<double>::quiet_NaN()), max_size_t);
+    BOOST_REQUIRE_EQUAL(to_floored_integer<size_t>(limit<double>::infinity()), max_size_t);
+    BOOST_REQUIRE_EQUAL(to_floored_integer<size_t>(-limit<double>::infinity()), max_size_t);
+}
+
+BOOST_AUTO_TEST_CASE(cast__to_floored_integer__overflow_underflow__clamped)
+{
+    BOOST_REQUIRE_EQUAL(to_floored_integer<size_t>(limit<double>::max()), max_size_t);
+    BOOST_REQUIRE_EQUAL(to_floored_integer<size_t>(-limit<double>::max()), min_size_t);
+    BOOST_REQUIRE_EQUAL(to_floored_integer<int64_t>(limit<double>::max()), max_int64);
+    BOOST_REQUIRE_EQUAL(to_floored_integer<int64_t>(-limit<double>::max()), min_int64);
+}
+
+BOOST_AUTO_TEST_CASE(cast__to_floored_integer__finites__expected)
+{
+    BOOST_REQUIRE_EQUAL(to_floored_integer<size_t>(0.0), 0u);
+    BOOST_REQUIRE_EQUAL(to_floored_integer<size_t>(1.0), 1u);
+    BOOST_REQUIRE_EQUAL(to_floored_integer<size_t>(1.1), 1u);
+    BOOST_REQUIRE_EQUAL(to_floored_integer<size_t>(1.9), 1u);
+    BOOST_REQUIRE_EQUAL(to_floored_integer<size_t>(-0.1), 0u);  // Floor to -1, but clamped to 0
+    BOOST_REQUIRE_EQUAL(to_floored_integer<size_t>(-1.1), 0u);  // Clamped to min (0)
+    BOOST_REQUIRE_EQUAL(to_floored_integer<int64_t>(-1.0), -1);
+    BOOST_REQUIRE_EQUAL(to_floored_integer<int64_t>(-1.1), -2);
+    BOOST_REQUIRE_EQUAL(to_floored_integer<int64_t>(-1.9), -2);
+}
+
+// to_rounded_integer
+
+BOOST_AUTO_TEST_CASE(cast__to_rounded_integer__non_finites__max)
+{
+    BOOST_REQUIRE_EQUAL(to_rounded_integer<size_t>(limit<double>::quiet_NaN()), max_size_t);
+    BOOST_REQUIRE_EQUAL(to_rounded_integer<size_t>(limit<double>::infinity()), max_size_t);
+    BOOST_REQUIRE_EQUAL(to_rounded_integer<size_t>(-limit<double>::infinity()), max_size_t);
+}
+
+BOOST_AUTO_TEST_CASE(cast__to_rounded_integer__overflow_underflow__clamped)
+{
+    BOOST_REQUIRE_EQUAL(to_rounded_integer<size_t>(limit<double>::max()), max_size_t);
+    BOOST_REQUIRE_EQUAL(to_rounded_integer<size_t>(-limit<double>::max()), min_size_t);
+    BOOST_REQUIRE_EQUAL(to_rounded_integer<int64_t>(limit<double>::max()), max_int64);
+    BOOST_REQUIRE_EQUAL(to_rounded_integer<int64_t>(-limit<double>::max()), min_int64);
+}
+
+BOOST_AUTO_TEST_CASE(cast__to_rounded_integer__finites__expected)
+{
+    BOOST_REQUIRE_EQUAL(to_rounded_integer<size_t>(0.0), 0u);
+    BOOST_REQUIRE_EQUAL(to_rounded_integer<size_t>(1.0), 1u);
+    BOOST_REQUIRE_EQUAL(to_rounded_integer<size_t>(1.1), 1u);
+    BOOST_REQUIRE_EQUAL(to_rounded_integer<size_t>(1.4), 1u);
+    BOOST_REQUIRE_EQUAL(to_rounded_integer<size_t>(1.5), 2u);
+    BOOST_REQUIRE_EQUAL(to_rounded_integer<size_t>(1.6), 2u);
+    BOOST_REQUIRE_EQUAL(to_rounded_integer<size_t>(-0.1), 0u);  // Round to 0
+    BOOST_REQUIRE_EQUAL(to_rounded_integer<size_t>(-0.5), 0u);  // Round to -1, clamped to 0
+    BOOST_REQUIRE_EQUAL(to_rounded_integer<size_t>(-1.1), 0u);  // Clamped to min (0)
+    BOOST_REQUIRE_EQUAL(to_rounded_integer<signed_size_t>(-1.0), -1);
+    BOOST_REQUIRE_EQUAL(to_rounded_integer<signed_size_t>(-1.1), -1);
+    BOOST_REQUIRE_EQUAL(to_rounded_integer<signed_size_t>(-1.4), -1);
+    BOOST_REQUIRE_EQUAL(to_rounded_integer<signed_size_t>(-1.5), -2);
+    BOOST_REQUIRE_EQUAL(to_rounded_integer<signed_size_t>(-1.6), -2);
+    BOOST_REQUIRE_EQUAL(to_rounded_integer<signed_size_t>(-2.5), -3);  // Halfway away from min_size_t
+}
+
+// to_truncated_integer
+
+BOOST_AUTO_TEST_CASE(cast__to_truncated_integer__non_finites__max)
+{
+    BOOST_REQUIRE_EQUAL(to_truncated_integer<size_t>(limit<double>::quiet_NaN()), max_size_t);
+    BOOST_REQUIRE_EQUAL(to_truncated_integer<size_t>(limit<double>::infinity()), max_size_t);
+    BOOST_REQUIRE_EQUAL(to_truncated_integer<size_t>(-limit<double>::infinity()), max_size_t);
+}
+
+BOOST_AUTO_TEST_CASE(cast__to_truncated_integer__overflow_underflow__clamped)
+{
+    BOOST_REQUIRE_EQUAL(to_truncated_integer<size_t>(limit<double>::max()), max_size_t);
+    BOOST_REQUIRE_EQUAL(to_truncated_integer<size_t>(-limit<double>::max()), min_size_t);
+    BOOST_REQUIRE_EQUAL(to_truncated_integer<signed_size_t>(limit<double>::max()), max_signed_size_t);
+    BOOST_REQUIRE_EQUAL(to_truncated_integer<signed_size_t>(-limit<double>::max()), min_signed_size_t);
+}
+
+BOOST_AUTO_TEST_CASE(cast__to_truncated_integer__finites__expected)
+{
+    BOOST_REQUIRE_EQUAL(to_truncated_integer<size_t>(0.0), 0u);
+    BOOST_REQUIRE_EQUAL(to_truncated_integer<size_t>(1.0), 1u);
+    BOOST_REQUIRE_EQUAL(to_truncated_integer<size_t>(1.1), 1u);
+    BOOST_REQUIRE_EQUAL(to_truncated_integer<size_t>(1.9), 1u);
+    BOOST_REQUIRE_EQUAL(to_truncated_integer<size_t>(-0.1), 0u);  // Trunc to 0
+    BOOST_REQUIRE_EQUAL(to_truncated_integer<size_t>(-1.1), 0u);  // Clamped to min (0)
+    BOOST_REQUIRE_EQUAL(to_truncated_integer<signed_size_t>(-1.0), -1);
+    BOOST_REQUIRE_EQUAL(to_truncated_integer<signed_size_t>(-1.1), -1);
+    BOOST_REQUIRE_EQUAL(to_truncated_integer<signed_size_t>(-1.9), -1);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/math/expectations.cpp b/test/math/expectations.cpp
new file mode 100644
index 0000000000..7ef4dbaf9e
--- /dev/null
+++ b/test/math/expectations.cpp
@@ -0,0 +1,298 @@
+/**
+ * Copyright (c) 2011-2025 libbitcoin developers (see AUTHORS)
+ *
+ * This file is part of libbitcoin.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include "../test.hpp"
+
+// Verify compiler "usual arithmetic conversion" expectations.
+// ----------------------------------------------------------------------------
+// Shift works like a unary op (right operand is not incorporated).
+// Order of operands does not affect (other) binary ops.
+// self-assigning (e.g. >>=, /=) ops obviously do not (cannot) promote.
+// ! and comparison are not mathematical ops.
+
+// Unary ops (+/-/~) change to unsigned upon width promotion, not otherwise.
+// + is a unary op and produces promotion.
+// std::common_type does not support unary operators.
+// std::common_type<Left, Right>::type == decltype(left - right)
+// std::common_type<Value>::type != decltype(-value)
+using integer = decltype(-'a');
+using character = std::common_type_t<char>;
+using common_character = std::common_type_t<char, char>;
+static_assert(!is_same_type<integer, character>);
+static_assert(!is_same_type<integer, common_character>);
+
+// Compiler warns on bool safety for -b, ~b, <<b, >>b, /b, %b, b/, b% (assertions disabled).
+
+// invert
+static_assert(is_same_type<decltype(!char{0}),                   bool>, "boolean");
+static_assert(is_same_type<decltype(!int8_t{0}),                 bool>, "boolean");
+static_assert(is_same_type<decltype(!int16_t{0}),                bool>, "boolean");
+static_assert(is_same_type<decltype(!int32_t{0}),                bool>, "boolean");
+static_assert(is_same_type<decltype(!int64_t{0}),                bool>, "boolean");
+static_assert(is_same_type<decltype(!bool{false}),               bool>, "boolean");
+static_assert(is_same_type<decltype(!uint8_t{0}),                bool>, "boolean");
+static_assert(is_same_type<decltype(!uint16_t{0}),               bool>, "boolean");
+static_assert(is_same_type<decltype(!uint32_t{0}),               bool>, "boolean");
+static_assert(is_same_type<decltype(!uint64_t{0}),               bool>, "boolean");
+
+// comparison
+static_assert(is_same_type<decltype(uint8_t{0}  == char{0}),     bool>, "boolean");
+static_assert(is_same_type<decltype(uint8_t{0}  != uint8_t{0}),  bool>, "boolean");
+static_assert(is_same_type<decltype(uint8_t{0}  >= uint16_t{0}), bool>, "boolean");
+static_assert(is_same_type<decltype(uint16_t{0} <= uint32_t{0}), bool>, "boolean");
+static_assert(is_same_type<decltype(uint32_t{0} == uint64_t{0}), bool>, "boolean");
+static_assert(is_same_type<decltype(uint64_t{0} == uint64_t{0}), bool>, "boolean");
+static_assert(is_same_type<decltype(uint8_t{0}  == bool{false}), bool>, "boolean");
+static_assert(is_same_type<decltype(bool{false} == uint32_t{0}), bool>, "boolean");
+static_assert(is_same_type<decltype(uint8_t{0}  == int8_t{0}),   bool>, "boolean");
+static_assert(is_same_type<decltype(uint8_t{0}  == int16_t{0}),  bool>, "boolean");
+static_assert(is_same_type<decltype(uint16_t{0} == int32_t{0}),  bool>, "boolean");
+static_assert(is_same_type<decltype(uint32_t{0} == int64_t{0}),  bool>, "boolean");
+static_assert(is_same_type<decltype(int64_t{0}  == uint32_t{0}), bool>, "boolean");
+
+// positive
+static_assert(is_same_type<decltype(+char{1}),                   int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(+int8_t{1}),                 int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(+int16_t{1}),                int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(+int32_t{1}),                int32_t>,  "unpromoted (>=32");
+static_assert(is_same_type<decltype(+int64_t{1}),                int64_t>,  "unpromoted (>=32");
+static_assert(is_same_type<decltype(+bool{false}),               int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(+uint8_t{1}),                int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(+uint16_t{1}),               int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(+uint32_t{1}),               uint32_t>, "unpromoted (>=32");
+static_assert(is_same_type<decltype(+uint64_t{1}),               uint64_t>, "unpromoted (>=32");
+
+// negate (signed)
+static_assert(is_same_type<decltype(-char{1}),                   int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(-int8_t{1}),                 int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(-int16_t{1}),                int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(-int32_t{1}),                int32_t>,  "unpromoted (>=32");
+static_assert(is_same_type<decltype(-int64_t{1}),                int64_t>,  "unpromoted (>=32");
+////static_assert(is_same_type<decltype(-bool{false}),               int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(-uint8_t{1}),                int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(-uint16_t{1}),               int>,      "promoted   (<32)");
+////static_assert(is_same_type<decltype(-uint32_t{1}),               uint32_t>, "unpromoted (>=32");
+////static_assert(is_same_type<decltype(-uint64_t{1}),               uint64_t>, "unpromoted (>=32");
+
+// negate (unsigned)
+static_assert(is_same_type<decltype(-char{1u}),                  int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(-int8_t{1u}),                int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(-int16_t{1u}),               int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(-int32_t{1u}),               int32_t>,  "unpromoted (>=32");
+static_assert(is_same_type<decltype(-int64_t{1u}),               int64_t>,  "unpromoted (>=32");
+////static_assert(is_same_type<decltype(-bool{false}),               int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(-uint8_t{1u}),               int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(-uint16_t{1u}),              int>,      "promoted   (<32)");
+////static_assert(is_same_type<decltype(-uint32_t{1u}),              uint32_t>, "unpromoted (>=32");
+////static_assert(is_same_type<decltype(-uint64_t{1u}),              uint64_t>, "unpromoted (>=32");
+
+// ones_complement
+static_assert(is_same_type<decltype(~char{0}),                   int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(~int8_t{0}),                 int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(~int16_t{0}),                int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(~int32_t{0}),                int32_t>,  "unpromoted (>=32");
+static_assert(is_same_type<decltype(~int64_t{0}),                int64_t>,  "unpromoted (>=32");
+////static_assert(is_same_type<decltype(~bool{false}),               int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(~uint8_t{0}),                int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(~uint16_t{0}),               int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(~uint32_t{0}),               uint32_t>, "unpromoted (>=32");
+static_assert(is_same_type<decltype(~uint64_t{0}),               uint64_t>, "unpromoted (>=32");
+
+// shift_left
+static_assert(is_same_type<decltype(uint8_t{0}  << char{0}),     int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(uint8_t{0}  << uint8_t{0}),  int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(uint8_t{0}  << uint16_t{0}), int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(uint16_t{0} << uint32_t{0}), int >,     "promoted   (<32)");
+static_assert(is_same_type<decltype(uint32_t{0} << uint64_t{0}), uint32_t>, "unpromoted (>=32");
+static_assert(is_same_type<decltype(uint64_t{0} << uint64_t{0}), uint64_t>, "unpromoted (>=32");
+////static_assert(is_same_type<decltype(uint8_t{0}  << bool{false}), int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(bool{false} << uint32_t{0}), int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(uint8_t{0}  << int8_t{0}),   int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(uint8_t{0}  << int16_t{0}),  int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(uint16_t{0} << int32_t{0}),  int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(uint32_t{0} << int64_t{0}),  uint32_t>, "unpromoted (>=32");
+static_assert(is_same_type<decltype(int64_t{0}  << uint32_t{0}), int64_t>,  "unpromoted (>=32");
+
+// shift_right
+static_assert(is_same_type<decltype(uint8_t{0}  >> char{0}),     int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(uint8_t{0}  >> uint8_t{0}),  int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(uint8_t{0}  >> uint16_t{0}), int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(uint16_t{0} >> uint32_t{0}), int >,     "promoted   (<32)");
+static_assert(is_same_type<decltype(uint32_t{0} >> uint64_t{0}), uint32_t>, "unpromoted (>=32");
+static_assert(is_same_type<decltype(uint64_t{0} >> uint64_t{0}), uint64_t>, "unpromoted (>=32");
+////static_assert(is_same_type<decltype(uint8_t{0}  >> bool{false}), int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(bool{false} >> uint32_t{0}), int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(uint8_t{0}  >> int8_t{0}),   int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(uint8_t{0}  >> int16_t{0}),  int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(uint16_t{0} >> int32_t{0}),  int>,      "promoted   (<32)");
+static_assert(is_same_type<decltype(uint32_t{0} >> int64_t{0}),  uint32_t>, "unpromoted (>=32");
+static_assert(is_same_type<decltype(int64_t{0}  >> uint32_t{0}), int64_t>,  "unpromoted (>=32");
+
+// bit_and
+static_assert(is_same_type<decltype(uint8_t{0}  & char{0}),     int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint8_t{0}  & uint8_t{0}),  int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint8_t{0}  & uint16_t{0}), int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint16_t{0} & uint32_t{0}), uint32_t>, "widest   (one >=32)");
+static_assert(is_same_type<decltype(uint32_t{0} & uint64_t{0}), uint64_t>, "widest   (two >=32)");
+static_assert(is_same_type<decltype(uint64_t{0} & uint64_t{0}), uint64_t>, "widest   (two >=32)");
+static_assert(is_same_type<decltype(uint8_t{0}  & bool{false}), int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint8_t{0}  & int8_t{0}),   int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint8_t{0}  & int16_t{0}),  int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint16_t{0} & int32_t{0}),  int32_t>,  "widest   (one >=32)");
+static_assert(is_same_type<decltype(uint32_t{0} & int64_t{0}),  int64_t>,  "unsigned (two >=32, s/u)");
+static_assert(is_same_type<decltype(int64_t{0}  & uint32_t{0}), int64_t>,  "unsigned (two >=32, u/s)");
+
+// bit_or
+static_assert(is_same_type<decltype(uint8_t{0}  | char{0}),     int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint8_t{0}  | uint8_t{0}),  int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint8_t{0}  | uint16_t{0}), int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint16_t{0} | uint32_t{0}), uint32_t>, "widest   (one >=32)");
+static_assert(is_same_type<decltype(uint32_t{0} | uint64_t{0}), uint64_t>, "widest   (two >=32)");
+static_assert(is_same_type<decltype(uint64_t{0} | uint64_t{0}), uint64_t>, "widest   (two >=32)");
+static_assert(is_same_type<decltype(uint8_t{0}  | bool{false}), int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint8_t{0}  | int8_t{0}),   int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint8_t{0}  | int16_t{0}),  int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint16_t{0} | int32_t{0}),  int32_t>,  "widest   (one >=32)");
+static_assert(is_same_type<decltype(uint32_t{0} | int64_t{0}),  int64_t>,  "unsigned (two >=32, s/u)");
+static_assert(is_same_type<decltype(int64_t{0}  | uint32_t{0}), int64_t>,  "unsigned (two >=32, u/s)");
+
+// bit_xor
+static_assert(is_same_type<decltype(uint8_t{0}  ^ char{0}),     int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint8_t{0}  ^ uint8_t{0}),  int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint8_t{0}  ^ uint16_t{0}), int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint16_t{0} ^ uint32_t{0}), uint32_t>, "widest   (one >=32)");
+static_assert(is_same_type<decltype(uint32_t{0} ^ uint64_t{0}), uint64_t>, "widest   (two >=32)");
+static_assert(is_same_type<decltype(uint64_t{0} ^ uint64_t{0}), uint64_t>, "widest   (two >=32)");
+static_assert(is_same_type<decltype(uint8_t{0}  ^ bool{false}), int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint8_t{0}  ^ int8_t{0}),   int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint8_t{0}  ^ int16_t{0}),  int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint16_t{0} ^ int32_t{0}),  int32_t>,  "widest   (one >=32)");
+static_assert(is_same_type<decltype(uint32_t{0} ^ int64_t{0}),  int64_t>,  "unsigned (two >=32, s/u)");
+static_assert(is_same_type<decltype(int64_t{0}  ^ uint32_t{0}), int64_t>,  "unsigned (two >=32, u/s)");
+
+// add
+static_assert(is_same_type<decltype(uint8_t{0}  + char{0}),     int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint8_t{0}  + uint8_t{0}),  int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint8_t{0}  + uint16_t{0}), int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint16_t{0} + uint32_t{0}), uint32_t>, "widest   (one >=32)");
+static_assert(is_same_type<decltype(uint32_t{0} + uint64_t{0}), uint64_t>, "widest   (two >=32)");
+static_assert(is_same_type<decltype(uint64_t{0} + uint64_t{0}), uint64_t>, "widest   (two >=32)");
+static_assert(is_same_type<decltype(uint8_t{0}  + bool{false}), int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint8_t{0}  + int8_t{0}),   int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint8_t{0}  + int16_t{0}),  int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint16_t{0} + int32_t{0}),  int32_t>,  "widest   (one >=32)");
+static_assert(is_same_type<decltype(uint32_t{0} + int64_t{0}),  int64_t>,  "unsigned (two >=32, s/u)");
+static_assert(is_same_type<decltype(int64_t{0}  + uint32_t{0}), int64_t>,  "unsigned (two >=32, u/s)");
+
+// subtract
+static_assert(is_same_type<decltype(uint8_t{0}  - char{0}),     int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint8_t{0}  - uint8_t{0}),  int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint8_t{0}  - uint16_t{0}), int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint16_t{0} - uint32_t{0}), uint32_t>, "widest   (one >=32)");
+static_assert(is_same_type<decltype(uint32_t{0} - uint64_t{0}), uint64_t>, "widest   (two >=32)");
+static_assert(is_same_type<decltype(uint64_t{0} - uint64_t{0}), uint64_t>, "widest   (two >=32)");
+static_assert(is_same_type<decltype(uint8_t{0}  - bool{false}), int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint8_t{0}  - int8_t{0}),   int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint8_t{0}  - int16_t{0}),  int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint16_t{0} - int32_t{0}),  int32_t>,  "widest   (one >=32)");
+static_assert(is_same_type<decltype(uint32_t{0} - int64_t{0}),  int64_t>,  "unsigned (two >=32, s/u)");
+static_assert(is_same_type<decltype(int64_t{0}  - uint32_t{0}), int64_t>,  "unsigned (two >=32, u/s)");
+
+// subtract (reversed)
+static_assert(is_same_type<decltype(char{0}     - uint8_t{0}),  int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint8_t{0}  - uint8_t{0}),  int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint16_t{0} - uint8_t{0}),  int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint32_t{0} - uint16_t{0}), uint32_t>, "widest   (one >=32)");
+static_assert(is_same_type<decltype(uint64_t{0} - uint32_t{0}), uint64_t>, "widest   (two >=32)");
+static_assert(is_same_type<decltype(uint64_t{0} - uint64_t{0}), uint64_t>, "widest   (two >=32)");
+static_assert(is_same_type<decltype(bool{false} - uint8_t{0}),  int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(int8_t{0}   - uint8_t{0}),  int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(int16_t{0}  - uint8_t{0}),  int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(int32_t{0}  - uint16_t{0}), int32_t>,  "widest   (one >=32)");
+static_assert(is_same_type<decltype(int64_t{0}  - uint32_t{0}), int64_t>,  "unsigned (two >=32, s-u)");
+static_assert(is_same_type<decltype(uint32_t{0} - int64_t{0}),  int64_t>,  "unsigned (two >=32, u-s)");
+
+// multiply
+static_assert(is_same_type<decltype(uint8_t{0}  * char{0}),     int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint8_t{0}  * uint8_t{0}),  int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint8_t{0}  * uint16_t{0}), int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint16_t{0} * uint32_t{0}), uint32_t>, "widest   (one >=32)");
+static_assert(is_same_type<decltype(uint32_t{0} * uint64_t{0}), uint64_t>, "widest   (two >=32)");
+static_assert(is_same_type<decltype(uint64_t{0} * uint64_t{0}), uint64_t>, "widest   (two >=32)");
+static_assert(is_same_type<decltype(uint8_t{0}  * bool{false}), int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint8_t{0}  * int8_t{0}),   int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint8_t{0}  * int16_t{0}),  int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint16_t{0} * int32_t{0}),  int32_t>,  "widest   (one >=32)");
+static_assert(is_same_type<decltype(uint32_t{0} * int64_t{0}),  int64_t>,  "unsigned (two >=32, s/u)");
+static_assert(is_same_type<decltype(int64_t{0}  * uint32_t{0}), int64_t>,  "unsigned (two >=32, u/s)");
+
+// divide
+static_assert(is_same_type<decltype(uint8_t{0}  / char{1}),     int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint8_t{0}  / uint8_t{1}),  int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint8_t{0}  / uint16_t{1}), int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint16_t{0} / uint32_t{1}), uint32_t>, "widest   (one >=32)");
+static_assert(is_same_type<decltype(uint32_t{0} / uint64_t{1}), uint64_t>, "widest   (two >=32)");
+static_assert(is_same_type<decltype(uint64_t{0} / uint64_t{1}), uint64_t>, "widest   (two >=32)");
+////static_assert(is_same_type<decltype(uint8_t{0}  / bool{true}),  int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint8_t{0}  / int8_t{1}),   int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint8_t{0}  / int16_t{1}),  int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint16_t{0} / int32_t{1}),  int32_t>,  "widest   (one >=32)");
+static_assert(is_same_type<decltype(uint32_t{0} / int64_t{1}),  int64_t>,  "unsigned (two >=32, s/u)");
+static_assert(is_same_type<decltype(int64_t{0}  / uint32_t{1}), int64_t>,  "unsigned (two >=32, u/s)");
+
+// divide (reversed)
+static_assert(is_same_type<decltype(char{0}     / uint8_t{1}),  int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint8_t{0}  / uint8_t{1}),  int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint16_t{0} / uint8_t{1}),  int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint32_t{0} / uint16_t{1}), uint32_t>, "widest   (one >=32)");
+static_assert(is_same_type<decltype(uint64_t{0} / uint32_t{1}), uint64_t>, "widest   (two >=32)");
+static_assert(is_same_type<decltype(uint64_t{0} / uint64_t{1}), uint64_t>, "widest   (two >=32)");
+////static_assert(is_same_type<decltype(bool{false} / uint8_t{1}),  int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(int8_t{0}   / uint8_t{1}),  int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(int16_t{0}  / uint8_t{1}),  int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(int32_t{0}  / uint16_t{1}), int32_t>,  "widest   (one >=32)");
+static_assert(is_same_type<decltype(int64_t{0}  / uint32_t{1}), int64_t>,  "unsigned (two >=32, s/u)");
+static_assert(is_same_type<decltype(uint32_t{0} / int64_t{1}),  int64_t>,  "unsigned (two >=32, u/s)");
+
+// modulo
+static_assert(is_same_type<decltype(uint8_t{0}  % char{1}),     int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint8_t{0}  % uint8_t{1}),  int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint8_t{0}  % uint16_t{1}), int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint16_t{0} % uint32_t{1}), uint32_t>, "widest   (one >=32)");
+static_assert(is_same_type<decltype(uint32_t{0} % uint64_t{1}), uint64_t>, "widest   (two >=32)");
+static_assert(is_same_type<decltype(uint64_t{0} % uint64_t{1}), uint64_t>, "widest   (two >=32)");
+////static_assert(is_same_type<decltype(uint8_t{0}  % bool{true}),  int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint8_t{0}  % int8_t{1}),   int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint8_t{0}  % int16_t{1}),  int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint16_t{0} % int32_t{1}),  int32_t>,  "widest   (one >=32)");
+static_assert(is_same_type<decltype(uint32_t{0} % int64_t{1}),  int64_t>,  "unsigned (two >=32, s%u)");
+static_assert(is_same_type<decltype(int64_t{0}  % uint32_t{1}), int64_t>,  "unsigned (two >=32, u%s)");
+
+// modulo (reversed)
+static_assert(is_same_type<decltype(char{0}     % uint8_t{1}),  int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint8_t{0}  % uint8_t{1}),  int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint16_t{0} % uint8_t{1}),  int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(uint32_t{0} % uint16_t{1}), uint32_t>, "widest   (one >=32)");
+static_assert(is_same_type<decltype(uint64_t{0} % uint32_t{1}), uint64_t>, "widest   (two >=32)");
+static_assert(is_same_type<decltype(uint64_t{0} % uint64_t{1}), uint64_t>, "widest   (two >=32)");
+////static_assert(is_same_type<decltype(bool{false} % uint8_t{1}),  int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(int8_t{0}   % uint8_t{1}),  int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(int16_t{0}  % uint8_t{1}),  int>,      "promoted (two <32)");
+static_assert(is_same_type<decltype(int32_t{0}  % uint16_t{1}), int32_t>,  "widest   (one >=32)");
+static_assert(is_same_type<decltype(int64_t{0}  % uint32_t{1}), int64_t>,  "unsigned (two >=32, s%u)");
+static_assert(is_same_type<decltype(uint32_t{0} % int64_t{1}),  int64_t>,  "unsigned (two >=32, u%s)");