update PR following changes on master

Author: burnpanck

example/measurement.cpp

@@ -140,7 +140,7 @@ class measurement {
 
 template<typename T>
 struct mp_units::scaling_traits<measurement<T>, mp_units::unspecified_rep> {
-  template<mp_units::Magnitude auto M>
+  template<mp_units::UnitMagnitude auto M>
   [[nodiscard]] static constexpr auto scale(const measurement<T>& value)
   {
     return measurement{
@@ -152,7 +152,7 @@ struct mp_units::scaling_traits<measurement<T>, mp_units::unspecified_rep> {
 
 template<typename From, typename To>
 struct mp_units::scaling_traits<measurement<From>, measurement<To>> {
-  template<mp_units::Magnitude auto M>
+  template<mp_units::UnitMagnitude auto M>
   [[nodiscard]] static constexpr measurement<To> scale(const measurement<From>& value)
   {
     constexpr std::type_identity<To> to_type;

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

@@ -22,19 +22,23 @@
 
 #pragma once
 
-// IWYU pragma: private, include <mp-units/framework.h>
-#include <mp-units/framework/magnitude.h>
+#include <mp-units/bits/hacks.h>  // IWYU pragma: keep
 
 #ifndef MP_UNITS_IN_MODULE_INTERFACE
 #ifdef MP_UNITS_IMPORT_STD
 import std;
 #else
+#include <algorithm>
 #include <bit>
+#include <cmath>
 #include <concepts>
 #include <cstdint>
 #include <cstdlib>
 #include <limits>
 #include <numbers>
+#include <tuple>
+#include <type_traits>
+#include <version>
 #endif
 #endif
 
@@ -43,6 +47,26 @@ namespace mp_units::detail {
 template<typename T>
 constexpr std::size_t integer_rep_width_v = std::numeric_limits<std::make_unsigned_t<T>>::digits;
 
+template<std::floating_point T>
+[[nodiscard]] consteval T int_power(T base, int exponent)
+{
+#if defined(__cpp_lib_constexpr_cmath) && __cpp_lib_constexpr_cmath >= 202202L
+  return std::ldexp(base, exponent);
+#else
+  if (exponent < 0) {
+    base = T{1} / base;
+    exponent = -exponent;
+  }
+  T ret = 1;
+  while (exponent) {
+    if (exponent & 1) ret *= base;
+    exponent >>= 1;
+    base *= base;
+  }
+  return ret;
+
+#endif
+}
 
 // this class synthesizes a double-width integer from two base-width integers.
 template<std::integral T>

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

@@ -78,7 +78,7 @@ template<Quantity To, typename FwdFrom, Quantity From = std::remove_cvref_t<FwdF
             To::reference};  // this is the only (and recommended) way to do a truncating conversion on a number, so we
                              // are using static_cast to suppress all the compiler warnings on conversions
   } else {
-    constexpr Magnitude auto c_mag = get_canonical_unit(From::unit).mag / get_canonical_unit(To::unit).mag;
+    constexpr UnitMagnitude auto c_mag = get_canonical_unit(From::unit).mag / get_canonical_unit(To::unit).mag;
 
     typename To::rep res =
       scale(std::type_identity<typename To::rep>{}, c_mag, q.numerical_value_is_an_implementation_detail_);
@@ -122,7 +122,7 @@ template<QuantityPoint ToQP, typename FwdFromQP, QuantityPoint FromQP = std::rem
     constexpr UnitMagnitude auto c_mag = get_canonical_unit(FromQP::unit).mag / get_canonical_unit(ToQP::unit).mag;
     using type_traits = conversion_type_traits<c_mag, typename FromQP::rep, typename ToQP::rep>;
     using c_type = type_traits::c_type;
-    if constexpr (_get_value<long double>(c_mag) > 1.) {
+    if constexpr (get_value<long double>(c_mag) > 1.) {
       // original unit had a larger unit magnitude; if we first convert to the common representation but retain the
       // unit, we obtain the largest possible range while not causing truncation of fractional values. This is optimal
       // for the offset computation.

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

@@ -25,9 +25,9 @@
 // IWYU pragma: private, include <mp-units/framework.h>
 #include <mp-units/bits/module_macros.h>
 #include <mp-units/framework/customization_points.h>
-#include <mp-units/framework/magnitude.h>
 #include <mp-units/framework/quantity_spec_concepts.h>
 #include <mp-units/framework/scaling.h>
+#include <mp-units/framework/unit_magnitude.h>
 
 #ifndef MP_UNITS_IN_MODULE_INTERFACE
 #ifdef MP_UNITS_IMPORT_STD

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

@@ -25,6 +25,7 @@
 // IWYU pragma: private, include <mp-units/framework.h>
 #include <mp-units/bits/fixed_point.h>
 #include <mp-units/framework/customization_points.h>
+#include <mp-units/framework/unit_magnitude_concepts.h>
 
 #ifndef MP_UNITS_IN_MODULE_INTERFACE
 #ifdef MP_UNITS_IMPORT_STD
@@ -79,8 +80,8 @@ template<typename T>
 concept UsesFloatingPointScaling =
   treat_as_floating_point<T> && requires(T value, floating_point_scaling_factor_type<value_type_t<T>>::type f) {
     // the result representation does not necessarily have to be the same.
-    { value* f } -> std::equality_comparable;
-    { value* f } -> std::copyable;
+    { value * f } -> std::equality_comparable;
+    { value * f } -> std::copyable;
   };
 
 template<typename T>
@@ -122,21 +123,21 @@ struct scaling_traits<From, To> {
   using _scaling_factor_type = std::common_type_t<value_type_t<From>, value_type_t<To>>;
   static_assert(std::is_floating_point_v<_scaling_factor_type>);
 
-  template<Magnitude auto M>
+  template<UnitMagnitude auto M>
   static constexpr bool implicitly_scalable =
     std::is_convertible_v<decltype(detail::cast_if_integral<_scaling_factor_type>(std::declval<From>()) *
                                    std::declval<_scaling_factor_type>()),
                           To>;
 
-  template<Magnitude auto M>
+  template<UnitMagnitude auto M>
   static constexpr To scale(const From& value)
   {
     using U = _scaling_factor_type;
-    if constexpr (_is_integral(_pow<-1>(M)) && !_is_integral(M)) {
-      constexpr U div = static_cast<U>(_get_value<long double>(_pow<-1>(M)));
+    if constexpr (is_integral(pow<-1>(M)) && !is_integral(M)) {
+      constexpr U div = static_cast<U>(get_value<long double>(pow<-1>(M)));
       return static_cast<To>(detail::cast_if_integral<U>(value) / div);
     } else {
-      constexpr U ratio = static_cast<U>(_get_value<long double>(M));
+      constexpr U ratio = static_cast<U>(get_value<long double>(M));
       return static_cast<To>(detail::cast_if_integral<U>(value) * ratio);
     }
   }
@@ -154,20 +155,20 @@ struct scaling_traits<From, To> {
 
   // TODO: should we take possible overflow into account here? This would lead to this almost always resulting
   // in explicit conversions, except for small integral factors combined with a widening conversion.
-  template<Magnitude auto M>
-  static constexpr bool implicitly_scalable = std::is_convertible_v<From, To> && _is_integral(M);
+  template<UnitMagnitude auto M>
+  static constexpr bool implicitly_scalable = std::is_convertible_v<From, To> && is_integral(M);
 
-  template<Magnitude auto M>
+  template<UnitMagnitude auto M>
   static constexpr To scale(const From& value)
   {
-    if constexpr (_is_integral(M)) {
-      constexpr auto mul = _get_value<_common_type>(M);
+    if constexpr (is_integral(M)) {
+      constexpr auto mul = get_value<_common_type>(M);
       return static_cast<To>(static_cast<value_type_t<From>>(value) * mul);
-    } else if constexpr (_is_integral(_pow<-1>(M))) {
-      constexpr auto div = _get_value<_common_type>(_pow<-1>(M));
+    } else if constexpr (is_integral(pow<-1>(M))) {
+      constexpr auto div = get_value<_common_type>(pow<-1>(M));
       return static_cast<To>(static_cast<value_type_t<From>>(value) / div);
     } else {
-      constexpr auto ratio = detail::fixed_point<_common_type>(_get_value<long double>(M));
+      constexpr auto ratio = detail::fixed_point<_common_type>(get_value<long double>(M));
       return static_cast<To>(ratio.scale(static_cast<value_type_t<From>>(value)));
     }
   }
@@ -181,7 +182,7 @@ MP_UNITS_EXPORT_BEGIN
 
 // @brief approximate the result of the symbolic multiplication of @c from by @c scaling_factor, and represent it as an
 // instance of @to
-template<typename To, Magnitude M, typename From>
+template<typename To, UnitMagnitude M, typename From>
   requires detail::HasScalingTraits<From, To>
 constexpr To scale(std::type_identity<To>, M scaling_factor [[maybe_unused]], const From& value)
 {
@@ -191,7 +192,7 @@ constexpr To scale(std::type_identity<To>, M scaling_factor [[maybe_unused]], co
 }
 
 // @brief approximate the result of the symbolic multiplication of @c from by @c scaling_factor
-template<Magnitude M, typename From>
+template<UnitMagnitude M, typename From>
   requires detail::HasScalingTraits<From, unspecified_rep>
 constexpr auto scale(M scaling_factor [[maybe_unused]], const From& value)
 {