Rename as_magnitude<...>() to mag<...>()

This is easier to write and to read.

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<pow<6>(as_magnitude<10>()), metre>> q(123);
+      const length<scaled_unit<pow<6>(mag<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<pow<-2>(as_magnitude<10>()), joule>> q(60);
+      const energy<scaled_unit<pow<-2>(mag<10>()), joule>> q(60);
       os << q;
 
       SECTION("iostream") { CHECK(os.str() == "60 cJ"); }

test/unit_test/runtime/fmt_units_test.cpp

@@ -327,7 +327,7 @@ TEST_CASE("std::format on synthesized unit symbols", "[text][fmt]")
   SECTION("unknown scaled unit with reference different than the dimension's coherent unit")
   {
     // TODO(chogg): Reinstate after format/Magnitude redesign.
-    // constexpr auto mag = units::as_magnitude<units::ratio{2, 3}>();
+    // constexpr auto mag = units::mag<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/runtime/magnitude_test.cpp

@@ -66,7 +66,7 @@ void check_same_type_and_value(T actual, U expected)
 template<ratio R>
 void check_ratio_round_trip_is_identity()
 {
-  constexpr Magnitude auto m = as_magnitude<R>();
+  constexpr Magnitude auto m = mag<R>();
   constexpr ratio round_trip = ratio{
     get_value<std::intmax_t>(numerator(m)),
     get_value<std::intmax_t>(denominator(m)),
@@ -125,10 +125,10 @@ TEST_CASE("base_power")
 
   SECTION("product with inverse equals identity")
   {
-    auto check_product_with_inverse_is_identity = [](auto x) { CHECK(x * pow<-1>(x) == as_magnitude<1>()); };
+    auto check_product_with_inverse_is_identity = [](auto x) { CHECK(x * pow<-1>(x) == mag<1>()); };
 
-    check_product_with_inverse_is_identity(as_magnitude<3>());
-    check_product_with_inverse_is_identity(as_magnitude<ratio{4, 17}>());
+    check_product_with_inverse_is_identity(mag<3>());
+    check_product_with_inverse_is_identity(mag<ratio{4, 17}>());
     check_product_with_inverse_is_identity(pi_to_the<ratio{-22, 7}>());
   }
 
@@ -144,21 +144,21 @@ TEST_CASE("make_ratio performs prime factorization correctly")
 {
   SECTION("Performs prime factorization when denominator is 1")
   {
-    CHECK(as_magnitude<1>() == magnitude<>{});
-    CHECK(as_magnitude<2>() == magnitude<base_power{2}>{});
-    CHECK(as_magnitude<3>() == magnitude<base_power{3}>{});
-    CHECK(as_magnitude<4>() == magnitude<base_power{2, 2}>{});
+    CHECK(mag<1>() == magnitude<>{});
+    CHECK(mag<2>() == magnitude<base_power{2}>{});
+    CHECK(mag<3>() == magnitude<base_power{3}>{});
+    CHECK(mag<4>() == magnitude<base_power{2, 2}>{});
 
-    CHECK(as_magnitude<792>() == magnitude<base_power{2, 3}, base_power{3, 2}, base_power{11}>{});
+    CHECK(mag<792>() == magnitude<base_power{2, 3}, base_power{3, 2}, base_power{11}>{});
   }
 
-  SECTION("Supports fractions") { CHECK(as_magnitude<ratio{5, 8}>() == magnitude<base_power{2, -3}, base_power{5}>{}); }
+  SECTION("Supports fractions") { CHECK(mag<ratio{5, 8}>() == magnitude<base_power{2, -3}, base_power{5}>{}); }
 
   SECTION("Can handle prime factor which would be large enough to overflow int")
   {
     // This was taken from a case which failed when we used `int` for our base to store prime numbers.
     // The failure was due to a prime factor which is larger than 2^31.
-    as_magnitude<ratio(16'605'390'666'050, 10'000'000'000'000)>();
+    mag<ratio(16'605'390'666'050, 10'000'000'000'000)>();
   }
 
   SECTION("Can bypass computing primes by providing known_first_factor<N>")
@@ -169,7 +169,7 @@ TEST_CASE("make_ratio performs prime factorization correctly")
     // In this case, we test that we can represent the largest prime that fits in a signed 64-bit int.  The reason this
     // test can pass is that we have provided the answer, by specializing the `known_first_factor` variable template
     // above in this file.
-    as_magnitude<9'223'372'036'854'775'783>();
+    mag<9'223'372'036'854'775'783>();
   }
 }
 
@@ -177,7 +177,7 @@ TEST_CASE("magnitude converts to numerical value")
 {
   SECTION("Positive integer powers of integer bases give integer values")
   {
-    constexpr auto mag_412 = as_magnitude<412>();
+    constexpr auto mag_412 = mag<412>();
     check_same_type_and_value(get_value<int>(mag_412), 412);
     check_same_type_and_value(get_value<std::size_t>(mag_412), std::size_t{412});
     check_same_type_and_value(get_value<float>(mag_412), 412.0f);
@@ -186,7 +186,7 @@ TEST_CASE("magnitude converts to numerical value")
 
   SECTION("Negative integer powers of integer bases compute correct values")
   {
-    constexpr auto mag_0p125 = as_magnitude<ratio{1, 8}>();
+    constexpr auto mag_0p125 = mag<ratio{1, 8}>();
     check_same_type_and_value(get_value<float>(mag_0p125), 0.125f);
     check_same_type_and_value(get_value<double>(mag_0p125), 0.125);
   }
@@ -219,20 +219,20 @@ TEST_CASE("magnitude converts to numerical value")
     // Naturally, we cannot actually write a test to verify a compiler error.  But any of these can
     // be uncommented if desired to verify that it breaks the build.
 
-    // get_value<int8_t>(as_magnitude<412>());
+    // get_value<int8_t>(mag<412>());
 
     // Would work for pow<62>:
-    // get_value<int64_t>(pow<63>(as_magnitude<2>()));
+    // get_value<int64_t>(pow<63>(mag<2>()));
 
     // Would work for pow<63>:
-    // get_value<uint64_t>(pow<64>(as_magnitude<2>()));
+    // get_value<uint64_t>(pow<64>(mag<2>()));
 
-    get_value<double>(pow<308>(as_magnitude<10>()));  // Compiles, correctly.
-    // get_value<double>(pow<309>(as_magnitude<10>()));
-    // get_value<double>(pow<3099>(as_magnitude<10>()));
-    // get_value<double>(pow<3099999>(as_magnitude<10>()));
+    get_value<double>(pow<308>(mag<10>()));  // Compiles, correctly.
+    // get_value<double>(pow<309>(mag<10>()));
+    // get_value<double>(pow<3099>(mag<10>()));
+    // get_value<double>(pow<3099999>(mag<10>()));
 
-    auto sqrt_2 = pow<ratio{1, 2}>(as_magnitude<2>());
+    auto sqrt_2 = pow<ratio{1, 2}>(mag<2>());
     CHECK(!is_integral(sqrt_2));
     // get_value<int>(sqrt_2);
   }
@@ -242,46 +242,40 @@ TEST_CASE("Equality works for magnitudes")
 {
   SECTION("Equivalent ratios are equal")
   {
-    CHECK(as_magnitude<1>() == as_magnitude<1>());
-    CHECK(as_magnitude<3>() == as_magnitude<3>());
-    CHECK(as_magnitude<ratio{3, 4}>() == as_magnitude<ratio{9, 12}>());
+    CHECK(mag<1>() == mag<1>());
+    CHECK(mag<3>() == mag<3>());
+    CHECK(mag<ratio{3, 4}>() == mag<ratio{9, 12}>());
   }
 
   SECTION("Different ratios are unequal")
   {
-    CHECK(as_magnitude<3>() != as_magnitude<5>());
-    CHECK(as_magnitude<3>() != as_magnitude<ratio{3, 2}>());
+    CHECK(mag<3>() != mag<5>());
+    CHECK(mag<3>() != mag<ratio{3, 2}>());
   }
 
   SECTION("Supports constexpr")
   {
-    constexpr auto eq = (as_magnitude<ratio{4, 5}>() == as_magnitude<ratio{4, 3}>());
+    constexpr auto eq = (mag<ratio{4, 5}>() == mag<ratio{4, 3}>());
     CHECK(!eq);
   }
 }
 
 TEST_CASE("Multiplication works for magnitudes")
 {
-  SECTION("Reciprocals reduce to null magnitude")
-  {
-    CHECK(as_magnitude<ratio{3, 4}>() * as_magnitude<ratio{4, 3}>() == as_magnitude<1>());
-  }
+  SECTION("Reciprocals reduce to null magnitude") { CHECK(mag<ratio{3, 4}>() * mag<ratio{4, 3}>() == mag<1>()); }
 
-  SECTION("Products work as expected")
-  {
-    CHECK(as_magnitude<ratio{4, 5}>() * as_magnitude<ratio{4, 3}>() == as_magnitude<ratio{16, 15}>());
-  }
+  SECTION("Products work as expected") { CHECK(mag<ratio{4, 5}>() * mag<ratio{4, 3}>() == mag<ratio{16, 15}>()); }
 
   SECTION("Products handle pi correctly")
   {
-    CHECK(pi_to_the<1>() * as_magnitude<ratio{2, 3}>() * pi_to_the<ratio{-1, 2}>() ==
+    CHECK(pi_to_the<1>() * mag<ratio{2, 3}>() * pi_to_the<ratio{-1, 2}>() ==
           magnitude<base_power{2}, base_power{3, -1}, base_power<pi_base>{ratio{1, 2}}>{});
   }
 
   SECTION("Supports constexpr")
   {
-    constexpr auto p = as_magnitude<ratio{4, 5}>() * as_magnitude<ratio{4, 3}>();
-    CHECK(p == as_magnitude<ratio{16, 15}>());
+    constexpr auto p = mag<ratio{4, 5}>() * mag<ratio{4, 3}>();
+    CHECK(p == mag<ratio{16, 15}>());
   }
 }
 
@@ -289,20 +283,20 @@ TEST_CASE("Common Magnitude")
 {
   SECTION("Identity for identical magnitudes")
   {
-    CHECK(common_magnitude(as_magnitude<1>(), as_magnitude<1>()) == as_magnitude<1>());
-    CHECK(common_magnitude(as_magnitude<15>(), as_magnitude<15>()) == as_magnitude<15>());
+    CHECK(common_magnitude(mag<1>(), mag<1>()) == mag<1>());
+    CHECK(common_magnitude(mag<15>(), mag<15>()) == mag<15>());
     CHECK(common_magnitude(pi_to_the<ratio{3, 4}>(), pi_to_the<ratio{3, 4}>()) == pi_to_the<ratio{3, 4}>());
   }
 
   SECTION("Greatest Common Factor for integers")
   {
-    CHECK(common_magnitude(as_magnitude<24>(), as_magnitude<36>()) == as_magnitude<12>());
-    CHECK(common_magnitude(as_magnitude<24>(), as_magnitude<37>()) == as_magnitude<1>());
+    CHECK(common_magnitude(mag<24>(), mag<36>()) == mag<12>());
+    CHECK(common_magnitude(mag<24>(), mag<37>()) == mag<1>());
   }
 
   SECTION("Handles fractions")
   {
-    CHECK(common_magnitude(as_magnitude<ratio{3, 8}>(), as_magnitude<ratio{5, 6}>()) == as_magnitude<ratio{1, 24}>());
+    CHECK(common_magnitude(mag<ratio{3, 8}>(), mag<ratio{5, 6}>()) == mag<ratio{1, 24}>());
   }
 }
 
@@ -310,19 +304,16 @@ TEST_CASE("Division works for magnitudes")
 {
   SECTION("Dividing anything by itself reduces to null magnitude")
   {
-    CHECK(as_magnitude<ratio{3, 4}>() / as_magnitude<ratio{3, 4}>() == as_magnitude<1>());
-    CHECK(as_magnitude<15>() / as_magnitude<15>() == as_magnitude<1>());
+    CHECK(mag<ratio{3, 4}>() / mag<ratio{3, 4}>() == mag<1>());
+    CHECK(mag<15>() / mag<15>() == mag<1>());
   }
 
-  SECTION("Quotients work as expected")
-  {
-    CHECK(as_magnitude<ratio{4, 5}>() / as_magnitude<ratio{4, 3}>() == as_magnitude<ratio{3, 5}>());
-  }
+  SECTION("Quotients work as expected") { CHECK(mag<ratio{4, 5}>() / mag<ratio{4, 3}>() == mag<ratio{3, 5}>()); }
 
   SECTION("Supports constexpr")
   {
-    constexpr auto q = as_magnitude<ratio{4, 5}>() / as_magnitude<ratio{4, 3}>();
-    CHECK(q == as_magnitude<ratio{3, 5}>());
+    constexpr auto q = mag<ratio{4, 5}>() / mag<ratio{4, 3}>();
+    CHECK(q == mag<ratio{3, 5}>());
   }
 }
 
@@ -330,17 +321,17 @@ TEST_CASE("Can raise Magnitudes to rational powers")
 {
   SECTION("Anything to the 0 is 1")
   {
-    CHECK(pow<0>(as_magnitude<1>()) == as_magnitude<1>());
-    CHECK(pow<0>(as_magnitude<123>()) == as_magnitude<1>());
-    CHECK(pow<0>(as_magnitude<ratio{3, 4}>()) == as_magnitude<1>());
-    CHECK(pow<0>(pi_to_the<ratio{-1, 2}>()) == as_magnitude<1>());
+    CHECK(pow<0>(mag<1>()) == mag<1>());
+    CHECK(pow<0>(mag<123>()) == mag<1>());
+    CHECK(pow<0>(mag<ratio{3, 4}>()) == mag<1>());
+    CHECK(pow<0>(pi_to_the<ratio{-1, 2}>()) == mag<1>());
   }
 
   SECTION("Anything to the 1 is itself")
   {
-    CHECK(pow<1>(as_magnitude<1>()) == as_magnitude<1>());
-    CHECK(pow<1>(as_magnitude<123>()) == as_magnitude<123>());
-    CHECK(pow<1>(as_magnitude<ratio{3, 4}>()) == as_magnitude<ratio{3, 4}>());
+    CHECK(pow<1>(mag<1>()) == mag<1>());
+    CHECK(pow<1>(mag<123>()) == mag<123>());
+    CHECK(pow<1>(mag<ratio{3, 4}>()) == mag<ratio{3, 4}>());
     CHECK(pow<1>(pi_to_the<ratio{-1, 2}>()) == pi_to_the<ratio{-1, 2}>());
   }
 
@@ -359,11 +350,11 @@ TEST_CASE("can distinguish integral, rational, and irrational magnitudes")
       CHECK(is_rational(m));
     };
     check_rational_and_integral(magnitude<>{});
-    check_rational_and_integral(as_magnitude<1>());
-    check_rational_and_integral(as_magnitude<3>());
-    check_rational_and_integral(as_magnitude<8>());
-    check_rational_and_integral(as_magnitude<412>());
-    check_rational_and_integral(as_magnitude<ratio{1, 1}>());
+    check_rational_and_integral(mag<1>());
+    check_rational_and_integral(mag<3>());
+    check_rational_and_integral(mag<8>());
+    check_rational_and_integral(mag<412>());
+    check_rational_and_integral(mag<ratio{1, 1}>());
   }
 
   SECTION("Fractional magnitudes are rational, but not integral")
@@ -372,8 +363,8 @@ TEST_CASE("can distinguish integral, rational, and irrational magnitudes")
       CHECK(!is_integral(m));
       CHECK(is_rational(m));
     };
-    check_rational_but_not_integral(as_magnitude<ratio{1, 2}>());
-    check_rational_but_not_integral(as_magnitude<ratio{5, 8}>());
+    check_rational_but_not_integral(mag<ratio{1, 2}>());
+    check_rational_but_not_integral(mag<ratio{5, 8}>());
   }
 }
 
@@ -390,17 +381,17 @@ TEST_CASE("Constructing ratio from rational magnitude")
 
   SECTION("Rational magnitude converts to ratio")
   {
-    constexpr ratio r = as_ratio(as_magnitude<ratio{22, 7}>());
+    constexpr ratio r = as_ratio(mag<ratio{22, 7}>());
     CHECK(r == ratio{22, 7});
   }
 
   SECTION("Irrational magnitude does not convert to ratio")
   {
     // The following code should not compile.
-    // as_ratio(pow<ratio{1, 2}>(as_magnitude<2>()));
+    // as_ratio(pow<ratio{1, 2}>(mag<2>()));
 
     // The following code should not compile.
-    // as_ratio(as_magnitude<180>() / pi_to_the<1>());
+    // as_ratio(mag<180>() / pi_to_the<1>());
   }
 }
 
