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

This is easier to write and to read.

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");