refactor: constant_unit abstraction removed and replaced with regular named_unit

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

@@ -50,10 +50,6 @@ struct scaled_unit;
 template<basic_symbol_text Symbol, auto...>
 struct named_unit;
 
-template<basic_symbol_text Symbol, Unit auto U>
-  requires(!Symbol.empty())
-struct constant_unit;
-
 namespace detail {
 
 template<basic_symbol_text Symbol, auto... Args>
@@ -69,21 +65,13 @@ inline constexpr bool is_specialization_of_named_unit = false;
 template<basic_symbol_text Symbol, auto... Args>
 inline constexpr bool is_specialization_of_named_unit<named_unit<Symbol, Args...>> = true;
 
-template<basic_symbol_text Symbol, auto U>
-void to_base_specialization_of_constant_unit(const volatile constant_unit<Symbol, U>*);
-
-template<typename T>
-inline constexpr bool is_derived_from_specialization_of_constant_unit =
-  requires(T* t) { to_base_specialization_of_constant_unit(t); };
-
 /**
  * @brief A concept matching all units with special names
  *
  * Satisfied by all unit types derived from the specialization of `named_unit` (but not constant units).
  */
 template<typename T>
-concept NamedUnit = Unit<T> && detail::is_derived_from_specialization_of_named_unit<T> &&
-                    (!detail::is_derived_from_specialization_of_constant_unit<T>);
+concept NamedUnit = Unit<T> && detail::is_derived_from_specialization_of_named_unit<T>;
 
 }  // namespace detail
 
@@ -144,12 +132,6 @@ inline constexpr bool is_specialization_of_unit = false;
 template<basic_symbol_text Symbol, auto... Args>
 inline constexpr bool is_specialization_of_unit<named_unit<Symbol, Args...>> = true;
 
-template<typename T>
-inline constexpr bool is_specialization_of_constant_unit = false;
-
-template<basic_symbol_text Symbol, auto U>
-inline constexpr bool is_specialization_of_constant_unit<constant_unit<Symbol, U>> = true;
-
 template<typename T>
 inline constexpr bool is_specialization_of_prefixed_unit = false;
 
@@ -158,8 +140,7 @@ inline constexpr bool is_specialization_of_prefixed_unit<prefixed_unit<Symbol, M
 
 template<typename T>
   requires requires(T* t) { is_unit_impl(t); }
-inline constexpr bool is_unit<T> = !is_specialization_of_named_unit<T> && !is_specialization_of_constant_unit<T> &&
-                                   !is_specialization_of_prefixed_unit<T>;
+inline constexpr bool is_unit<T> = !is_specialization_of_named_unit<T> && !is_specialization_of_prefixed_unit<T>;
 
 template<Unit U>
 [[nodiscard]] consteval bool has_associated_quantity(U);

src/core/include/mp-units/unit.h

@@ -162,41 +162,6 @@ struct named_unit<Symbol, U, QS> : std::remove_const_t<decltype(U)> {
   static constexpr auto quantity_spec = QS;
 };
 
