Migrate units from ratio to Magnitude

This commit is huge, but hopefully the cognitive load is not too bad.
The bulk of this commit is just some fairly mechanical updates from
`ratio` to `Magnitude`.  Other things to call out:

- `UnitRatio` goes away.  We don't need this concept, because Magnitude
  can't even _represent_ anything that doesn't satisfy it.

- I commented out some formatting test cases where the precise
  expression changes, but the number is completely equivalent.  We will
  need to decide how we want to handle Magnitude formatting as a
  separate, follow-on task.  But at least Magnitude gives us all the
  tools we'll need to do so!

test/unit_test/runtime/fmt_test.cpp

@@ -84,7 +84,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
   {
     SECTION("in terms of base units")
     {
-      const length<scaled_unit<ratio(1, 1, 6), metre>> q(123);
+      const length<scaled_unit<pow<6>(as_magnitude<10>()), metre>> q(123);
       os << q;
 
       SECTION("iostream") { CHECK(os.str() == "123 Mm"); }
@@ -96,7 +96,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
 
     SECTION("in terms of derived units")
     {
-      const energy<scaled_unit<ratio(1, 1, -2), joule>> q(60);
+      const energy<scaled_unit<pow<-2>(as_magnitude<10>()), joule>> q(60);
       os << q;
 
       SECTION("iostream") { CHECK(os.str() == "60 cJ"); }
@@ -257,7 +257,8 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
       const auto q = 60_q_kJ / 2_q_min;
       os << q;
 
-      SECTION("iostream") { CHECK(os.str() == "30 [1/6 × 10²] W"); }
+      // TODO(chogg): Reinstate after format/Magnitude design.
+      // SECTION("iostream") { CHECK(os.str() == "30 [1/6 × 10²] W"); }
 
       SECTION("fmt with default format {} on a quantity") { CHECK(STD_FMT::format("{}", q) == os.str()); }
 
@@ -390,7 +391,8 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
       const auto q = 60_q_min / 2_q_km;
       os << q;
 
-      SECTION("iostream") { CHECK(os.str() == "30 [6 × 10⁻²] 1/m ⋅ s"); }
+      // TODO(chogg): Reinstate after format/Magnitude design.
+      // SECTION("iostream") { CHECK(os.str() == "30 [6 × 10⁻²] 1/m ⋅ s"); }
 
       SECTION("fmt with default format {} on a quantity") { CHECK(STD_FMT::format("{}", q) == os.str()); }
 

test/unit_test/runtime/fmt_units_test.cpp

@@ -30,6 +30,7 @@
 #include <units/isq/si/si.h>
 #include <units/isq/si/typographic/typographic.h>
 #include <units/isq/si/uscs/uscs.h>
+#include <units/magnitude.h>
 
 using namespace units::isq::si;
 using namespace units::isq::si::references;
@@ -315,16 +316,18 @@ TEST_CASE("std::format on synthesized unit symbols", "[text][fmt]")
 
   SECTION("incoherent units with powers")
   {
-    CHECK(STD_FMT::format("{}", 1_q_mi * 1_q_mi * 1_q_mi) == "1 [15900351812136/3814697265625 × 10⁹] m³");
-    CHECK(STD_FMT::format("{}", 1_q_au * 1_q_au) == "1 [2237952291797391849 × 10⁴] m²");
-
-    CHECK(STD_FMT::format("{:%Q %Aq}", 1_q_mi * 1_q_mi * 1_q_mi) == "1 [15900351812136/3814697265625 x 10^9] m^3");
-    CHECK(STD_FMT::format("{:%Q %Aq}", 1_q_au * 1_q_au) == "1 [2237952291797391849 x 10^4] m^2");
+    // TODO(chogg): Reinstate after format/Magnitude redesign.
+    // CHECK(STD_FMT::format("{}", 1_q_mi * 1_q_mi * 1_q_mi) == "1 [15900351812136/3814697265625 × 10⁹] m³");
+    // CHECK(STD_FMT::format("{}", 1_q_au * 1_q_au) == "1 [2237952291797391849 × 10⁴] m²");
+    //
+    // CHECK(STD_FMT::format("{:%Q %Aq}", 1_q_mi * 1_q_mi * 1_q_mi) == "1 [15900351812136/3814697265625 x 10^9] m^3");
+    // CHECK(STD_FMT::format("{:%Q %Aq}", 1_q_au * 1_q_au) == "1 [2237952291797391849 x 10^4] m^2");
   }
 
   SECTION("unknown scaled unit with reference different than the dimension's coherent unit")
   {
-    CHECK(STD_FMT::format("{}", mass<units::scaled_unit<units::ratio(2, 3), gram>>(1)) == "1 [2/3 × 10⁻³] kg");
-    CHECK(STD_FMT::format("{:%Q %Aq}", mass<units::scaled_unit<units::ratio(2, 3), gram>>(1)) == "1 [2/3 x 10^-3] kg");
+    constexpr auto mag = units::as_magnitude<units::ratio{2, 3}>();
+    CHECK(STD_FMT::format("{}", mass<units::scaled_unit<mag, gram>>(1)) == "1 [2/3 × 10⁻³] kg");
+    CHECK(STD_FMT::format("{:%Q %Aq}", mass<units::scaled_unit<mag, gram>>(1)) == "1 [2/3 x 10^-3] kg");
   }
 }

test/unit_test/static/concepts_test.cpp

@@ -53,15 +53,6 @@ static_assert(Prefix<si::kilo>);
 static_assert(!Prefix<si::prefix>);
 static_assert(!Prefix<std::kilo>);
 
-// UnitRatio
-
-static_assert(UnitRatio<ratio(1000)>);
-static_assert(!UnitRatio<ratio(0)>);
-// static_assert(UnitRatio<ratio(1000, 0)>);  // static_assert in ratio
-static_assert(UnitRatio<ratio(-1000, -1)>);
-static_assert(!UnitRatio<ratio(-1000, 1)>);
-static_assert(!UnitRatio<ratio(1, -1000)>);
-
 // BaseDimension
 
 static_assert(BaseDimension<si::dim_length>);

test/unit_test/static/quantity_kind_test.cpp

@@ -456,9 +456,9 @@ concept invalid_compound_assignments =
     requires !requires { w *= m; };
     requires !requires { w /= m; };
     requires !requires { w %= m; };
-    requires !requires { w *= quantity_kind<downcast_kind<Width, dim_one>, scaled_unit<ratio{1, 1, 3}, one>, int>{1}; };
-    requires !requires { w /= quantity_kind<downcast_kind<Width, dim_one>, scaled_unit<ratio{1, 1, 3}, one>, int>{1}; };
-    requires !requires { w %= quantity_kind<downcast_kind<Width, dim_one>, scaled_unit<ratio{1, 1, 3}, one>, int>{1}; };
+    requires !requires { w *= quantity_kind<downcast_kind<Width, dim_one>, scaled_unit<as_magnitude<1000>(), one>, int>{1}; };
+    requires !requires { w /= quantity_kind<downcast_kind<Width, dim_one>, scaled_unit<as_magnitude<1000>(), one>, int>{1}; };
+    requires !requires { w %= quantity_kind<downcast_kind<Width, dim_one>, scaled_unit<as_magnitude<1000>(), one>, int>{1}; };
     requires !requires { w %= 1.0; };
     requires !requires { w %= quantity(1.0); };
     requires !requires { w %= 1.0 * (w / w); };

test/unit_test/static/quantity_test.cpp

@@ -496,7 +496,7 @@ static_assert(compare<decltype(1_q_m / 1_q_m), dimensionless<one, std::int64_t>>
 static_assert(compare<decltype(1 / 1_q_s), frequency<hertz, std::int64_t>>);
 static_assert(compare<decltype(quantity{1} / 1_q_s), frequency<hertz, std::int64_t>>);
 static_assert(compare<decltype(dimensionless<percent, std::int64_t>(1) / 1_q_s),
-                      frequency<scaled_unit<ratio(1, 100), hertz>, std::int64_t>>);
+                      frequency<scaled_unit<as_magnitude<ratio(1, 100)>(), hertz>, std::int64_t>>);
 
 static_assert(is_same_v<decltype((std::uint8_t(0) * m + std::uint8_t(0) * m).number()), int&&>);
 static_assert(is_same_v<decltype((std::uint8_t(0) * m - std::uint8_t(0) * m).number()), int&&>);
@@ -527,7 +527,7 @@ static_assert(compare<decltype(1_q_m / 1._q_m), dimensionless<one, long double>>
 static_assert(compare<decltype(1 / 1._q_s), frequency<hertz, long double>>);
 static_assert(compare<decltype(quantity{1} / 1._q_s), frequency<hertz, long double>>);
 static_assert(compare<decltype(dimensionless<percent, std::int64_t>(1) / 1._q_s),
-                      frequency<scaled_unit<ratio(1, 100), hertz>, long double>>);
+                      frequency<scaled_unit<as_magnitude<ratio(1, 100)>(), hertz>, long double>>);
 static_assert(compare<decltype(1_q_m % short(1)), length<metre, std::int64_t>>);
 static_assert(compare<decltype(1_q_m % quantity{short(1)}), length<metre, std::int64_t>>);
 static_assert(compare<decltype(1_q_m % dimensionless<percent, short>(1)), length<metre, std::int64_t>>);
@@ -549,7 +549,7 @@ static_assert(compare<decltype(1._q_m / 1_q_m), dimensionless<one, long double>>
 static_assert(compare<decltype(1.L / 1_q_s), frequency<hertz, long double>>);
 static_assert(compare<decltype(quantity{1.L} / 1_q_s), frequency<hertz, long double>>);
 static_assert(compare<decltype(dimensionless<percent, long double>(1) / 1_q_s),
-                      frequency<scaled_unit<ratio(1, 100), hertz>, long double>>);
+                      frequency<scaled_unit<as_magnitude<ratio(1, 100)>(), hertz>, long double>>);
 
 // different units
 static_assert(is_same_v<decltype(1_q_m + 1_q_km), length<metre, std::int64_t>>);
@@ -577,22 +577,25 @@ static_assert(is_same_v<decltype(1_q_km % 1_q_m), length<kilometre, std::int64_t
 
 // different dimensions
 static_assert(compare<decltype(1_q_m_per_s * 1_q_s), length<metre, std::int64_t>>);
-static_assert(compare<decltype(1_q_m_per_s * 1_q_h), length<scaled_unit<ratio(36, 1, 2), metre>, std::int64_t>>);
+static_assert(
+  compare<decltype(1_q_m_per_s * 1_q_h), length<scaled_unit<as_magnitude<ratio(36, 1, 2)>(), metre>, std::int64_t>>);
 static_assert(
   compare<decltype(1_q_m * 1_q_min), quantity<unknown_dimension<exponent<dim_length, 1>, exponent<dim_time, 1>>,
-                                              scaled_unit<ratio(60), unknown_coherent_unit>, std::int64_t>>);
+                                              scaled_unit<as_magnitude<60>(), unknown_coherent_unit>, std::int64_t>>);
 static_assert(compare<decltype(1_q_s * 1_q_Hz), dimensionless<one, std::int64_t>>);
-static_assert(compare<decltype(1 / 1_q_min), frequency<scaled_unit<ratio(1, 60), hertz>, std::int64_t>>);
-static_assert(compare<decltype(1 / 1_q_Hz), isq::si::time<second, std::int64_t>>);
 static_assert(
-  compare<decltype(1 / 1_q_km), quantity<unknown_dimension<exponent<dim_length, -1>>,
-                                         scaled_unit<ratio(1, 1, -3), unknown_coherent_unit>, std::int64_t>>);
-static_assert(compare<decltype(1_q_km / 1_q_m), dimensionless<scaled_unit<ratio(1000), one>, std::int64_t>>);
+  compare<decltype(1 / 1_q_min), frequency<scaled_unit<as_magnitude<ratio(1, 60)>(), hertz>, std::int64_t>>);
+static_assert(compare<decltype(1 / 1_q_Hz), isq::si::time<second, std::int64_t>>);
+static_assert(compare<decltype(1 / 1_q_km),
+                      quantity<unknown_dimension<exponent<dim_length, -1>>,
+                               scaled_unit<as_magnitude<ratio(1, 1, -3)>(), unknown_coherent_unit>, std::int64_t>>);
+static_assert(compare<decltype(1_q_km / 1_q_m), dimensionless<scaled_unit<as_magnitude<1000>(), one>, std::int64_t>>);
 static_assert(compare<decltype(1_q_m / 1_q_s), speed<metre_per_second, std::int64_t>>);
-static_assert(compare<decltype(1_q_m / 1_q_min), speed<scaled_unit<ratio(1, 60), metre_per_second>, std::int64_t>>);
+static_assert(
+  compare<decltype(1_q_m / 1_q_min), speed<scaled_unit<as_magnitude<ratio(1, 60)>(), metre_per_second>, std::int64_t>>);
 static_assert(
   compare<decltype(1_q_min / 1_q_m), quantity<unknown_dimension<exponent<dim_length, -1>, exponent<dim_time, 1>>,
-                                              scaled_unit<ratio(60), unknown_coherent_unit>, std::int64_t>>);
+                                              scaled_unit<as_magnitude<60>(), unknown_coherent_unit>, std::int64_t>>);
 
 static_assert((1_q_m + 1_q_m).number() == 2);
 static_assert((1_q_m + 1_q_km).number() == 1001);