@@ -607,26 +598,26 @@ TEST_CASE("extract_power_of_10")
 {
   SECTION("Picks out positive powers")
   {
-    CHECK(extract_power_of_10(as_magnitude<10>()) == 1);
-    CHECK(extract_power_of_10(as_magnitude<20>()) == 1);
-    CHECK(extract_power_of_10(as_magnitude<40>()) == 1);
-    CHECK(extract_power_of_10(as_magnitude<50>()) == 1);
-    CHECK(extract_power_of_10(as_magnitude<100>()) == 2);
+    CHECK(extract_power_of_10(mag<10>()) == 1);
+    CHECK(extract_power_of_10(mag<20>()) == 1);
+    CHECK(extract_power_of_10(mag<40>()) == 1);
+    CHECK(extract_power_of_10(mag<50>()) == 1);
+    CHECK(extract_power_of_10(mag<100>()) == 2);
   }
 
   SECTION("Picks out negative powers")
   {
-    constexpr auto ONE = as_magnitude<1>();
-    CHECK(extract_power_of_10(ONE / as_magnitude<10>()) == -1);
-    CHECK(extract_power_of_10(ONE / as_magnitude<20>()) == -1);
-    CHECK(extract_power_of_10(ONE / as_magnitude<40>()) == -1);
-    CHECK(extract_power_of_10(ONE / as_magnitude<50>()) == -1);
-    CHECK(extract_power_of_10(ONE / as_magnitude<100>()) == -2);
+    constexpr auto ONE = mag<1>();
+    CHECK(extract_power_of_10(ONE / mag<10>()) == -1);
+    CHECK(extract_power_of_10(ONE / mag<20>()) == -1);
+    CHECK(extract_power_of_10(ONE / mag<40>()) == -1);
+    CHECK(extract_power_of_10(ONE / mag<50>()) == -1);
+    CHECK(extract_power_of_10(ONE / mag<100>()) == -2);
   }
 
-  SECTION("Zero if signs disagree") { CHECK(extract_power_of_10(as_magnitude<2>() / as_magnitude<5>()) == 0); }
+  SECTION("Zero if signs disagree") { CHECK(extract_power_of_10(mag<2>() / mag<5>()) == 0); }
 
-  SECTION("Handles rational powers") { CHECK(extract_power_of_10(sqrt(as_magnitude<1000>())) == 1); }
+  SECTION("Handles rational powers") { CHECK(extract_power_of_10(sqrt(mag<1000>())) == 1); }
 }
 
 }  // namespace

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<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 *= quantity_kind<downcast_kind<Width, dim_one>, scaled_unit<mag<1000>(), one>, int>{1}; };
+    requires !requires { w /= quantity_kind<downcast_kind<Width, dim_one>, scaled_unit<mag<1000>(), one>, int>{1}; };
+    requires !requires { w %= quantity_kind<downcast_kind<Width, dim_one>, scaled_unit<mag<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

@@ -498,7 +498,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<as_magnitude<ratio(1, 100)>(), hertz>, std::int64_t>>);
+                      frequency<scaled_unit<mag<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&&>);
@@ -529,7 +529,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<as_magnitude<ratio(1, 100)>(), hertz>, long double>>);
+                      frequency<scaled_unit<mag<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>>);
@@ -551,7 +551,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<as_magnitude<ratio(1, 100)>(), hertz>, long double>>);
+                      frequency<scaled_unit<mag<ratio(1, 100)>(), hertz>, long double>>);
 
 // different units
 static_assert(compare<decltype(1_q_m + 1_q_km), length<metre, std::int64_t>>);
