Use Magnitude instead of ratio in unit implementations

example/custom_systems.cpp

@@ -33,7 +33,7 @@ using namespace units;
 namespace fps {
 
 struct foot : named_unit<foot, "ft"> {};
-struct yard : named_scaled_unit<yard, "yd", ratio(3), foot> {};
+struct yard : named_scaled_unit<yard, "yd", as_magnitude<3>(), foot> {};
 
 struct dim_length : base_dimension<"L", foot> {};
 
@@ -54,8 +54,8 @@ using length = quantity<dim_length, U, Rep>;
 
 namespace fps {
 
-struct foot : named_scaled_unit<foot, "ft", ratio(3'048, 1'000, -1), metre> {};
-struct yard : named_scaled_unit<yard, "yd", ratio(3), foot> {};
+struct foot : named_scaled_unit<foot, "ft", as_magnitude<ratio(3'048, 1'000, -1)>(), metre> {};
+struct yard : named_scaled_unit<yard, "yd", as_magnitude<3>(), foot> {};
 
 struct dim_length : base_dimension<"L", foot> {};
 
@@ -103,7 +103,7 @@ template<Unit U>
 std::ostream& operator<<(std::ostream& os, const U& u)
 {
   using unit_type = std::remove_cvref_t<decltype(u)>;
-  return os << unit_type::ratio << " x " << unit_type::reference::symbol.standard();
+  return os << as_ratio(unit_type::mag) << " x " << unit_type::reference::symbol.standard();
 }
 
 void what_is_your_ratio()

src/core/include/units/bits/base_units_ratio.h

@@ -24,29 +24,25 @@
 
 #include <units/base_dimension.h>
 #include <units/exponent.h>
+#include <units/magnitude.h>
 #include <units/ratio.h>
 
 namespace units::detail {
 
-template<Exponent E>
-  requires(E::den == 1 || E::den == 2)  // TODO provide support for any den
-constexpr ratio exp_ratio()
-{
-  const ratio base_ratio = E::dimension::base_unit::ratio;
-  const ratio positive_ratio =
-    E::num * E::den < 0 ? ratio(base_ratio.den, base_ratio.num, -base_ratio.exp) : base_ratio;
-  const std::intmax_t N = E::num * E::den < 0 ? -E::num : E::num;
-  const ratio ratio_pow = pow<N>(positive_ratio);
-  return E::den == 2 ? sqrt(ratio_pow) : ratio_pow;
-}
-
 /**
- * @brief Calculates the common ratio of all the references of base units in the derived dimension
+ * @brief Calculates the "absolute" magnitude of the derived dimension defined by this list.
+ *
+ * "Absolute" magnitudes are not physically observable: only ratios of magnitudes are.  For example: if we multiplied
+ * all magnitudes in the system by the same constant, no meaningful results would change.  However, in practice, we need
+ * to make some global choice for the "absolute" values of magnitudes, so that we can compute their ratios.
+ *
+ * The point of this function is to compute the absolute magnitude of a derived dimension, in terms of the absolute
+ * magnitudes of its constituent dimensions.
  */
 template<typename... Es>
-constexpr ratio base_units_ratio(exponent_list<Es...>)
+constexpr Magnitude auto absolute_magnitude(exponent_list<Es...>)
 {
-  return (exp_ratio<Es>() * ... * ratio(1));
+  return (pow<ratio{Es::num, Es::den}>(Es::dimension::base_unit::mag) * ... * magnitude<>{});
 }
 
 }  // namespace units::detail

src/core/include/units/bits/basic_concepts.h

@@ -28,7 +28,7 @@
 #include <units/bits/external/fixed_string.h>
 #include <units/bits/external/type_traits.h>
 #include <units/customization_points.h>
-#include <units/ratio.h>
+#include <units/magnitude.h>
 // IWYU pragma: end_exports
 
 #include <cstdint>
@@ -56,24 +56,15 @@ void to_prefix_base(const volatile prefix_base<R>*);
 template<typename T>
 concept Prefix = requires(T* t) { detail::to_prefix_base(t); };
 
-/**
- * @brief A concept matching unit's ratio
- *
- * Satisfied by all ratio values for which `R.num > 0` and `R.den > 0`.
- */
-template<ratio R>
-concept UnitRatio = (R.num > 0) && (R.den > 0);
-
 // Unit
-template<ratio R, typename U>
-  requires UnitRatio<R>
+template<Magnitude auto M, typename U>
 struct scaled_unit;
 
 // TODO: Remove when P1985 accepted
 namespace detail {
 
-template<ratio R, typename U>
-void to_base_scaled_unit(const volatile scaled_unit<R, U>*);
+template<Magnitude auto M, typename U>
+void to_base_scaled_unit(const volatile scaled_unit<M, U>*);
 
 }  // namespace detail
 

src/core/include/units/bits/common_type.h

@@ -55,22 +55,22 @@ struct common_quantity_reference_impl<reference<D, U>, reference<D, U>> {
 
 template<typename D, typename U1, typename U2>
 struct common_quantity_reference_impl<reference<D, U1>, reference<D, U2>> {
-  using type = reference<D, downcast_unit<D, common_ratio(U1::ratio, U2::ratio)>>;
+  using type = reference<D, downcast_unit<D, common_magnitude(U1::mag, U2::mag)>>;
 };
 
 template<typename D1, typename U1, typename D2, typename U2>
   requires(same_unit_reference<dimension_unit<D1>, dimension_unit<D2>>::value)
 struct common_quantity_reference_impl<reference<D1, U1>, reference<D2, U2>> {
-  using type = reference<D1, downcast_unit<D1, common_ratio(U1::ratio, U2::ratio)>>;
+  using type = reference<D1, downcast_unit<D1, common_magnitude(U1::mag, U2::mag)>>;
 };
 
 template<typename D1, typename U1, typename D2, typename U2>
 struct common_quantity_reference_impl<reference<D1, U1>, reference<D2, U2>> {
   using dimension = conditional<is_specialization_of<D1, unknown_dimension>, D2, D1>;
-  static constexpr ratio r1 = D1::base_units_ratio * U1::ratio;
-  static constexpr ratio r2 = D2::base_units_ratio * U2::ratio;
-  static constexpr ratio cr = common_ratio(r1, r2);
-  using unit = downcast_unit<dimension, cr / dimension::base_units_ratio>;
+  static constexpr UNITS_MSVC_WORKAROUND(Magnitude) auto m1 = D1::base_units_ratio * U1::mag;
+  static constexpr UNITS_MSVC_WORKAROUND(Magnitude) auto m2 = D2::base_units_ratio * U2::mag;
+  static constexpr UNITS_MSVC_WORKAROUND(Magnitude) auto cm = common_magnitude(m1, m2);
+  using unit = downcast_unit<dimension, cm / dimension::base_units_ratio>;
   using type = reference<dimension, unit>;
 };
 

src/core/include/units/bits/derived_scaled_unit.h

@@ -23,6 +23,7 @@
 #pragma once
 
 #include <units/derived_dimension.h>
+#include <units/magnitude.h>
 
 namespace units::detail {
 
@@ -35,24 +36,14 @@ inline constexpr bool compatible_units<exponent_list<Es...>, Us...> = (UnitOf<Us
 
 // derived_scaled_unit
 
-template<Exponent E>
-constexpr ratio inverse_if_negative(const ratio& r)
-{
-  if constexpr (E::num * E::den > 0)
-    return r;
-  else
-    return inverse(r);
-}
-
 template<Unit... Us, typename... Es>
-constexpr ratio derived_ratio(exponent_list<Es...>)
+constexpr Magnitude auto derived_mag(exponent_list<Es...>)
 {
-  return (... * inverse_if_negative<Es>(
-                  pow<detail::abs(Es::num)>(Us::ratio / dimension_unit<typename Es::dimension>::ratio)));
+  return (as_magnitude<1>() * ... *
+          pow<ratio{Es::num, Es::den}>(Us::mag / dimension_unit<typename Es::dimension>::mag));
 }
 
 template<DerivedDimension D, Unit... Us>
-using derived_scaled_unit =
-  scaled_unit<derived_ratio<Us...>(typename D::recipe()), typename D::coherent_unit::reference>;
+using derived_scaled_unit = scaled_unit<derived_mag<Us...>(typename D::recipe()), typename D::coherent_unit::reference>;
 
 }  // namespace units::detail

src/core/include/units/bits/equivalent.h

@@ -72,8 +72,8 @@ struct equivalent_impl<D1, D2> :
 // additionally accounts for unknown dimensions
 template<Unit U1, Dimension D1, Unit U2, Dimension D2>
 struct equivalent_unit :
-    std::disjunction<equivalent_impl<U1, U2>, std::bool_constant<U1::ratio / dimension_unit<D1>::ratio ==
-                                                                 U2::ratio / dimension_unit<D2>::ratio>> {};
+    std::disjunction<equivalent_impl<U1, U2>,
+                     std::bool_constant<U1::mag / dimension_unit<D1>::mag == U2::mag / dimension_unit<D2>::mag>> {};
 
 // point origins
 

src/core/include/units/bits/external/hacks.h

@@ -100,6 +100,16 @@
 
 #endif
 
+#if UNITS_COMP_MSVC
+
+#define UNITS_MSVC_WORKAROUND(X)
+
+#else
+
+#define UNITS_MSVC_WORKAROUND(X) X
+
+#endif
+
 
 namespace std {
 

src/core/include/units/bits/unit_text.h

@@ -147,7 +147,7 @@ constexpr auto unit_text()
     }();
 
     constexpr auto prefix_txt =
-      prefix_or_ratio_text<U, U::ratio / coherent_unit::ratio, symbol_text.standard().size()>();
+      prefix_or_ratio_text<U, as_ratio(U::mag / coherent_unit::mag), symbol_text.standard().size()>();
     return prefix_txt + symbol_text;
   }
 }

src/core/include/units/chrono.h

@@ -33,8 +33,11 @@ namespace units {
 
 template<typename Rep, typename Period>
 struct quantity_like_traits<std::chrono::duration<Rep, Period>> {
+private:
+  static constexpr auto mag = as_magnitude<ratio(Period::num, Period::den)>();
+public:
   using dimension = isq::si::dim_time;
-  using unit = downcast_unit<dimension, ratio(Period::num, Period::den)>;
+  using unit = downcast_unit<dimension, mag>;
   using rep = Rep;
   [[nodiscard]] static constexpr rep number(const std::chrono::duration<Rep, Period>& q) { return q.count(); }
 };
@@ -44,8 +47,11 @@ struct clock_origin : point_origin<isq::si::dim_time> {};
 
 template<typename C, typename Rep, typename Period>
 struct quantity_point_like_traits<std::chrono::time_point<C, std::chrono::duration<Rep, Period>>> {
+private:
+  static constexpr auto mag = as_magnitude<ratio(Period::num, Period::den)>();
+public:
   using origin = clock_origin<C>;
-  using unit = downcast_unit<typename origin::dimension, ratio(Period::num, Period::den)>;
+  using unit = downcast_unit<typename origin::dimension, mag>;
   using rep = Rep;
   [[nodiscard]] static constexpr auto relative(const std::chrono::time_point<C, std::chrono::duration<Rep, Period>>& qp)
   {
@@ -86,13 +92,13 @@ using to_std_ratio = decltype(detail::to_std_ratio_impl<R>());
 template<typename U, typename Rep>
 [[nodiscard]] constexpr auto to_std_duration(const quantity<isq::si::dim_time, U, Rep>& q)
 {
-  return std::chrono::duration<Rep, to_std_ratio<U::ratio>>(q.number());
+  return std::chrono::duration<Rep, to_std_ratio<as_ratio(U::mag)>>(q.number());
 }
 
 template<typename C, typename U, typename Rep>
 [[nodiscard]] constexpr auto to_std_time_point(const quantity_point<clock_origin<C>, U, Rep>& qp)
 {
-  using ret_type = std::chrono::time_point<C, std::chrono::duration<Rep, to_std_ratio<U::ratio>>>;
+  using ret_type = std::chrono::time_point<C, std::chrono::duration<Rep, to_std_ratio<as_ratio(U::mag)>>>;
   return ret_type(to_std_duration(qp.relative()));
 }
 

src/core/include/units/derived_dimension.h

@@ -85,7 +85,8 @@ template<typename Child, Unit U, Exponent... Es>
 struct derived_dimension : downcast_dispatch<Child, typename detail::make_dimension<Es...>> {
   using recipe = exponent_list<Es...>;
   using coherent_unit = U;
-  static constexpr ratio base_units_ratio = detail::base_units_ratio(typename derived_dimension::exponents());
+  static constexpr UNITS_MSVC_WORKAROUND(Magnitude) auto base_units_ratio =
+    detail::absolute_magnitude(typename derived_dimension::exponents());
 };
 
 }  // namespace units

src/core/include/units/generic/dimensionless.h

@@ -31,7 +31,7 @@
 namespace units {
 
 struct one : derived_unit<one> {};
-struct percent : named_scaled_unit<percent, "%", ratio(1, 100), one> {};
+struct percent : named_scaled_unit<percent, "%", as_magnitude<ratio(1, 100)>(), one> {};
 
 /**
  * @brief Dimension one