Add to_integer and to_floating casts.

Author: evoskuil

include/bitcoin/system/constraints.hpp

@@ -216,7 +216,7 @@ using if_integral_integer = bool_if<
 
 template <typename Type>
 using if_non_integral_integer = bool_if<
-    !is_integral<Type>  &&
+    !is_integral<Type> &&
     is_integer<Type>>;
 
 template <typename Type>
@@ -251,6 +251,10 @@ using if_little_endian_integral_integer = bool_if<
     is_integral_integer<Integer> &&
     is_little_endian>;
 
+template <typename Integer>
+using if_floating_point = bool_if<
+    is_floating_point<Integer>>;
+
 /// std::array/std::vector
 
 template <typename Type>

include/bitcoin/system/impl/math/cast.ipp

@@ -206,6 +206,31 @@ constexpr Unsigned to_unsigned(Unsigned value) NOEXCEPT
     return value;
 }
 
+// Floating point casts.
+// ----------------------------------------------------------------------------
+
+template <typename Integer, typename Float,
+    if_integral_integer<Integer>,
+    if_floating_point<Float>>
+constexpr Integer to_integer(Float value) NOEXCEPT
+{
+    // Floating point conversion in c++ requires explicit or implicit cast.
+    BC_PUSH_WARNING(NO_CASTS_FOR_ARITHMETIC_CONVERSION)
+    return static_cast<Integer>(value);
+    BC_POP_WARNING()
+}
+
+template <typename Float, typename Integer,
+    if_floating_point<Float>,
+    if_integral_integer<Integer>>
+constexpr Float to_floating(Integer value) NOEXCEPT
+{
+    // Floating point conversion in c++ requires explicit or implicit cast.
+    BC_PUSH_WARNING(NO_CASTS_FOR_ARITHMETIC_CONVERSION)
+    return static_cast<Float>(value);
+    BC_POP_WARNING()
+}
+
 } // namespace system
 } // namespace libbitcoin
 

include/bitcoin/system/math/cast.hpp

@@ -139,6 +139,21 @@ constexpr to_unsigned_type<Signed> to_unsigned(Signed value) NOEXCEPT;
 template <typename Unsigned, if_unsigned_integer<Unsigned> = true>
 constexpr Unsigned to_unsigned(Unsigned value) NOEXCEPT;
 
+/// Floating point casts.
+/// ---------------------------------------------------------------------------
+
+/// Cast floating point to integral integer, overflow 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.
+template <typename Float = double, typename Integer,
+    if_floating_point<Float> = true,
+    if_integral_integer<Integer> = true>
+constexpr Float to_floating(Integer value) NOEXCEPT;
+
 } // namespace system
 } // namespace libbitcoin
 

include/bitcoin/system/typelets.hpp

@@ -74,6 +74,11 @@ constexpr bool is_integer = std::numeric_limits<std::decay_t<Type>>::is_integer
 template <typename Type>
 constexpr bool is_integral_integer = is_integral<Type> /*&& is_integer<Type>*/;
 
+/// numeric_limits may be specialized by non-integrals (such as uintx).
+template <typename Type>
+constexpr bool is_floating_point =
+    std::is_floating_point_v<std::decay_t<Type>>;
+
 /// Constrained to is_integral types.
 template <typename Type, std::enable_if_t<is_integral_size<Type>, bool> = true>
 constexpr size_t bits = to_bits(sizeof(Type));

test/constraints.cpp

@@ -622,6 +622,13 @@ static_assert(is_defined<if_not_same_signed_integral_integer<int, size_t>>);
 ////static_assert(is_defined<if_big_endian_integral_integer<uint8_t>>);
 ////static_assert(is_defined<if_little_endian_integral_integer<uint8_t>>);
 
+////static_assert(!is_defined<if_floating_point<int>>);
+////static_assert(!is_defined<if_floating_point<bool>>);
+static_assert(is_defined<if_floating_point<float>>);
+static_assert(is_defined<if_floating_point<const float>>);
+static_assert(is_defined<if_floating_point<double>>);
+static_assert(is_defined<if_floating_point<long double>>);
+
 // std_array/std_vector
 
 static_assert(is_defined<if_std_array<std_array<uint8_t, 0>>>);

test/math/cast.cpp

@@ -62,6 +62,20 @@ static_assert(is_same_type<decltype(to_unsigned(0u)), unsigned>);
 static_assert(is_same_type<decltype(to_unsigned(1)), unsigned>);
 static_assert(is_same_type<decltype(to_unsigned(1u)), unsigned>);
 
+static_assert(to_integer(1.0f) == 1_size);
+static_assert(to_integer<int>(1.0f) == 1u);
+static_assert(to_integer<unsigned>(2.0) == 2u);
+static_assert(is_same_type<decltype(to_integer(1.0f)), size_t>);
+static_assert(is_same_type<decltype(to_integer<int>(1.0f)), int>);
+static_assert(is_same_type<decltype(to_integer<unsigned>(1.0)), unsigned>);
+
+static_assert(to_floating(1u) == 1.0);
+static_assert(to_floating<float>(1u) == 1.0f);
+static_assert(to_floating<double>(2u) == 2.0);
+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).

test/typelets.cpp

@@ -209,6 +209,27 @@ static_assert(!is_integral_integer<bool>);
 static_assert(!is_integral_integer<std::string>);
 static_assert(is_same_type<decltype(is_integral_integer<int32_t>), const bool>);
 
+static_assert(!is_floating_point<uintx>);
+static_assert(!is_floating_point<uint128_t>);
+static_assert(!is_floating_point<uint8_t>);
+static_assert(!is_floating_point<uint16_t>);
+static_assert(!is_floating_point<uint32_t>);
+static_assert(!is_floating_point<uint64_t>);
+static_assert(!is_floating_point<size_t>);
+static_assert(!is_floating_point<int8_t>);
+static_assert(!is_floating_point<int16_t>);
+static_assert(!is_floating_point<int32_t>);
+static_assert(!is_floating_point<int64_t>);
+static_assert(!is_floating_point<char>);
+static_assert(!is_floating_point<wchar_t>);
+static_assert(!is_floating_point<bool>);
+static_assert(!is_floating_point<std::string>);
+static_assert(is_floating_point<float>);
+static_assert(is_floating_point<const float>);
+static_assert(is_floating_point<double>);
+static_assert(is_floating_point<long double>);
+static_assert(is_same_type<decltype(is_floating_point<float>), const bool>);
+
 // These may be unexpected, which is why we generally avoid them.
 static_assert(sizeof(bool) >= 1u);
 ////static_assert(bits<bool> >= 1u);