@@ -579,24 +579,23 @@ 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<as_magnitude<3600>(), metre>, std::int64_t>>);
+static_assert(compare<decltype(1_q_m_per_s * 1_q_h), length<scaled_unit<mag<3600>(), 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<as_magnitude<60>(), unknown_coherent_unit>, std::int64_t>>);
+                                              scaled_unit<mag<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<as_magnitude<ratio(1, 60)>(), hertz>, std::int64_t>>);
+static_assert(compare<decltype(1 / 1_q_min), frequency<scaled_unit<mag<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, 1000)>(), 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 / 1_q_km), quantity<unknown_dimension<exponent<dim_length, -1>>,
+                                         scaled_unit<mag<ratio(1, 1000)>(), unknown_coherent_unit>, std::int64_t>>);
+static_assert(compare<decltype(1_q_km / 1_q_m), dimensionless<scaled_unit<mag<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<as_magnitude<ratio(1, 60)>(), metre_per_second>, std::int64_t>>);
+  compare<decltype(1_q_m / 1_q_min), speed<scaled_unit<mag<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<as_magnitude<60>(), unknown_coherent_unit>, std::int64_t>>);
+                                              scaled_unit<mag<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);
@@ -886,9 +885,8 @@ 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<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, 1000)>(), metre>, std::int64_t>>);
+                                 scaled_unit<mag<1>(), unknown_coherent_unit>, std::int64_t>>);
+static_assert(is_same_v<decltype(1_q_mm + 1_q_km), length<scaled_unit<mag<ratio(1, 1000)>(), metre>, std::int64_t>>);
 
 #else
 