-/**
- * @brief A unit of a physical constant
- *
- * Defines a unit of a physical constant together with its value encoded as a unit ratio.
- *
- * This allows moving all of the constant-related ratio manipulation to the compile-time domain
- * (i.e. multiplying and then dividing by the same constant will eliminate the item from the final
- * type).
- * As a result we have faster runtime performance and no precision loss due to eager floating-point
- * operations. Also, if the user prefers integral types for a quantity representation, this will
- * not force the user to convert to a floating-point type right away. Only when a final quantity
- * number needs to actually account for the constant value, the floating-point operation (if any)
- * can be triggered lazily with the `value_cast<U>()`.
- *
- * For example:
- *
- * @code{.cpp}
- * inline constexpr struct standard_gravity_unit :
- *   constant_unit<"g", mag<ratio{980'665, 100'000}> * metre / square(second)> {} standard_gravity_unit;
- * @endcode
- *
- * @note A common convention in this library is to assign the same name for a type and an object of this type.
- *       Besides defining them user never works with the unit types in the source code. All operations
- *       are done on the objects. Contrarily, the unit types are the only one visible in the compilation
- *       errors. Having them of the same names improves user experience and somehow blurs those separate domains.
- *
- * @tparam Symbol a short text representation of the constant
- *
- * @note Constant symbol is printed in the text output encapsulated inside square brackets `[]`
- *       and before any regular units
- */
-template<basic_symbol_text Symbol, Unit auto U>
-  requires(!Symbol.empty())
-struct constant_unit : named_unit<'[' + Symbol + ']', U> {};
-
 /**
  * @brief A prefixed unit
  *
@@ -400,10 +365,6 @@ template<Unit T, typename... Expr>
 template<Unit Lhs, Unit Rhs>
 [[nodiscard]] consteval bool less(Lhs, Rhs)
 {
-  if constexpr ((is_derived_from_specialization_of_constant_unit<Lhs> &&
-                 is_derived_from_specialization_of_constant_unit<Rhs>) ||
-                (!is_derived_from_specialization_of_constant_unit<Lhs> &&
-                 !is_derived_from_specialization_of_constant_unit<Rhs>)) {
   if constexpr (requires {
                   Lhs::symbol;
                   Rhs::symbol;
@@ -413,10 +374,6 @@ template<Unit Lhs, Unit Rhs>
     return Lhs::symbol < Rhs::symbol;
   else
     return type_name<Lhs>() < type_name<Rhs>();
-  } else {
-    // put constants at the front of units list in the expression
-    return is_derived_from_specialization_of_constant_unit<Lhs>;
-  }
 }
 
 

src/systems/hep/include/mp-units/systems/hep/hep.h

@@ -42,6 +42,9 @@ inline constexpr struct barn : named_unit<"b", mag_power<10, -28> * square(si::m
 inline constexpr struct electron_mass : named_unit<"m_e", mag<ratio{9'109'383'701'528, 1'000'000'000'000}> * mag_power<10, -31> * si::kilogram> {} electron_mass;
 inline constexpr struct proton_mass : named_unit<"m_p", mag<ratio{1'672'621'923'695, 1'000'000'000'000}> * mag_power<10, -27> * si::kilogram> {} proton_mass;
 inline constexpr struct neutron_mass : named_unit<"m_n", mag<ratio{1'674'927'498'049, 1'000'000'000'000}> * mag_power<10, -27> * si::kilogram> {} neutron_mass;
+
+// speed
+inline constexpr struct speed_of_light : decltype(si::si2019::speed_of_light_in_vacuum) {} speed_of_light;
 // clang-format on
 
 namespace unit_symbols {
@@ -89,8 +92,8 @@ inline constexpr auto m_e = electron_mass;
 inline constexpr auto m_p = proton_mass;
 inline constexpr auto m_n = neutron_mass;
 
-inline constexpr auto c = si::si2019::speed_of_light_in_vacuum_unit;
-inline constexpr auto c2 = square(si::si2019::speed_of_light_in_vacuum_unit);
+inline constexpr auto c = speed_of_light;
+inline constexpr auto c2 = square(speed_of_light);
 
 }  // namespace unit_symbols
 

src/systems/international/include/mp-units/systems/international/international.h

@@ -56,7 +56,7 @@ inline constexpr struct knot : named_unit<"kn", nautical_mile / si::hour> {} kno
 inline constexpr struct poundal : named_unit<"pdl", pound * foot / square(si::second)> {} poundal;
 
 // https://en.wikipedia.org/wiki/Pound_(force)
-inline constexpr struct pound_force : named_unit<"lbf", pound * si::standard_gravity_unit> {} pound_force;
+inline constexpr struct pound_force : named_unit<"lbf", pound * si::standard_gravity> {} pound_force;
 
 // https://en.wikipedia.org/wiki/Kip_(unit),
 inline constexpr struct kip : decltype(si::kilo<pound_force>) {} kip;

src/systems/si/include/mp-units/systems/si/constants.h

@@ -23,7 +23,6 @@
 #pragma once
 
 #include <mp-units/quantity.h>
-#include <mp-units/systems/isq/isq.h>
 #include <mp-units/systems/si/units.h>
 
 namespace mp_units::si {
@@ -31,42 +30,29 @@ namespace mp_units::si {
 namespace si2019 {
 
 // clang-format off
-inline constexpr struct hyperfine_structure_transition_frequency_of_cs_unit :
-  constant_unit<basic_symbol_text{"ΔνCs", "dvCs"}, mag<9'192'631'770> * hertz> {} hyperfine_structure_transition_frequency_of_cs_unit;
-inline constexpr struct speed_of_light_in_vacuum_unit :
-  constant_unit<"c", mag<299'792'458> * metre / second> {} speed_of_light_in_vacuum_unit;
-inline constexpr struct planck_constant_unit :
-  constant_unit<"h", mag<ratio{662'607'015, 100'000'000}> * mag_power<10, -34> * joule * second> {} planck_constant_unit;
-inline constexpr struct elementary_charge_unit :
-  constant_unit<"e", mag<ratio{1'602'176'634, 1'000'000'000}> * mag_power<10, -19> * coulomb> {} elementary_charge_unit;
-inline constexpr struct boltzmann_constant_unit :
-  constant_unit<"k", mag<ratio{1'380'649, 1'000'000}> * mag_power<10, -23> * joule / kelvin> {} boltzmann_constant_unit;
-inline constexpr struct avogadro_constant_unit :
-  constant_unit<"NA", mag<ratio{602'214'076, 100'000'000}> * mag_power<10, 23> * (1 / mole)> {} avogadro_constant_unit;
-inline constexpr struct luminous_efficacy_unit :
-  constant_unit<"Kcd", mag<683> * lumen / watt> {} luminous_efficacy_unit;
+inline constexpr struct hyperfine_structure_transition_frequency_of_cs :
+  named_unit<basic_symbol_text{"Δν_Cs", "dv_Cs"}, mag<9'192'631'770> * hertz> {} hyperfine_structure_transition_frequency_of_cs;
+inline constexpr struct speed_of_light_in_vacuum :
+  named_unit<"c", mag<299'792'458> * metre / second> {} speed_of_light_in_vacuum;
+inline constexpr struct planck_constant :
+  named_unit<"h", mag<ratio{662'607'015, 100'000'000}> * mag_power<10, -34> * joule * second> {} planck_constant;
+inline constexpr struct elementary_charge :
+  named_unit<"e", mag<ratio{1'602'176'634, 1'000'000'000}> * mag_power<10, -19> * coulomb> {} elementary_charge;
+inline constexpr struct boltzmann_constant :
+  named_unit<"k", mag<ratio{1'380'649, 1'000'000}> * mag_power<10, -23> * joule / kelvin> {} boltzmann_constant;
+inline constexpr struct avogadro_constant :
+  named_unit<"N_A", mag<ratio{602'214'076, 100'000'000}> * mag_power<10, 23> * (1 / mole)> {} avogadro_constant;
+inline constexpr struct luminous_efficacy :
+  named_unit<"K_cd", mag<683> * lumen / watt> {} luminous_efficacy;
 // clang-format on
 
-inline constexpr auto hyperfine_structure_transition_frequency_of_cs =
-  isq::frequency[hyperfine_structure_transition_frequency_of_cs_unit];
-inline constexpr auto speed_of_light_in_vacuum = isq::speed_of_light[speed_of_light_in_vacuum_unit];
-inline constexpr auto planck_constant = isq::action[planck_constant_unit];
-inline constexpr auto elementary_charge = isq::electric_charge[elementary_charge_unit];
-inline constexpr auto boltzmann_constant = isq::entropy[boltzmann_constant_unit];
-inline constexpr auto avogadro_constant = (1 / isq::amount_of_substance)[avogadro_constant_unit];
-// TODO uncomment the below when all the ISQ is provided
-// inline constexpr auto luminous_efficacy = isq::luminous_efficacy_of_radiation[luminous_efficacy_unit];
-
 }  // namespace si2019
 
 // clang-format off
-inline constexpr struct standard_gravity_unit :
-  constant_unit<basic_symbol_text{"g₀", "g_0"}, mag<ratio{980'665, 100'000}> * metre / square(second)> {} standard_gravity_unit;
-inline constexpr struct magnetic_constant_unit :
-  constant_unit<basic_symbol_text{"μ₀", "u_0"}, mag<4> * mag_pi * mag_power<10, -7> * henry / metre> {} magnetic_constant_unit;
+inline constexpr struct standard_gravity :
+  named_unit<basic_symbol_text{"g₀", "g_0"}, mag<ratio{980'665, 100'000}> * metre / square(second)> {} standard_gravity;
+inline constexpr struct magnetic_constant :
+  named_unit<basic_symbol_text{"μ₀", "u_0"}, mag<4> * mag_pi * mag_power<10, -7> * henry / metre> {} magnetic_constant;
 // clang-format on
 
-inline constexpr auto standard_gravity = isq::acceleration_of_free_fall[standard_gravity_unit];
-inline constexpr auto magnetic_constant = isq::magnetic_constant[magnetic_constant_unit];
-
 }  // namespace mp_units::si

test/unit_test/static/concepts_test.cpp

@@ -148,7 +148,7 @@ static_assert(Unit<std::remove_const_t<decltype(1 / si::second)>>);
 static_assert(Unit<std::remove_const_t<decltype(mag<10> * si::second)>>);
 static_assert(Unit<std::remove_const_t<decltype(square(si::metre))>>);
 static_assert(Unit<std::remove_const_t<decltype(pow<2>(si::metre))>>);
-static_assert(Unit<struct si::standard_gravity_unit>);
+static_assert(Unit<struct si::standard_gravity>);
 static_assert(Unit<scaled_unit<mag<10>, struct si::second>>);
 static_assert(Unit<metre_per_second>);
 static_assert(Unit<derived_unit<struct si::metre, per<struct si::second>>>);
@@ -157,7 +157,6 @@ static_assert(!Unit<named_unit<"?", isq::length>>);
 static_assert(!Unit<named_unit<"?">>);
 static_assert(!Unit<named_unit<"?", si::metre / si::second>>);
 static_assert(!Unit<named_unit<"?", si::metre, isq::length>>);
-static_assert(!Unit<constant_unit<"?", si::metre / si::second>>);
 static_assert(!Unit<prefixed_unit<"?", mag<10>, si::second>>);
 static_assert(!Unit<struct isq::dim_length>);
 static_assert(!Unit<int>);
@@ -173,7 +172,7 @@ static_assert(!detail::NamedUnit<std::remove_const_t<decltype(1 / si::second)>>)
 static_assert(!detail::NamedUnit<std::remove_const_t<decltype(mag<10> * si::second)>>);
 static_assert(!detail::NamedUnit<std::remove_const_t<decltype(square(si::metre))>>);
 static_assert(!detail::NamedUnit<std::remove_const_t<decltype(pow<2>(si::metre))>>);
-static_assert(!detail::NamedUnit<struct si::standard_gravity_unit>);
+static_assert(detail::NamedUnit<struct si::standard_gravity>);
 static_assert(!detail::NamedUnit<scaled_unit<mag<10>, struct si::second>>);
 static_assert(!detail::NamedUnit<metre_per_second>);
 static_assert(!detail::NamedUnit<derived_unit<struct si::metre, per<struct si::second>>>);
@@ -182,7 +181,6 @@ static_assert(!detail::NamedUnit<named_unit<"?", isq::length>>);
 static_assert(!detail::NamedUnit<named_unit<"?">>);
 static_assert(!detail::NamedUnit<named_unit<"?", si::metre / si::second>>);
 static_assert(!detail::NamedUnit<named_unit<"?", si::metre, isq::length>>);
-static_assert(!detail::NamedUnit<constant_unit<"?", si::metre / si::second>>);
 static_assert(!detail::NamedUnit<prefixed_unit<"?", mag<10>, si::second>>);
 static_assert(!detail::NamedUnit<struct isq::dim_length>);
 static_assert(!detail::NamedUnit<int>);
@@ -198,7 +196,7 @@ static_assert(!PrefixableUnit<std::remove_const_t<decltype(1 / si::second)>>);
 static_assert(!PrefixableUnit<std::remove_const_t<decltype(mag<10> * si::second)>>);
 static_assert(!PrefixableUnit<std::remove_const_t<decltype(square(si::metre))>>);
 static_assert(!PrefixableUnit<std::remove_const_t<decltype(pow<2>(si::metre))>>);
-static_assert(!PrefixableUnit<struct si::standard_gravity_unit>);
+static_assert(PrefixableUnit<struct si::standard_gravity>);
 static_assert(!PrefixableUnit<scaled_unit<mag<10>, struct si::second>>);
 static_assert(!PrefixableUnit<metre_per_second>);
 static_assert(!PrefixableUnit<derived_unit<struct si::metre, per<struct si::second>>>);
@@ -207,7 +205,6 @@ static_assert(!PrefixableUnit<named_unit<"?", isq::length>>);
 static_assert(!PrefixableUnit<named_unit<"?">>);
 static_assert(!PrefixableUnit<named_unit<"?", si::metre / si::second>>);
 static_assert(!PrefixableUnit<named_unit<"?", si::metre, isq::length>>);
-static_assert(!PrefixableUnit<constant_unit<"?", si::metre / si::second>>);
 static_assert(!PrefixableUnit<prefixed_unit<"?", mag<10>, si::second>>);
 static_assert(!PrefixableUnit<struct isq::dim_length>);
 static_assert(!PrefixableUnit<int>);
@@ -223,7 +220,7 @@ static_assert(AssociatedUnit<std::remove_const_t<decltype(1 / si::second)>>);
 static_assert(AssociatedUnit<std::remove_const_t<decltype(mag<10> * si::second)>>);
 static_assert(AssociatedUnit<std::remove_const_t<decltype(square(si::metre))>>);
 static_assert(AssociatedUnit<std::remove_const_t<decltype(pow<2>(si::metre))>>);
-static_assert(AssociatedUnit<struct si::standard_gravity_unit>);
+static_assert(AssociatedUnit<struct si::standard_gravity>);
 static_assert(AssociatedUnit<scaled_unit<mag<10>, struct si::second>>);
 static_assert(AssociatedUnit<metre_per_second>);
 static_assert(AssociatedUnit<derived_unit<struct si::metre, per<struct si::second>>>);
@@ -232,7 +229,6 @@ static_assert(!AssociatedUnit<named_unit<"?", isq::length>>);
 static_assert(!AssociatedUnit<named_unit<"?">>);
 static_assert(!AssociatedUnit<named_unit<"?", si::metre / si::second>>);
 static_assert(!AssociatedUnit<named_unit<"?", si::metre, isq::length>>);
-static_assert(!AssociatedUnit<constant_unit<"?", si::metre / si::second>>);
 static_assert(!AssociatedUnit<prefixed_unit<"?", mag<10>, si::second>>);
 static_assert(!AssociatedUnit<struct isq::dim_length>);
 static_assert(!AssociatedUnit<int>);

test/unit_test/static/unit_symbol_test.cpp

@@ -159,9 +159,9 @@ static_assert(unit_symbol(pow<3, 5>(metre)) == "m^(3/5)");
 static_assert(unit_symbol(pow<1, 2>(metre / second)) == "m^(1/2)/s^(1/2)");
 
 // Physical constants
-static_assert(unit_symbol(si2019::speed_of_light_in_vacuum_unit) == "[c]");
-static_assert(unit_symbol(gram * standard_gravity_unit * si2019::speed_of_light_in_vacuum_unit) == "[c] [g₀] g");
-static_assert(unit_symbol(gram / standard_gravity_unit) == "g/[g₀]");
+static_assert(unit_symbol(si2019::speed_of_light_in_vacuum) == "c");
+static_assert(unit_symbol(gram * standard_gravity * si2019::speed_of_light_in_vacuum) == "c g g₀");
+static_assert(unit_symbol(gram / standard_gravity) == "g/g₀");
 
 #endif  // __cpp_lib_constexpr_string
 

test/unit_test/static/unit_test.cpp

@@ -87,8 +87,8 @@ inline constexpr struct kilometre_ : decltype(si::kilo<metre>) {} kilometre;
 inline constexpr struct kilojoule_ : decltype(si::kilo<joule>) {} kilojoule;
 
 // physical constant units
-inline constexpr struct standard_gravity_unit_ : constant_unit<"g", mag<ratio{980'665, 100'000}> * metre / square(second)> {} standard_gravity_unit;
-inline constexpr struct speed_of_light_in_vacuum_unit_ : constant_unit<"c", mag<299'792'458> * metre / second> {} speed_of_light_in_vacuum_unit;
+inline constexpr struct standard_gravity_ : named_unit<basic_symbol_text{"g₀", "g_0"}, mag<ratio{980'665, 100'000}> * metre / square(second)> {} standard_gravity;
+inline constexpr struct speed_of_light_in_vacuum_ : named_unit<"c", mag<299'792'458> * metre / second> {} speed_of_light_in_vacuum;
 
 // clang-format on
 
@@ -190,15 +190,15 @@ static_assert(joule != newton);
 static_assert(is_of_type<nu_second / nu_second, one_>);
 
 // constant_unit
-static_assert(is_of_type<standard_gravity_unit, standard_gravity_unit_>);
+static_assert(is_of_type<standard_gravity, standard_gravity_>);
 static_assert(
-  is_of_type<get_canonical_unit(standard_gravity_unit).reference_unit, derived_unit<metre_, per<power<second_, 2>>>>);
-static_assert(get_canonical_unit(standard_gravity_unit).mag == mag<ratio{980'665, 100'000}>);
-static_assert(convertible(standard_gravity_unit, standard_gravity_unit));
-static_assert(convertible(standard_gravity_unit, metre / square(second)));
-static_assert(standard_gravity_unit == standard_gravity_unit);
-static_assert(standard_gravity_unit != metre / square(second));  // magnitude is different
-static_assert(standard_gravity_unit.symbol == "[g]");
+  is_of_type<get_canonical_unit(standard_gravity).reference_unit, derived_unit<metre_, per<power<second_, 2>>>>);
+static_assert(get_canonical_unit(standard_gravity).mag == mag<ratio{980'665, 100'000}>);
+static_assert(convertible(standard_gravity, standard_gravity));
+static_assert(convertible(standard_gravity, metre / square(second)));
+static_assert(standard_gravity == standard_gravity);
+static_assert(standard_gravity != metre / square(second));  // magnitude is different
+static_assert(standard_gravity.symbol == basic_symbol_text{"g₀", "g_0"});
 
 // prefixed_unit
 static_assert(is_of_type<kilometre, kilometre_>);
@@ -333,15 +333,15 @@ static_assert(is_of_type<one * metre * square(second) / gram, derived_unit<metre
 static_assert(is_of_type<(metre * square(second) / gram) * one, derived_unit<metre_, power<second_, 2>, per<gram_>>>);
 static_assert(is_of_type<metre * square(second) / gram * one, derived_unit<metre_, power<second_, 2>, per<gram_>>>);
 
-static_assert(is_of_type<standard_gravity_unit * gram, derived_unit<standard_gravity_unit_, gram_>>);
-static_assert(is_of_type<gram * standard_gravity_unit, derived_unit<standard_gravity_unit_, gram_>>);
-static_assert(is_of_type<standard_gravity_unit / gram, derived_unit<standard_gravity_unit_, per<gram_>>>);
-static_assert(is_of_type<gram / standard_gravity_unit, derived_unit<gram_, per<standard_gravity_unit_>>>);
-static_assert(is_of_type<standard_gravity_unit * gram / standard_gravity_unit, gram_>);
-static_assert(is_of_type<speed_of_light_in_vacuum_unit * gram * standard_gravity_unit,
-                         derived_unit<speed_of_light_in_vacuum_unit_, standard_gravity_unit_, gram_>>);
-static_assert(is_of_type<gram * standard_gravity_unit * speed_of_light_in_vacuum_unit,
-                         derived_unit<speed_of_light_in_vacuum_unit_, standard_gravity_unit_, gram_>>);
+static_assert(is_of_type<standard_gravity * gram, derived_unit<gram_, standard_gravity_>>);
+static_assert(is_of_type<gram * standard_gravity, derived_unit<gram_, standard_gravity_>>);
+static_assert(is_of_type<standard_gravity / gram, derived_unit<standard_gravity_, per<gram_>>>);
+static_assert(is_of_type<gram / standard_gravity, derived_unit<gram_, per<standard_gravity_>>>);
+static_assert(is_of_type<standard_gravity * gram / standard_gravity, gram_>);
+static_assert(is_of_type<speed_of_light_in_vacuum * gram * standard_gravity,
+                         derived_unit<speed_of_light_in_vacuum_, gram_, standard_gravity_>>);
+static_assert(is_of_type<gram * standard_gravity * speed_of_light_in_vacuum,
+                         derived_unit<speed_of_light_in_vacuum_, gram_, standard_gravity_>>);
 
 static_assert(std::is_same_v<decltype(1 / second * metre), decltype(metre / second)>);
 static_assert(std::is_same_v<decltype(metre * (1 / second)), decltype(metre / second)>);
@@ -374,11 +374,11 @@ static_assert(
   is_of_type<get_canonical_unit(1 / pascal).reference_unit, derived_unit<metre_, power<second_, 2>, per<gram_>>>);
 
 static_assert(
-  is_of_type<get_canonical_unit(standard_gravity_unit).reference_unit, derived_unit<metre_, per<power<second_, 2>>>>);
-static_assert(get_canonical_unit(standard_gravity_unit).mag == mag<ratio{980'665, 100'000}>);
-static_assert(is_of_type<get_canonical_unit(standard_gravity_unit* gram).reference_unit,
+  is_of_type<get_canonical_unit(standard_gravity).reference_unit, derived_unit<metre_, per<power<second_, 2>>>>);
+static_assert(get_canonical_unit(standard_gravity).mag == mag<ratio{980'665, 100'000}>);
+static_assert(is_of_type<get_canonical_unit(standard_gravity* gram).reference_unit,
                          derived_unit<gram_, metre_, per<power<second_, 2>>>>);
-static_assert(is_of_type<get_canonical_unit(standard_gravity_unit / speed_of_light_in_vacuum_unit).reference_unit,
+static_assert(is_of_type<get_canonical_unit(standard_gravity / speed_of_light_in_vacuum).reference_unit,
                          derived_unit<one_, per<second_>>>);
 
 // operations commutativity
@@ -532,7 +532,6 @@ static_assert(is_of_type<common_unit(metre / second, kilometre / hour),
                          scaled_unit<mag<ratio{1, 18}>, derived_unit<metre_, per<second_>>>>);
 static_assert(is_of_type<common_unit(kilometre, mile), scaled_unit<mag<ratio{8, 125}>, metre_>>);
 static_assert(is_of_type<common_unit(mile, kilometre), scaled_unit<mag<ratio{8, 125}>, metre_>>);
-static_assert(
-  is_of_type<common_unit(speed_of_light_in_vacuum_unit, metre / second), derived_unit<metre_, per<second_>>>);
+static_assert(is_of_type<common_unit(speed_of_light_in_vacuum, metre / second), derived_unit<metre_, per<second_>>>);
 
 }  // namespace