Fix #580 by using a fixed-point implementation for unit conversions using integer representations

src/core/include/mp-units/bits/fixed_point.h

@@ -301,6 +301,12 @@ using min_width_uint_t =
 template<std::size_t N>
 using min_width_int_t = make_signed_t<min_width_uint_t<N>>;
 
+// TODO: other standard floating point types (half-width floats?)
+template<std::size_t N>
+using min_digit_float_t =
+  std::conditional_t<(N <= std::numeric_limits<float>::digits), float,
+                     std::conditional_t<(N <= std::numeric_limits<double>::digits), double, long double>>;
+
 template<typename T>
 using double_width_int_for_t = std::conditional_t<is_signed_v<T>, min_width_int_t<integer_rep_width_v<T> * 2>,
                                                   min_width_uint_t<integer_rep_width_v<T> * 2>>;

src/core/include/mp-units/bits/scaling.h

@@ -46,7 +46,7 @@ using minimal_floating_point_type =
 template<typename To, typename T>
 constexpr auto cast_integral(const T& value)
 {
-  if constexpr (std::is_integral_v<T>) {
+  if constexpr (std::is_integral_v<value_type_t<T>>) {
     return static_cast<To>(value);
   } else {
     return value;
@@ -63,8 +63,10 @@ struct floating_point_scaling_factor_type {
 template<std::floating_point T>
 struct floating_point_scaling_factor_type<T> : std::type_identity<T> {};
 
+// try to choose the smallest standard floating-point type which can represent the integer exactly (has at least as many
+// mantiassa bits as the integer is wide)
 template<std::integral T>
-struct floating_point_scaling_factor_type<T> : std::common_type<T, float> {};
+struct floating_point_scaling_factor_type<T> : std::type_identity<min_digit_float_t<std::numeric_limits<T>::digits>> {};
 
 template<typename T>
   requires requires { typename scaling_traits<T>::floating_point_scaling_factor_type; }
@@ -74,8 +76,6 @@ struct floating_point_scaling_factor_type<T> :
 
 template<Magnitude auto M>
 struct floating_point_scaling_impl {
-  static constexpr Magnitude auto num = _numerator(M);
-  static constexpr Magnitude auto den = _denominator(M);
   template<typename T>
   static constexpr T ratio = [] {
     using U = long double;
@@ -88,9 +88,9 @@ struct floating_point_scaling_impl {
     using U = minimal_floating_point_type<typename floating_point_scaling_factor_type<To>::type,
                                           typename floating_point_scaling_factor_type<From>::type>;
     if constexpr (_is_integral(M)) {
-      return static_cast<To>(cast_integral<U>(value) * _get_value<U>(num));
+      return static_cast<To>(cast_integral<U>(value) * _get_value<U>(M));
     } else if constexpr (_is_integral(_pow<-1>(M))) {
-      return static_cast<To>(cast_integral<U>(value) / _get_value<U>(den));
+      return static_cast<To>(cast_integral<U>(value) / _get_value<U>(_pow<-1>(M)));
     } else {
       return static_cast<To>(cast_integral<U>(value) * ratio<U>);
     }
@@ -118,7 +118,7 @@ struct floating_point_scaling_traits {
   static constexpr Rep scale_from(M, const From& value)
   {
     return floating_point_scaling_impl<M{}>::template scale<Rep>(value);
-  };
+  }
 
   template<Magnitude M>
   static constexpr auto scale(M, const Rep& value)
@@ -131,8 +131,6 @@ struct floating_point_scaling_traits {
 
 template<Magnitude auto M>
 struct fixed_point_scaling_impl {
-  static constexpr Magnitude auto num = _numerator(M);
-  static constexpr Magnitude auto den = _denominator(M);
   template<std::integral T>
   static constexpr auto ratio = [] {
     using U = long double;
@@ -145,9 +143,9 @@ struct fixed_point_scaling_impl {
   {
     using U = std::common_type_t<value_type_t<From>, value_type_t<To>>;
     if constexpr (_is_integral(M)) {
-      return static_cast<To>(static_cast<value_type_t<From>>(value) * _get_value<U>(num));
+      return static_cast<To>(static_cast<value_type_t<From>>(value) * _get_value<U>(M));
     } else if constexpr (_is_integral(_pow<-1>(M))) {
-      return static_cast<To>(static_cast<value_type_t<From>>(value) / _get_value<U>(den));
+      return static_cast<To>(static_cast<value_type_t<From>>(value) / _get_value<U>(_pow<-1>(M)));
     } else {
       return static_cast<To>(ratio<U>.scale(static_cast<value_type_t<From>>(value)));
     }
@@ -161,7 +159,7 @@ struct fixed_point_scaling_traits {
   static constexpr Rep scale_from(M, const From& value)
   {
     return fixed_point_scaling_impl<M{}>::template scale<Rep>(value);
-  };
+  }
 
   template<Magnitude M>
   static constexpr auto scale(M, const Rep& value)
@@ -201,6 +199,8 @@ concept HasScalingTraits = !std::convertible_to<decltype(select_scaling_traits<T
 
 }  // namespace detail
 
+MP_UNITS_EXPORT_BEGIN
+
 template<typename To, Magnitude M, typename From>
   requires detail::HasScalingTraits<To, From> ||
            requires(const From& value) { value.scale(std::type_identity<To>{}, M{}); }
@@ -226,4 +226,7 @@ constexpr auto scale(M scaling_factor, const From& value)
   }
 }
 
+
+MP_UNITS_EXPORT_END
+
 }  // namespace mp_units

src/core/include/mp-units/framework/customization_points.h

@@ -173,7 +173,7 @@ struct quantity_values {
  *    return an instance of @c Rep that approximates `scaling_factor * value`, another element of $\mathcal{V}$.
  *    This needs to be defined at least for `From = Rep`, as well as any other representation
  *    types for which interoperability is desired.
- *  - `template <typename To, Magnitude M> static constexpr auto scale(M scaling_factor, const Rep &value)`:
+ *  - `template <Magnitude M> static constexpr auto scale(M scaling_factor, const Rep &value)`:
  *    Given an element of $\mathcal{V}$ represented by @c value and, a real number represented by  @c scaling_factor,
  *    return an approximation of `scaling_factor * value`, another element of $\mathcal{V}$.
  *    Contrary to the `scale_from` case, here, the result representation is unspecified.

test/runtime/fixed_point_test.cpp

@@ -76,24 +76,21 @@ std::vector<std::tuple<T...>> cartesian_product(const std::vector<T>&... src)
 
 
 template<std::integral T>
-using half_width_int_t = std::conditional_t<std::is_signed_v<T>, min_width_int_t<integer_rep_width_v<T> / 2>,
-                                            min_width_uint_t<integer_rep_width_v<T> / 2>>;
-template<std::integral T>
-using double_width_int_t = std::conditional_t<std::is_signed_v<T>, min_width_int_t<integer_rep_width_v<T> * 2>,
-                                              min_width_uint_t<integer_rep_width_v<T> * 2>>;
+using half_width_int_for_t = std::conditional_t<std::is_signed_v<T>, min_width_int_t<integer_rep_width_v<T> / 2>,
+                                                min_width_uint_t<integer_rep_width_v<T> / 2>>;
 
 template<std::integral Hi, std::unsigned_integral Lo>
   requires(integer_rep_width_v<Hi> == integer_rep_width_v<Lo>)
 auto combine_bits(Hi hi, Lo lo)
 {
-  using ret_t = double_width_int_t<Hi>;
+  using ret_t = double_width_int_for_t<Hi>;
   return (static_cast<ret_t>(hi) << integer_rep_width_v<Lo>)+static_cast<ret_t>(lo);
 }
 
 template<std::integral T, typename V>
 void check(double_width_int<T> value, V&& visitor)
 {
-  using DT = double_width_int_t<T>;
+  using DT = double_width_int_for_t<T>;
   auto as_standard_int = static_cast<DT>(value);
   auto expected = visitor(as_standard_int);
   auto actual = visitor(value);

test/static/custom_rep_test_min_impl.cpp

@@ -70,6 +70,7 @@ struct std::common_type<min_impl<T>, U> : std::type_identity<min_impl<std::commo
 template<typename U, typename T>
 struct std::common_type<U, min_impl<T>> : std::type_identity<min_impl<std::common_type_t<T, U>>> {};
 
+
 namespace {
 
 using namespace mp_units;