@@ -918,8 +916,7 @@ static_assert(same(quotient_remainder_theorem(3'000 * m, 400), 3'000 * m));
 static_assert(comp(quotient_remainder_theorem(3'000 * m, quantity(400)), 3'000 * m));
 static_assert(comp(quotient_remainder_theorem(3 * km, quantity(400)), 3 * km));
 static_assert(comp(quotient_remainder_theorem(3 * km, quantity(2)), 3 * km));
-static_assert(
-  comp(quotient_remainder_theorem(3 * km, dimensionless<scaled_unit<as_magnitude<ratio(1, 1000)>(), one>, int>(400)),
-       3 * km));
+static_assert(comp(quotient_remainder_theorem(3 * km, dimensionless<scaled_unit<mag<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<as_magnitude<ratio(1, 10)>(), one>>(20));
+static_assert(100_q_mm / 5_q_cm == dimensionless<scaled_unit<mag<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<as_magnitude<60>(), one>>(10));
+static_assert(10_q_Hz * 1_q_min == dimensionless<scaled_unit<mag<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"> {};
 struct centimetre : prefixed_unit<centimetre, si::centi, metre> {};
 struct kilometre : prefixed_unit<kilometre, si::kilo, metre> {};
-struct yard : named_scaled_unit<yard, "yd", as_magnitude<ratio{9'144, 10'000}>(), metre> {};
-struct foot : named_scaled_unit<foot, "ft", as_magnitude<ratio(1, 3)>(), yard> {};
+struct yard : named_scaled_unit<yard, "yd", mag<ratio{9'144, 10'000}>(), metre> {};
+struct foot : named_scaled_unit<foot, "ft", mag<ratio(1, 3)>(), yard> {};
 struct dim_length : base_dimension<"length", metre> {};
 
 struct second : named_unit<second, "s"> {};
-struct hour : named_scaled_unit<hour, "h", as_magnitude<3600>(), second> {};
+struct hour : named_scaled_unit<hour, "h", mag<3600>(), second> {};
 struct dim_time : base_dimension<"time", second> {};
 
 struct kelvin : named_unit<kelvin, "K"> {};
@@ -59,10 +59,10 @@ struct kilometre_per_hour : derived_scaled_unit<kilometre_per_hour, dim_speed, k
 
 static_assert(equivalent<metre::named_unit, metre>);
 static_assert(equivalent<metre::scaled_unit, metre>);
-static_assert(compare<downcast<scaled_unit<as_magnitude<1>(), metre>>, metre>);
-static_assert(compare<downcast<scaled_unit<as_magnitude<ratio(1, 100)>(), metre>>, centimetre>);
+static_assert(compare<downcast<scaled_unit<mag<1>(), metre>>, metre>);
+static_assert(compare<downcast<scaled_unit<mag<ratio(1, 100)>(), metre>>, centimetre>);
 static_assert(compare<downcast<scaled_unit<yard::mag, metre>>, yard>);
-static_assert(compare<downcast<scaled_unit<yard::mag / as_magnitude<3>(), metre>>, foot>);
+static_assert(compare<downcast<scaled_unit<yard::mag / mag<3>(), metre>>, foot>);
 static_assert(compare<downcast<scaled_unit<kilometre::mag / hour::mag, metre_per_second>>, kilometre_per_hour>);
 
 static_assert(centimetre::symbol == "cm");