@@ -882,8 +885,9 @@ static_assert(!is_same_v<decltype(quantity_cast<litre>(2_q_dm3)), volume<cubic_d
 
 static_assert(is_same_v<decltype(10_q_m / 5_q_s),
                         quantity<unknown_dimension<units::exponent<dim_length, 1>, units::exponent<dim_time, -1>>,
-                                 scaled_unit<ratio(1), unknown_coherent_unit>, std::int64_t>>);
-static_assert(is_same_v<decltype(1_q_mm + 1_q_km), length<scaled_unit<ratio(1, 1, -3), metre>, std::int64_t>>);
+                                 scaled_unit<as_magnitude<1>(), unknown_coherent_unit>, std::int64_t>>);
+static_assert(
+  is_same_v<decltype(1_q_mm + 1_q_km), length<scaled_unit<as_magnitude<ratio(1, 1, -3)>(), metre>, std::int64_t>>);
 
 #else
 
@@ -913,7 +917,8 @@ static_assert(same(quotient_remainder_theorem(3'000 * m, 400), 3'000 * m));
 static_assert(same(quotient_remainder_theorem(3'000 * m, quantity(400)), 3'000 * m));
 static_assert(same(quotient_remainder_theorem(3 * km, quantity(400)), 3 * km));
 static_assert(same(quotient_remainder_theorem(3 * km, quantity(2)), 3 * km));
-static_assert(same(quotient_remainder_theorem(3 * km, dimensionless<scaled_unit<ratio(1, 1000), one>, int>(400)),
-                   3 * km));
+static_assert(
+  same(quotient_remainder_theorem(3 * km, dimensionless<scaled_unit<as_magnitude<ratio(1, 1000)>(), one>, int>(400)),
+       3 * km));
 
 }  // namespace

test/unit_test/static/si_test.cpp

@@ -43,7 +43,7 @@ static_assert(1_q_au == 149'597'870'700_q_m);
 static_assert(1_q_km + 1_q_m == 1001_q_m);
 static_assert(10_q_km / 5_q_km == 2);
 static_assert(10_q_km / 5_q_km < 3);
-static_assert(100_q_mm / 5_q_cm == dimensionless<scaled_unit<ratio(1, 1, -1), one>>(20));
+static_assert(100_q_mm / 5_q_cm == dimensionless<scaled_unit<as_magnitude<ratio(1, 10)>(), one>>(20));
 static_assert(100_q_mm / 5_q_cm == dimensionless<one>(2));
 static_assert(10_q_km / 2 == 5_q_km);
 
@@ -107,7 +107,7 @@ static_assert(1000 / 1_q_s == 1_q_kHz);
 static_assert(1 / 1_q_ms == 1_q_kHz);
 static_assert(3.2_q_GHz == 3'200'000'000_q_Hz);
 static_assert((10_q_Hz * 1_q_min).number() == 10);
-static_assert(10_q_Hz * 1_q_min == dimensionless<scaled_unit<ratio(60), one>>(10));
+static_assert(10_q_Hz * 1_q_min == dimensionless<scaled_unit<as_magnitude<60>(), one>>(10));
 static_assert(10_q_Hz * 1_q_min == dimensionless<one>(600));
 static_assert(2 / 1_q_Hz == 2_q_s);
 

test/unit_test/static/unit_test.cpp

@@ -36,12 +36,12 @@ using namespace units::isq;
 struct metre : named_unit<metre, "m", si::prefix> {};
 struct centimetre : prefixed_unit<centimetre, si::centi, metre> {};
 struct kilometre : prefixed_unit<kilometre, si::kilo, metre> {};
-struct yard : named_scaled_unit<yard, "yd", no_prefix, ratio(9'144, 1, -4), metre> {};
-struct foot : named_scaled_unit<foot, "ft", no_prefix, ratio(1, 3), yard> {};
+struct yard : named_scaled_unit<yard, "yd", no_prefix, as_magnitude<ratio(9'144, 1, -4)>(), metre> {};
+struct foot : named_scaled_unit<foot, "ft", no_prefix, as_magnitude<ratio(1, 3)>(), yard> {};
 struct dim_length : base_dimension<"length", metre> {};
 
 struct second : named_unit<second, "s", si::prefix> {};
-struct hour : named_scaled_unit<hour, "h", no_prefix, ratio(36, 1, 2), second> {};
+struct hour : named_scaled_unit<hour, "h", no_prefix, as_magnitude<ratio(36, 1, 2)>(), second> {};
 struct dim_time : base_dimension<"time", second> {};
 
 struct kelvin : named_unit<kelvin, "K", no_prefix> {};
@@ -59,17 +59,21 @@ struct kilometre_per_hour : derived_unit<kilometre_per_hour, dim_speed, kilometr
 
 static_assert(equivalent<metre::named_unit, metre>);
 static_assert(equivalent<metre::scaled_unit, metre>);
-static_assert(compare<downcast<scaled_unit<ratio(1), metre>>, metre>);
-static_assert(compare<downcast<scaled_unit<ratio(1, 1, -2), metre>>, centimetre>);
-static_assert(compare<downcast<scaled_unit<ratio(yard::ratio.num, yard::ratio.den, yard::ratio.exp), metre>>, yard>);
-static_assert(compare<downcast<scaled_unit<yard::ratio * ratio(1, 3), metre>>, foot>);
-static_assert(compare<downcast<scaled_unit<kilometre::ratio / hour::ratio, metre_per_second>>, kilometre_per_hour>);
+static_assert(compare<downcast<scaled_unit<as_magnitude<1>(), metre>>, metre>);
+static_assert(compare<downcast<scaled_unit<as_magnitude<ratio(1, 1, -2)>(), metre>>, centimetre>);
+static_assert(
+  compare<downcast<scaled_unit<as_magnitude<ratio(yard::ratio.num, yard::ratio.den, yard::ratio.exp)>(), metre>>,
+          yard>);
+static_assert(compare<downcast<scaled_unit<yard::mag / as_magnitude<3>(), metre>>, foot>);
+static_assert(compare<downcast<scaled_unit<kilometre::mag / hour::mag, metre_per_second>>, kilometre_per_hour>);
 
-#if !UNITS_COMP_MSVC
-static_assert([]<ratio R>() {
-  return !requires { typename scaled_unit<R, metre>; };
-}.template operator()<ratio(-1, 1)>());  // negative unit ratio
-#endif
+// We should delete this test case, because we are switching from ratio to Magnitude, and a negative Magnitude cannot
+// even be formed.
+// #if !UNITS_COMP_MSVC
+// static_assert([]<ratio R>() {
+//   return !requires { typename scaled_unit<R, metre>; };
+// }.template operator()<as_magnitude<ratio(-1, 1)>()>());  // negative unit ratio
+// #endif
 
 static_assert(centimetre::symbol == "cm");
 static_assert(kilometre::symbol == "km");