Add f32::from(int) and f64::from(int) when they are lossless

Part of #221.

Author: danakj

sus/num/__private/float_methods.inc

@@ -147,17 +147,17 @@ constexpr inline _self(P v) noexcept : primitive_value(v) {}
 /// #[doc.overloads=from.float]
 template <Float F>
   requires(::sus::mem::size_of<F>() <= ::sus::mem::size_of<_primitive>())
-sus_pure static constexpr _self from(F f) noexcept {
-  return _self(f);
+sus_pure static constexpr _self from(F v) noexcept {
+  return _self(v);
 }
 
 /// Construction from primitive floating point types where no bits are lost.
 ///
-/// #[doc.overloads=from.primitivefloat]
-template <PrimitiveFloat F>
-  requires(::sus::mem::size_of<F>() <= ::sus::mem::size_of<_primitive>())
-sus_pure static constexpr _self from(F f) noexcept {
-  return _self(f);
+/// #[doc.overloads=from.primitive_float]
+template <PrimitiveFloat P>
+  requires(::sus::mem::size_of<P>() <= ::sus::mem::size_of<_primitive>())
+sus_pure static constexpr _self from(P v) noexcept {
+  return _self(v);
 }
 
 /// Assignment from floating point types where no bits are lost.
@@ -180,6 +180,32 @@ constexpr inline _self& operator=(P v) noexcept {
   return *this;
 }
 
+/// Construction from integer types where no bits are lost.
+///
+/// For [`f32`]($sus::num::f32) this includes integer types up to 16 bits.
+/// For [`f64`]($sus::num::f64) this includes integer types up to 32 bits.
+///
+/// #[doc.overloads=from.int]
+template <Integer I>
+  requires(::sus::mem::size_of<I>() * 8 <=
+           __private::num_mantissa_digits<_primitive>())
+sus_pure static constexpr _self from(I v) noexcept {
+  return _self(static_cast<_primitive>(v.primitive_value));
+}
+
+/// Construction from integer types where no bits are lost.
+///
+/// For [`f32`]($sus::num::f32) this includes integer types up to 16 bits.
+/// For [`f64`]($sus::num::f64) this includes integer types up to 32 bits.
+///
+/// #[doc.overloads=from.primitive_int]
+template <PrimitiveInteger P>
+  requires(::sus::mem::size_of<P>() * 8 <=
+           __private::num_mantissa_digits<_primitive>())
+sus_pure static constexpr _self from(P v) noexcept {
+  return _self(static_cast<_primitive>(v));
+}
+
 /// Constructs a [`@doc.self `]($sus::num::@doc.self) from an
 /// [`Iterator`]($sus::iter::Iterator) by computing the sum of all elements in
 /// the iterator.

sus/num/f32_unittest.cc

@@ -228,6 +228,47 @@ TEST(f32, ToPrimitive) {
   static_assert(NotConvertible<f32, size_t>);
 }
 
+TEST(f32, From) {
+  static_assert(sus::construct::From<f32, bool>);
+  static_assert(sus::construct::From<f32, char>);
+  static_assert(sus::construct::From<f32, unsigned char>);
+  static_assert(sus::construct::From<f32, signed char>);
+  static_assert(sus::construct::From<f32, int8_t>);
+  static_assert(sus::construct::From<f32, int16_t>);
+  static_assert(!sus::construct::From<f32, int32_t>);
+  static_assert(!sus::construct::From<f32, int64_t>);
+  static_assert(sus::construct::From<f32, uint8_t>);
+  static_assert(sus::construct::From<f32, uint16_t>);
+  static_assert(!sus::construct::From<f32, uint32_t>);
+  static_assert(!sus::construct::From<f32, uint64_t>);
+  static_assert(!sus::construct::From<f32, size_t>);
+  static_assert(!sus::construct::From<f32, uintptr_t>);
+
+  static_assert(sus::construct::From<f32, i8>);
+  static_assert(sus::construct::From<f32, i16>);
+  static_assert(!sus::construct::From<f32, i32>);
+  static_assert(!sus::construct::From<f32, i64>);
+  static_assert(!sus::construct::From<f32, isize>);
+  static_assert(sus::construct::From<f32, u8>);
+  static_assert(sus::construct::From<f32, u16>);
+  static_assert(!sus::construct::From<f32, u32>);
+  static_assert(!sus::construct::From<f32, u64>);
+  static_assert(!sus::construct::From<f32, usize>);
+  static_assert(!sus::construct::From<f32, uptr>);
+
+  static_assert(f32::from(true) == 1_f32);
+  static_assert(f32::from(int16_t{-33}) == -33_f32);
+  static_assert(f32::from(-33_i16) == -33_f32);
+  static_assert(f32::from(int16_t{33}) == 33_f32);
+  static_assert(f32::from(33_u16) == 33_f32);
+
+  EXPECT_EQ(f32::from(true), 1_f32);
+  EXPECT_EQ(f32::from(int16_t{-33}), -33_f32);
+  EXPECT_EQ(f32::from(-33_i16), -33_f32);
+  EXPECT_EQ(f32::from(int16_t{33}), 33_f32);
+  EXPECT_EQ(f32::from(33_u16), 33_f32);
+}
+
 TEST(f32, Negate) {
   constexpr auto a = -(0.345_f32);
   EXPECT_EQ(a, f32(-0.345f));

sus/num/f64_unittest.cc

@@ -228,6 +228,59 @@ TEST(f64, ToPrimitive) {
   static_assert(NotConvertible<f64, size_t>);
 }
 
+TEST(f64, From) {
+  static_assert(sus::construct::From<f64, bool>);
+  static_assert(sus::construct::From<f64, char>);
+  static_assert(sus::construct::From<f64, unsigned char>);
+  static_assert(sus::construct::From<f64, signed char>);
+  static_assert(sus::construct::From<f64, int8_t>);
+  static_assert(sus::construct::From<f64, int16_t>);
+  static_assert(sus::construct::From<f64, int32_t>);
+  static_assert(!sus::construct::From<f64, int64_t>);
+  static_assert(sus::construct::From<f64, uint8_t>);
+  static_assert(sus::construct::From<f64, uint16_t>);
+  static_assert(sus::construct::From<f64, uint32_t>);
+  static_assert(!sus::construct::From<f64, uint64_t>);
+  static_assert((sizeof(size_t) <= sizeof(u32)) ==
+                sus::construct::From<f64, size_t>);
+  static_assert((sizeof(uintptr_t) <= sizeof(u32)) ==
+                sus::construct::From<f64, uintptr_t>);
+
+  static_assert(sus::construct::From<f64, i8>);
+  static_assert(sus::construct::From<f64, i16>);
+  static_assert(sus::construct::From<f64, i32>);
+  static_assert(!sus::construct::From<f64, i64>);
+  static_assert(!sus::construct::From<f64, isize>);
+  static_assert(sus::construct::From<f64, u8>);
+  static_assert(sus::construct::From<f64, u16>);
+  static_assert(sus::construct::From<f64, u32>);
+  static_assert(!sus::construct::From<f64, u64>);
+  static_assert((sizeof(usize) <= sizeof(u32)) ==
+                sus::construct::From<f64, usize>);
+  static_assert((sizeof(uptr) <= sizeof(u32)) ==
+                sus::construct::From<f64, uptr>);
+
+  static_assert(f64::from(true) == 1_f64);
+  static_assert(f64::from(int16_t{-33}) == -33_f64);
+  static_assert(f64::from(-33_i16) == -33_f64);
+  static_assert(f64::from(int16_t{33}) == 33_f64);
+  static_assert(f64::from(33_u16) == 33_f64);
+  static_assert(f64::from(int32_t{-33}) == -33_f64);
+  static_assert(f64::from(-33_i32) == -33_f64);
+  static_assert(f64::from(int32_t{33}) == 33_f64);
+  static_assert(f64::from(33_u32) == 33_f64);
+
+  EXPECT_EQ(f64::from(true), 1_f64);
+  EXPECT_EQ(f64::from(int16_t{-33}), -33_f64);
+  EXPECT_EQ(f64::from(-33_i16), -33_f64);
+  EXPECT_EQ(f64::from(int16_t{33}), 33_f64);
+  EXPECT_EQ(f64::from(33_u16), 33_f64);
+  EXPECT_EQ(f64::from(int32_t{-33}), -33_f64);
+  EXPECT_EQ(f64::from(-33_i32), -33_f64);
+  EXPECT_EQ(f64::from(int32_t{33}), 33_f64);
+  EXPECT_EQ(f64::from(33_u32), 33_f64);
+}
+
 TEST(f64, Negate) {
   constexpr auto a = -(0.345_f64);
   EXPECT_EQ(a, f64(-0.345));