feat: unit_constants

src/include/units/bits/one_rep.h

@@ -0,0 +1,69 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2018 Mateusz Pusz
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#pragma once
+
+#include <units/bits/basic_concepts.h>
+#include <units/customization_points.h>
+#include <type_traits>
+
+namespace units::detail {
+
+struct one_rep {
+  template<QuantityValue Rep>
+  [[nodiscard]] friend constexpr Rep operator*(const Rep& lhs, one_rep)
+  {
+    return lhs;
+  }
+  template<QuantityValue Rep>
+  [[nodiscard]] friend constexpr Rep operator/(const Rep& lhs, one_rep)
+  {
+    return lhs;
+  }
+
+  template<QuantityValue Rep>
+  [[nodiscard]] constexpr operator Rep() const noexcept
+  {
+    return quantity_values<Rep>::one();
+  }
+
+  [[nodiscard]] bool operator==(const one_rep&) const = default;
+  [[nodiscard]] auto operator<=>(const one_rep&) const = default;
+};
+
+}  // namespace units::detail
+
+namespace std {
+template<>
+struct common_type<units::detail::one_rep, units::detail::one_rep> {
+  using type = units::detail::one_rep;
+};
+template<units::QuantityValue Rep>
+struct common_type<units::detail::one_rep, Rep> {
+  using type = Rep;
+};
+template<units::QuantityValue Rep>
+struct common_type<Rep, units::detail::one_rep> {
+  using type = Rep;
+};
+
+}  // namespace std

src/include/units/data/base/information.h

@@ -22,6 +22,7 @@
 
 #pragma once
 
+#include <units/bits/one_rep.h>
 #include <units/base_dimension.h>
 #include <units/data/prefixes.h>
 #include <units/unit.h>
@@ -71,4 +72,22 @@ constexpr auto operator"" _q_PiB(unsigned long long l) { return information<pebi
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto b = information<bit, detail::one_rep>{};
+inline constexpr auto Kib = information<kibibit, detail::one_rep>{};
+inline constexpr auto Mib = information<mebibit, detail::one_rep>{};
+inline constexpr auto Gib = information<gibibit, detail::one_rep>{};
+inline constexpr auto Tib = information<tebibit, detail::one_rep>{};
+inline constexpr auto Pib = information<pebibit, detail::one_rep>{};
+
+inline constexpr auto B = information<byte, detail::one_rep>{};
+inline constexpr auto KiB = information<kibibyte, detail::one_rep>{};
+inline constexpr auto MiB = information<mebibyte, detail::one_rep>{};
+inline constexpr auto GiB = information<gibibyte, detail::one_rep>{};
+inline constexpr auto TiB = information<tebibyte, detail::one_rep>{};
+inline constexpr auto PiB = information<pebibyte, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::data

src/include/units/data/derived/bitrate.h

@@ -56,4 +56,15 @@ constexpr auto operator"" _q_Pib_per_s(unsigned long long l) { return bitrate<pe
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto b_per_s = bitrate<bit_per_second, detail::one_rep>{};
+inline constexpr auto Kib_per_s = bitrate<kibibit_per_second, detail::one_rep>{};
+inline constexpr auto Mib_per_s = bitrate<mebibit_per_second, detail::one_rep>{};
+inline constexpr auto Gib_per_s = bitrate<gibibit_per_second, detail::one_rep>{};
+inline constexpr auto Tib_per_s = bitrate<tebibit_per_second, detail::one_rep>{};
+inline constexpr auto Pib_per_s = bitrate<pebibit_per_second, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::data

src/include/units/physical/si/base/amount_of_substance.h

@@ -22,6 +22,7 @@
 
 #pragma once
 
+#include <units/bits/one_rep.h>
 #include <units/physical/dimensions/amount_of_substance.h>
 #include <units/physical/si/prefixes.h>
 #include <units/quantity.h>
@@ -43,4 +44,10 @@ constexpr auto operator"" _q_mol(long double l) { return amount_of_substance<mol
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto mol = amount_of_substance<mole, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si

src/include/units/physical/si/base/electric_current.h

@@ -22,6 +22,7 @@
 
 #pragma once
 
+#include <units/bits/one_rep.h>
 #include <units/physical/dimensions/electric_current.h>
 #include <units/physical/si/prefixes.h>
 #include <units/quantity.h>
@@ -143,4 +144,30 @@ constexpr auto operator"" _q_YA(long double l) { return electric_current<yottaam
 
 } // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto A = electric_current<ampere, detail::one_rep>{};
+inline constexpr auto yA = electric_current<yoctoampere, detail::one_rep>{};
+inline constexpr auto zA = electric_current<zeptoampere, detail::one_rep>{};
+inline constexpr auto aA = electric_current<attoampere, detail::one_rep>{};
+inline constexpr auto fA = electric_current<femtoampere, detail::one_rep>{};
+inline constexpr auto pA = electric_current<picoampere, detail::one_rep>{};
+inline constexpr auto nA = electric_current<nanoampere, detail::one_rep>{};
+inline constexpr auto uA = electric_current<microampere, detail::one_rep>{};
+inline constexpr auto mA = electric_current<milliampere, detail::one_rep>{};
+inline constexpr auto cA = electric_current<centiampere, detail::one_rep>{};
+inline constexpr auto dA = electric_current<deciampere, detail::one_rep>{};
+inline constexpr auto daA = electric_current<decaampere, detail::one_rep>{};
+inline constexpr auto hA = electric_current<hectoampere, detail::one_rep>{};
+inline constexpr auto kA = electric_current<kiloampere, detail::one_rep>{};
+inline constexpr auto MA = electric_current<megaampere, detail::one_rep>{};
+inline constexpr auto GA = electric_current<gigaampere, detail::one_rep>{};
+inline constexpr auto TA = electric_current<teraampere, detail::one_rep>{};
+inline constexpr auto PA = electric_current<petaampere, detail::one_rep>{};
+inline constexpr auto EA = electric_current<exaampere, detail::one_rep>{};
+inline constexpr auto ZA = electric_current<zettaampere, detail::one_rep>{};
+inline constexpr auto YA = electric_current<yottaampere, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si

src/include/units/physical/si/base/length.h

@@ -22,6 +22,7 @@
 
 #pragma once
 
+#include <units/bits/one_rep.h>
 #include <units/physical/dimensions/length.h>
 #include <units/physical/si/prefixes.h>
 #include <units/quantity.h>
@@ -149,4 +150,31 @@ constexpr auto operator"" _q_au(long double l) { return length<astronomical_unit
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto m = length<metre, detail::one_rep>{};
+inline constexpr auto ym = length<yoctometre, detail::one_rep>{};
+inline constexpr auto zm = length<zeptometre, detail::one_rep>{};
+inline constexpr auto am = length<attometre, detail::one_rep>{};
+inline constexpr auto fm = length<femtometre, detail::one_rep>{};
+inline constexpr auto pm = length<picometre, detail::one_rep>{};
+inline constexpr auto nm = length<nanometre, detail::one_rep>{};
+inline constexpr auto um = length<micrometre, detail::one_rep>{};
+inline constexpr auto mm = length<millimetre, detail::one_rep>{};
+inline constexpr auto cm = length<centimetre, detail::one_rep>{};
+inline constexpr auto dm = length<decimetre, detail::one_rep>{};
+inline constexpr auto dam = length<decametre, detail::one_rep>{};
+inline constexpr auto hm = length<hectometre, detail::one_rep>{};
+inline constexpr auto km = length<kilometre, detail::one_rep>{};
+inline constexpr auto Mm = length<megametre, detail::one_rep>{};
+inline constexpr auto Gm = length<gigametre, detail::one_rep>{};
+inline constexpr auto Tm = length<terametre, detail::one_rep>{};
+inline constexpr auto Pm = length<petametre, detail::one_rep>{};
+inline constexpr auto Em = length<exametre, detail::one_rep>{};
+inline constexpr auto Zm = length<zettametre, detail::one_rep>{};
+inline constexpr auto Ym = length<yottametre, detail::one_rep>{};
+inline constexpr auto au = length<astronomical_unit, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si

src/include/units/physical/si/base/luminous_intensity.h

@@ -22,6 +22,7 @@
 
 #pragma once
 
+#include <units/bits/one_rep.h>
 #include <units/physical/dimensions/luminous_intensity.h>
 #include <units/physical/si/prefixes.h>
 #include <units/quantity.h>
@@ -143,4 +144,30 @@ constexpr auto operator"" _q_Ycd(long double l) { return luminous_intensity<yott
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto cd = luminous_intensity<candela, detail::one_rep>{};
+inline constexpr auto ycd = luminous_intensity<yoctocandela, detail::one_rep>{};
+inline constexpr auto zcd = luminous_intensity<zeptocandela, detail::one_rep>{};
+inline constexpr auto acd = luminous_intensity<attocandela, detail::one_rep>{};
+inline constexpr auto fcd = luminous_intensity<femtocandela, detail::one_rep>{};
+inline constexpr auto pcd = luminous_intensity<picocandela, detail::one_rep>{};
+inline constexpr auto ncd = luminous_intensity<nanocandela, detail::one_rep>{};
+inline constexpr auto ucd = luminous_intensity<microcandela, detail::one_rep>{};
+inline constexpr auto mcd = luminous_intensity<millicandela, detail::one_rep>{};
+inline constexpr auto ccd = luminous_intensity<centicandela, detail::one_rep>{};
+inline constexpr auto dcd = luminous_intensity<decicandela, detail::one_rep>{};
+inline constexpr auto dacd = luminous_intensity<decacandela, detail::one_rep>{};
+inline constexpr auto hcd = luminous_intensity<hectocandela, detail::one_rep>{};
+inline constexpr auto kcd = luminous_intensity<kilocandela, detail::one_rep>{};
+inline constexpr auto Mcd = luminous_intensity<megacandela, detail::one_rep>{};
+inline constexpr auto Gcd = luminous_intensity<gigacandela, detail::one_rep>{};
+inline constexpr auto Tcd = luminous_intensity<teracandela, detail::one_rep>{};
+inline constexpr auto Pcd = luminous_intensity<petacandela, detail::one_rep>{};
+inline constexpr auto Ecd = luminous_intensity<exacandela, detail::one_rep>{};
+inline constexpr auto Zcd = luminous_intensity<zettacandela, detail::one_rep>{};
+inline constexpr auto Ycd = luminous_intensity<yottacandela, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si

src/include/units/physical/si/base/mass.h

@@ -22,6 +22,7 @@
 
 #pragma once
 
+#include <units/bits/one_rep.h>
 #include <units/physical/dimensions/mass.h>
 #include <units/physical/si/prefixes.h>
 #include <units/quantity.h>
@@ -255,4 +256,52 @@ constexpr auto operator"" _q_Da(long double l) { return mass<dalton, long double
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto g = mass<gram, detail::one_rep>{};
+inline constexpr auto yg = mass<yoctogram, detail::one_rep>{};
+inline constexpr auto zg = mass<zeptogram, detail::one_rep>{};
+inline constexpr auto ag = mass<attogram, detail::one_rep>{};
+inline constexpr auto fg = mass<femtogram, detail::one_rep>{};
+inline constexpr auto pg = mass<picogram, detail::one_rep>{};
+inline constexpr auto ng = mass<nanogram, detail::one_rep>{};
+inline constexpr auto ug = mass<microgram, detail::one_rep>{};
+inline constexpr auto mg = mass<milligram, detail::one_rep>{};
+inline constexpr auto cg = mass<centigram, detail::one_rep>{};
+inline constexpr auto dg = mass<decigram, detail::one_rep>{};
+inline constexpr auto dag = mass<decagram, detail::one_rep>{};
+inline constexpr auto hg = mass<hectogram, detail::one_rep>{};
+inline constexpr auto kg = mass<kilogram, detail::one_rep>{};
+inline constexpr auto Mg = mass<megagram, detail::one_rep>{};
+inline constexpr auto Gg = mass<gigagram, detail::one_rep>{};
+inline constexpr auto Tg = mass<teragram, detail::one_rep>{};
+inline constexpr auto Pg = mass<petagram, detail::one_rep>{};
+inline constexpr auto Eg = mass<exagram, detail::one_rep>{};
+inline constexpr auto Zg = mass<zettagram, detail::one_rep>{};
+inline constexpr auto Yg = mass<yottagram, detail::one_rep>{};
+inline constexpr auto t = mass<tonne, detail::one_rep>{};
+inline constexpr auto yt = mass<yoctotonne, detail::one_rep>{};
+inline constexpr auto zt = mass<zeptotonne, detail::one_rep>{};
+inline constexpr auto at = mass<attotonne, detail::one_rep>{};
+inline constexpr auto ft = mass<femtotonne, detail::one_rep>{};
+inline constexpr auto pt = mass<picotonne, detail::one_rep>{};
+inline constexpr auto nt = mass<nanotonne, detail::one_rep>{};
+inline constexpr auto ut = mass<microtonne, detail::one_rep>{};
+inline constexpr auto mt = mass<millitonne, detail::one_rep>{};
+inline constexpr auto ct = mass<centitonne, detail::one_rep>{};
+inline constexpr auto dt = mass<decitonne, detail::one_rep>{};
+inline constexpr auto dat = mass<decatonne, detail::one_rep>{};
+inline constexpr auto ht = mass<hectotonne, detail::one_rep>{};
+inline constexpr auto kt = mass<kilotonne, detail::one_rep>{};
+inline constexpr auto Mt = mass<megatonne, detail::one_rep>{};
+inline constexpr auto Gt = mass<gigatonne, detail::one_rep>{};
+inline constexpr auto Tt = mass<teratonne, detail::one_rep>{};
+inline constexpr auto Pt = mass<petatonne, detail::one_rep>{};
+inline constexpr auto Et = mass<exatonne, detail::one_rep>{};
+inline constexpr auto Zt = mass<zettatonne, detail::one_rep>{};
+inline constexpr auto Yt = mass<yottatonne, detail::one_rep>{};
+inline constexpr auto Da = mass<dalton, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si

src/include/units/physical/si/base/thermodynamic_temperature.h

@@ -22,6 +22,7 @@
 
 #pragma once
 
+#include <units/bits/one_rep.h>
 #include <units/physical/dimensions/thermodynamic_temperature.h>
 #include <units/quantity.h>
 
@@ -42,4 +43,10 @@ constexpr auto operator"" _q_K(long double l) { return thermodynamic_temperature
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto K = thermodynamic_temperature<kelvin, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si

src/include/units/physical/si/base/time.h

@@ -22,6 +22,7 @@
 
 #pragma once
 
+#include <units/bits/one_rep.h>
 #include <units/physical/dimensions/time.h>
 #include <units/physical/si/prefixes.h>
 #include <units/quantity.h>
@@ -98,4 +99,21 @@ constexpr auto operator"" _q_d(long double l) { return time<day, long double>(l)
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto ys = time<yoctosecond, detail::one_rep>{};
+inline constexpr auto zs = time<zeptosecond, detail::one_rep>{};
+inline constexpr auto as = time<attosecond, detail::one_rep>{};
+inline constexpr auto fs = time<femtosecond, detail::one_rep>{};
+inline constexpr auto ps = time<picosecond, detail::one_rep>{};
+inline constexpr auto ns = time<nanosecond, detail::one_rep>{};
+inline constexpr auto us = time<microsecond, detail::one_rep>{};
+inline constexpr auto ms = time<millisecond, detail::one_rep>{};
+inline constexpr auto s = time<second, detail::one_rep>{};
+inline constexpr auto min = time<minute, detail::one_rep>{};
+inline constexpr auto h = time<hour, detail::one_rep>{};
+inline constexpr auto d = time<day, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si

src/include/units/physical/si/cgs/base/length.h

@@ -40,6 +40,12 @@ inline namespace literals {
 constexpr auto operator"" _q_cm(unsigned long long l) { return length<centimetre, std::int64_t>(l); }
 constexpr auto operator"" _q_cm(long double l) { return length<centimetre, long double>(l); }
 
-}
+}  // namespace literals
+
+namespace unit_constants {
+
+inline constexpr auto cm = length<centimetre, detail::one_rep>{};
+
+}  // namespace unit_constants
 
 }  // namespace units::physical::si::cgs

src/include/units/physical/si/cgs/base/mass.h

@@ -40,6 +40,12 @@ inline namespace literals {
 constexpr auto operator"" _q_g(unsigned long long l) { return mass<gram, std::int64_t>(l); }
 constexpr auto operator"" _q_g(long double l) { return mass<gram, long double>(l); }
 
-}
+}  // namespace literals
+
+namespace unit_constants {
+
+inline constexpr auto g = mass<gram, detail::one_rep>{};
+
+}  // namespace unit_constants
 
 }  // namespace units::physical::si::cgs

src/include/units/physical/si/cgs/base/time.h

@@ -36,6 +36,12 @@ inline namespace literals {
 
 using si::literals::operator"" _q_s;
 
-}
+}  // namespace literals
+
+namespace unit_constants {
+
+using si::unit_constants::s;
+
+}  // namespace unit_constants
 
 }  // namespace units::physical::si::cgs

src/include/units/physical/si/cgs/derived/acceleration.h

@@ -42,4 +42,10 @@ constexpr auto operator"" _q_Gal(long double l) { return acceleration<gal, long
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto Gal = acceleration<gal, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si::cgs

src/include/units/physical/si/cgs/derived/area.h

@@ -41,6 +41,12 @@ inline namespace literals {
 constexpr auto operator"" _q_cm2(unsigned long long l) { return area<square_centimetre, std::int64_t>(l); }
 constexpr auto operator"" _q_cm2(long double l) { return area<square_centimetre, long double>(l); }
 
-}
+}  // namespace literals
+
+namespace unit_constants {
+
+inline constexpr auto cm2 = area<square_centimetre, detail::one_rep>{};
+
+}  // namespace unit_constants
 
 }  // namespace units::physical::si::cgs

src/include/units/physical/si/cgs/derived/energy.h

@@ -44,4 +44,10 @@ constexpr auto operator"" _q_erg(long double l) { return energy<erg, long double
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto erg = energy<cgs::erg, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si::cgs

src/include/units/physical/si/cgs/derived/force.h

@@ -45,4 +45,10 @@ constexpr auto operator"" _q_dyn(long double l) { return force<dyne, long double
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto dyn = force<dyne, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si::cgs

src/include/units/physical/si/cgs/derived/power.h

@@ -38,7 +38,7 @@ using power = quantity<dim_power, U, Rep>;
 
 inline namespace literals {
 
-// ergps
+// erg/s
 constexpr auto operator"" _q_erg_per_s(unsigned long long l) { return power<erg_per_second, std::int64_t>(l); }
 constexpr auto operator"" _q_erg_per_s(long double l) { return power<erg_per_second, long double>(l); }
 

src/include/units/physical/si/cgs/derived/pressure.h

@@ -45,4 +45,10 @@ constexpr auto operator"" _q_Ba(long double l) { return pressure<barye, long dou
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto Ba = pressure<barye, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si::cgs

src/include/units/physical/si/cgs/derived/speed.h

@@ -37,7 +37,7 @@ using speed = quantity<dim_speed, U, Rep>;
 
 inline namespace literals {
 
-// cmps
+// cm/s
 constexpr auto operator"" _q_cm_per_s(unsigned long long l) { return speed<centimetre_per_second, std::int64_t>(l); }
 constexpr auto operator"" _q_cm_per_s(long double l) { return speed<centimetre_per_second, long double>(l); }
 

src/include/units/physical/si/derived/absorbed_dose.h

@@ -58,7 +58,7 @@ using absorbed_dose = quantity<dim_absorbed_dose, U, Rep>;
 
 inline namespace literals {
 
-// G
+// Gy
 constexpr auto operator"" _q_Gy(unsigned long long l) { return absorbed_dose<gray, std::int64_t>(l); }
 constexpr auto operator"" _q_Gy(long double l) { return absorbed_dose<gray, long double>(l); }
 
@@ -144,4 +144,30 @@ constexpr auto operator"" _q_YGy(long double l) { return absorbed_dose<yottagray
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto Gy = absorbed_dose<gray, detail::one_rep>{};
+inline constexpr auto yGy = absorbed_dose<yoctogray, detail::one_rep>{};
+inline constexpr auto zGy = absorbed_dose<zeptogray, detail::one_rep>{};
+inline constexpr auto aGy = absorbed_dose<attogray, detail::one_rep>{};
+inline constexpr auto fGy = absorbed_dose<femtogray, detail::one_rep>{};
+inline constexpr auto pGy = absorbed_dose<picogray, detail::one_rep>{};
+inline constexpr auto nGy = absorbed_dose<nanogray, detail::one_rep>{};
+inline constexpr auto uGy = absorbed_dose<microgray, detail::one_rep>{};
+inline constexpr auto mGy = absorbed_dose<milligray, detail::one_rep>{};
+inline constexpr auto cGy = absorbed_dose<centigray, detail::one_rep>{};
+inline constexpr auto dGy = absorbed_dose<decigray, detail::one_rep>{};
+inline constexpr auto daGy = absorbed_dose<decagray, detail::one_rep>{};
+inline constexpr auto hGy = absorbed_dose<hectogray, detail::one_rep>{};
+inline constexpr auto kGy = absorbed_dose<kilogray, detail::one_rep>{};
+inline constexpr auto MGy = absorbed_dose<megagray, detail::one_rep>{};
+inline constexpr auto GGy = absorbed_dose<gigagray, detail::one_rep>{};
+inline constexpr auto TGy = absorbed_dose<teragray, detail::one_rep>{};
+inline constexpr auto PGy = absorbed_dose<petagray, detail::one_rep>{};
+inline constexpr auto EGy = absorbed_dose<exagray, detail::one_rep>{};
+inline constexpr auto ZGy = absorbed_dose<zettagray, detail::one_rep>{};
+inline constexpr auto YGy = absorbed_dose<yottagray, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si

src/include/units/physical/si/derived/acceleration.h

@@ -36,7 +36,7 @@ using acceleration = quantity<dim_acceleration, U, Rep>;
 
 inline namespace literals {
 
-// mps2
+// m/s2
 constexpr auto operator"" _q_m_per_s2(unsigned long long l) { return acceleration<metre_per_second_sq, std::int64_t>(l); }
 constexpr auto operator"" _q_m_per_s2(long double l) { return acceleration<metre_per_second_sq, long double>(l); }
 

src/include/units/physical/si/derived/angular_velocity.h

@@ -43,7 +43,6 @@ inline namespace literals {
 constexpr auto operator"" _q_rad_per_s(unsigned long long l) { return angular_velocity<radian_per_second, std::int64_t>(l); }
 constexpr auto operator"" _q_rad_per_s(long double l) { return angular_velocity<radian_per_second, long double>(l); }
 
-
 }  // namespace literals
 
 }  // namespace units::physical::si

src/include/units/physical/si/derived/area.h

@@ -149,4 +149,31 @@ constexpr auto operator"" _q_ha(long double l) { return area<hectare, long doubl
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto m2 = area<square_metre, detail::one_rep>{};
+inline constexpr auto ym2 = area<square_yoctometre, detail::one_rep>{};
+inline constexpr auto zm2 = area<square_zeptometre, detail::one_rep>{};
+inline constexpr auto am2 = area<square_attometre, detail::one_rep>{};
+inline constexpr auto fm2 = area<square_femtometre, detail::one_rep>{};
+inline constexpr auto pm2 = area<square_picometre, detail::one_rep>{};
+inline constexpr auto nm2 = area<square_nanometre, detail::one_rep>{};
+inline constexpr auto um2 = area<square_micrometre, detail::one_rep>{};
+inline constexpr auto mm2 = area<square_millimetre, detail::one_rep>{};
+inline constexpr auto cm2 = area<square_centimetre, detail::one_rep>{};
+inline constexpr auto dm2 = area<square_decimetre, detail::one_rep>{};
+inline constexpr auto dam2 = area<square_decametre, detail::one_rep>{};
+inline constexpr auto hm2 = area<square_hectometre, detail::one_rep>{};
+inline constexpr auto km2 = area<square_kilometre, detail::one_rep>{};
+inline constexpr auto Mm2 = area<square_megametre, detail::one_rep>{};
+inline constexpr auto Gm2 = area<square_gigametre, detail::one_rep>{};
+inline constexpr auto Tm2 = area<square_terametre, detail::one_rep>{};
+inline constexpr auto Pm2 = area<square_petametre, detail::one_rep>{};
+inline constexpr auto Em2 = area<square_exametre, detail::one_rep>{};
+inline constexpr auto Zm2 = area<square_zettametre, detail::one_rep>{};
+inline constexpr auto Ym2 = area<square_yottametre, detail::one_rep>{};
+inline constexpr auto ha = area<hectare, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si

src/include/units/physical/si/derived/capacitance.h

@@ -145,4 +145,30 @@ constexpr auto operator"" _q_YF(long double l) { return capacitance<yottafarad,
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto F = capacitance<farad, detail::one_rep>{};
+inline constexpr auto yF = capacitance<yoctofarad, detail::one_rep>{};
+inline constexpr auto zF = capacitance<zeptofarad, detail::one_rep>{};
+inline constexpr auto aF = capacitance<attofarad, detail::one_rep>{};
+inline constexpr auto fF = capacitance<femtofarad, detail::one_rep>{};
+inline constexpr auto pF = capacitance<picofarad, detail::one_rep>{};
+inline constexpr auto nF = capacitance<nanofarad, detail::one_rep>{};
+inline constexpr auto uF = capacitance<microfarad, detail::one_rep>{};
+inline constexpr auto mF = capacitance<millifarad, detail::one_rep>{};
+inline constexpr auto cF = capacitance<centifarad, detail::one_rep>{};
+inline constexpr auto dF = capacitance<decifarad, detail::one_rep>{};
+inline constexpr auto daF = capacitance<decafarad, detail::one_rep>{};
+inline constexpr auto hF = capacitance<hectofarad, detail::one_rep>{};
+inline constexpr auto kF = capacitance<kilofarad, detail::one_rep>{};
+inline constexpr auto MF = capacitance<megafarad, detail::one_rep>{};
+inline constexpr auto GF = capacitance<gigafarad, detail::one_rep>{};
+inline constexpr auto TF = capacitance<terafarad, detail::one_rep>{};
+inline constexpr auto PF = capacitance<petafarad, detail::one_rep>{};
+inline constexpr auto EF = capacitance<exafarad, detail::one_rep>{};
+inline constexpr auto ZF = capacitance<zettafarad, detail::one_rep>{};
+inline constexpr auto YF = capacitance<yottafarad, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si

src/include/units/physical/si/derived/catalytic_activity.h

@@ -151,5 +151,32 @@ constexpr auto operator"" _q_U(long double l) { return catalytic_activity<enzyme
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto kat = catalytic_activity<katal, detail::one_rep>{};
+inline constexpr auto ykat = catalytic_activity<yoctokatal, detail::one_rep>{};
+inline constexpr auto zkat = catalytic_activity<zeptokatal, detail::one_rep>{};
+inline constexpr auto akat = catalytic_activity<attokatal, detail::one_rep>{};
+inline constexpr auto fkat = catalytic_activity<femtokatal, detail::one_rep>{};
+inline constexpr auto pkat = catalytic_activity<picokatal, detail::one_rep>{};
+inline constexpr auto nkat = catalytic_activity<nanokatal, detail::one_rep>{};
+inline constexpr auto ukat = catalytic_activity<microkatal, detail::one_rep>{};
+inline constexpr auto mkat = catalytic_activity<millikatal, detail::one_rep>{};
+inline constexpr auto ckat = catalytic_activity<centikatal, detail::one_rep>{};
+inline constexpr auto dkat = catalytic_activity<decikatal, detail::one_rep>{};
+inline constexpr auto dakat = catalytic_activity<decakatal, detail::one_rep>{};
+inline constexpr auto hkat = catalytic_activity<hectokatal, detail::one_rep>{};
+inline constexpr auto kkat = catalytic_activity<kilokatal, detail::one_rep>{};
+inline constexpr auto Mkat = catalytic_activity<megakatal, detail::one_rep>{};
+inline constexpr auto Gkat = catalytic_activity<gigakatal, detail::one_rep>{};
+inline constexpr auto Tkat = catalytic_activity<terakatal, detail::one_rep>{};
+inline constexpr auto Pkat = catalytic_activity<petakatal, detail::one_rep>{};
+inline constexpr auto Ekat = catalytic_activity<exakatal, detail::one_rep>{};
+inline constexpr auto Zkat = catalytic_activity<zettakatal, detail::one_rep>{};
+inline constexpr auto Ykat = catalytic_activity<yottakatal, detail::one_rep>{};
+inline constexpr auto U = catalytic_activity<enzyme_unit, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si
 

src/include/units/physical/si/derived/conductance.h

@@ -124,5 +124,27 @@ constexpr auto operator"" _q_YS(long double l) { return conductance<yottasiemens
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto S = conductance<siemens, detail::one_rep>{};
+inline constexpr auto yS = conductance<yoctosiemens, detail::one_rep>{};
+inline constexpr auto zS = conductance<zeptosiemens, detail::one_rep>{};
+inline constexpr auto aS = conductance<attosiemens, detail::one_rep>{};
+inline constexpr auto fS = conductance<femtosiemens, detail::one_rep>{};
+inline constexpr auto pS = conductance<picosiemens, detail::one_rep>{};
+inline constexpr auto nS = conductance<nanosiemens, detail::one_rep>{};
+inline constexpr auto uS = conductance<microsiemens, detail::one_rep>{};
+inline constexpr auto mS = conductance<millisiemens, detail::one_rep>{};
+inline constexpr auto kS = conductance<kilosiemens, detail::one_rep>{};
+inline constexpr auto MS = conductance<megasiemens, detail::one_rep>{};
+inline constexpr auto GS = conductance<gigasiemens, detail::one_rep>{};
+inline constexpr auto TS = conductance<terasiemens, detail::one_rep>{};
+inline constexpr auto PS = conductance<petasiemens, detail::one_rep>{};
+inline constexpr auto ES = conductance<exasiemens, detail::one_rep>{};
+inline constexpr auto ZS = conductance<zettasiemens, detail::one_rep>{};
+inline constexpr auto YS = conductance<yottasiemens, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si
 

src/include/units/physical/si/derived/current_density.h

@@ -39,6 +39,7 @@ using current_density = quantity<dim_current_density, U, Rep>;
 
 inline namespace literals {
 
+// A / m²
 constexpr auto operator"" _q_A_per_m2(unsigned long long l) { return current_density<ampere_per_metre_sq, std::int64_t>(l); }
 constexpr auto operator"" _q_A_per_m2(long double l) { return current_density<ampere_per_metre_sq, long double>(l); }
 

src/include/units/physical/si/derived/density.h

@@ -39,6 +39,7 @@ using density = quantity<dim_density, U, Rep>;
 
 inline namespace literals {
 
+// kg / m³
 constexpr auto operator"" _q_kg_per_m3(unsigned long long l) { return density<kilogram_per_metre_cub, std::int64_t>(l); }
 constexpr auto operator"" _q_kg_per_m3(long double l) { return density<kilogram_per_metre_cub, long double>(l); }
 

src/include/units/physical/si/derived/dynamic_viscosity.h

@@ -43,5 +43,11 @@ constexpr auto operator"" _q_Pa_s(long double l) { return dynamic_viscosity<pasc
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto Pa_s = dynamic_viscosity<pascal_second, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si
 

src/include/units/physical/si/derived/electric_charge.h

@@ -44,4 +44,10 @@ constexpr auto operator"" _q_C(long double l) { return electric_charge<coulomb,
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto C = electric_charge<coulomb, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si

src/include/units/physical/si/derived/energy.h

@@ -135,4 +135,28 @@ constexpr auto operator"" _q_GeV(long double l) { return energy<gigaelectronvolt
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto J = energy<joule, detail::one_rep>{};
+inline constexpr auto yJ = energy<yoctojoule, detail::one_rep>{};
+inline constexpr auto zJ = energy<zeptojoule, detail::one_rep>{};
+inline constexpr auto aJ = energy<attojoule, detail::one_rep>{};
+inline constexpr auto fJ = energy<femtojoule, detail::one_rep>{};
+inline constexpr auto pJ = energy<picojoule, detail::one_rep>{};
+inline constexpr auto nJ = energy<nanojoule, detail::one_rep>{};
+inline constexpr auto uJ = energy<microjoule, detail::one_rep>{};
+inline constexpr auto mJ = energy<millijoule, detail::one_rep>{};
+inline constexpr auto kJ = energy<kilojoule, detail::one_rep>{};
+inline constexpr auto MJ = energy<megajoule, detail::one_rep>{};
+inline constexpr auto GJ = energy<gigajoule, detail::one_rep>{};
+inline constexpr auto TJ = energy<terajoule, detail::one_rep>{};
+inline constexpr auto PJ = energy<petajoule, detail::one_rep>{};
+inline constexpr auto EJ = energy<exajoule, detail::one_rep>{};
+inline constexpr auto ZJ = energy<zettajoule, detail::one_rep>{};
+inline constexpr auto YJ = energy<yottajoule, detail::one_rep>{};
+inline constexpr auto eV = energy<electronvolt, detail::one_rep>{};
+inline constexpr auto GeV = energy<gigaelectronvolt, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si

src/include/units/physical/si/derived/force.h

@@ -145,4 +145,30 @@ constexpr auto operator"" _q_YN(long double l) { return force<yottanewton, long
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto N = force<newton, detail::one_rep>{};
+inline constexpr auto yN = force<yoctonewton, detail::one_rep>{};
+inline constexpr auto zN = force<zeptonewton, detail::one_rep>{};
+inline constexpr auto aN = force<attonewton, detail::one_rep>{};
+inline constexpr auto fN = force<femtonewton, detail::one_rep>{};
+inline constexpr auto pN = force<piconewton, detail::one_rep>{};
+inline constexpr auto nN = force<nanonewton, detail::one_rep>{};
+inline constexpr auto uN = force<micronewton, detail::one_rep>{};
+inline constexpr auto mN = force<millinewton, detail::one_rep>{};
+inline constexpr auto cN = force<centinewton, detail::one_rep>{};
+inline constexpr auto dN = force<decinewton, detail::one_rep>{};
+inline constexpr auto daN = force<decanewton, detail::one_rep>{};
+inline constexpr auto hN = force<hectonewton, detail::one_rep>{};
+inline constexpr auto kN = force<kilonewton, detail::one_rep>{};
+inline constexpr auto MN = force<meganewton, detail::one_rep>{};
+inline constexpr auto GN = force<giganewton, detail::one_rep>{};
+inline constexpr auto TN = force<teranewton, detail::one_rep>{};
+inline constexpr auto PN = force<petanewton, detail::one_rep>{};
+inline constexpr auto EN = force<exanewton, detail::one_rep>{};
+inline constexpr auto ZN = force<zettanewton, detail::one_rep>{};
+inline constexpr auto YN = force<yottanewton, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si

src/include/units/physical/si/derived/frequency.h

@@ -123,4 +123,26 @@ constexpr auto operator"" _q_YHz(long double l) { return frequency<yottahertz, l
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto Hz = frequency<hertz, detail::one_rep>{};
+inline constexpr auto yHz = frequency<yoctohertz, detail::one_rep>{};
+inline constexpr auto zHz = frequency<zeptohertz, detail::one_rep>{};
+inline constexpr auto aHz = frequency<attohertz, detail::one_rep>{};
+inline constexpr auto fHz = frequency<femtohertz, detail::one_rep>{};
+inline constexpr auto pHz = frequency<picohertz, detail::one_rep>{};
+inline constexpr auto nHz = frequency<nanohertz, detail::one_rep>{};
+inline constexpr auto uHz = frequency<microhertz, detail::one_rep>{};
+inline constexpr auto mHz = frequency<millihertz, detail::one_rep>{};
+inline constexpr auto kHz = frequency<kilohertz, detail::one_rep>{};
+inline constexpr auto MHz = frequency<megahertz, detail::one_rep>{};
+inline constexpr auto GHz = frequency<gigahertz, detail::one_rep>{};
+inline constexpr auto THz = frequency<terahertz, detail::one_rep>{};
+inline constexpr auto PHz = frequency<petahertz, detail::one_rep>{};
+inline constexpr auto EHz = frequency<exahertz, detail::one_rep>{};
+inline constexpr auto ZHz = frequency<zettahertz, detail::one_rep>{};
+inline constexpr auto YHz = frequency<yottahertz, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si

src/include/units/physical/si/derived/inductance.h

@@ -125,4 +125,26 @@ constexpr auto operator"" _q_YH(long double l) { return inductance<yottahenry, l
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto H = inductance<henry, detail::one_rep>{};
+inline constexpr auto yH = inductance<yoctohenry, detail::one_rep>{};
+inline constexpr auto zH = inductance<zeptohenry, detail::one_rep>{};
+inline constexpr auto aH = inductance<attohenry, detail::one_rep>{};
+inline constexpr auto fH = inductance<femtohenry, detail::one_rep>{};
+inline constexpr auto pH = inductance<picohenry, detail::one_rep>{};
+inline constexpr auto nH = inductance<nanohenry, detail::one_rep>{};
+inline constexpr auto uH = inductance<microhenry, detail::one_rep>{};
+inline constexpr auto mH = inductance<millihenry, detail::one_rep>{};
+inline constexpr auto kH = inductance<kilohenry, detail::one_rep>{};
+inline constexpr auto MH = inductance<megahenry, detail::one_rep>{};
+inline constexpr auto GH = inductance<gigahenry, detail::one_rep>{};
+inline constexpr auto TH = inductance<terahenry, detail::one_rep>{};
+inline constexpr auto PH = inductance<petahenry, detail::one_rep>{};
+inline constexpr auto EH = inductance<exahenry, detail::one_rep>{};
+inline constexpr auto ZH = inductance<zettahenry, detail::one_rep>{};
+inline constexpr auto YH = inductance<yottahenry, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si

src/include/units/physical/si/derived/magnetic_flux.h

@@ -125,4 +125,26 @@ constexpr auto operator"" _q_YWb(long double l) { return magnetic_flux<yottawebe
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto Wb = magnetic_flux<weber, detail::one_rep>{};
+inline constexpr auto yWb = magnetic_flux<yoctoweber, detail::one_rep>{};
+inline constexpr auto zWb = magnetic_flux<zeptoweber, detail::one_rep>{};
+inline constexpr auto aWb = magnetic_flux<attoweber, detail::one_rep>{};
+inline constexpr auto fWb = magnetic_flux<femtoweber, detail::one_rep>{};
+inline constexpr auto pWb = magnetic_flux<picoweber, detail::one_rep>{};
+inline constexpr auto nWb = magnetic_flux<nanoweber, detail::one_rep>{};
+inline constexpr auto uWb = magnetic_flux<microweber, detail::one_rep>{};
+inline constexpr auto mWb = magnetic_flux<milliweber, detail::one_rep>{};
+inline constexpr auto kWb = magnetic_flux<kiloweber, detail::one_rep>{};
+inline constexpr auto MWb = magnetic_flux<megaweber, detail::one_rep>{};
+inline constexpr auto GWb = magnetic_flux<gigaweber, detail::one_rep>{};
+inline constexpr auto TWb = magnetic_flux<teraweber, detail::one_rep>{};
+inline constexpr auto PWb = magnetic_flux<petaweber, detail::one_rep>{};
+inline constexpr auto EWb = magnetic_flux<exaweber, detail::one_rep>{};
+inline constexpr auto ZWb = magnetic_flux<zettaweber, detail::one_rep>{};
+inline constexpr auto YWb = magnetic_flux<yottaweber, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si

src/include/units/physical/si/derived/magnetic_induction.h

@@ -133,4 +133,27 @@ constexpr auto operator"" _q_G(long double l) { return magnetic_induction<gauss,
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto T = magnetic_induction<tesla, detail::one_rep>{};
+inline constexpr auto yT = magnetic_induction<yoctotesla, detail::one_rep>{};
+inline constexpr auto zT = magnetic_induction<zeptotesla, detail::one_rep>{};
+inline constexpr auto aT = magnetic_induction<attotesla, detail::one_rep>{};
+inline constexpr auto fT = magnetic_induction<femtotesla, detail::one_rep>{};
+inline constexpr auto pT = magnetic_induction<picotesla, detail::one_rep>{};
+inline constexpr auto nT = magnetic_induction<nanotesla, detail::one_rep>{};
+inline constexpr auto uT = magnetic_induction<microtesla, detail::one_rep>{};
+inline constexpr auto mT = magnetic_induction<millitesla, detail::one_rep>{};
+inline constexpr auto kT = magnetic_induction<kilotesla, detail::one_rep>{};
+inline constexpr auto MT = magnetic_induction<megatesla, detail::one_rep>{};
+inline constexpr auto GT = magnetic_induction<gigatesla, detail::one_rep>{};
+inline constexpr auto TT = magnetic_induction<teratesla, detail::one_rep>{};
+inline constexpr auto PT = magnetic_induction<petatesla, detail::one_rep>{};
+inline constexpr auto ET = magnetic_induction<exatesla, detail::one_rep>{};
+inline constexpr auto ZT = magnetic_induction<zettatesla, detail::one_rep>{};
+inline constexpr auto YT = magnetic_induction<yottatesla, detail::one_rep>{};
+inline constexpr auto G = magnetic_induction<gauss, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 } // namespace units

src/include/units/physical/si/derived/molar_energy.h

@@ -39,7 +39,7 @@ using molar_energy = quantity<dim_molar_energy, U, Rep>;
 
 inline namespace literals {
 
-// H/m
+// J/mol
 constexpr auto operator"" _q_J_per_mol(unsigned long long l) { return molar_energy<joule_per_mole, std::int64_t>(l); }
 constexpr auto operator"" _q_J_per_mol(long double l) { return molar_energy<joule_per_mole, long double>(l); }
 

src/include/units/physical/si/derived/momentum.h

@@ -37,7 +37,7 @@ using momentum = quantity<dim_momentum, U, Rep>;
 
 inline namespace literals {
 
-// kgmps
+// kg*m/s
 constexpr auto operator"" _q_kg_m_per_s(unsigned long long l) { return momentum<kilogram_metre_per_second, std::int64_t>(l); }
 constexpr auto operator"" _q_kg_m_per_s(long double l) { return momentum<kilogram_metre_per_second, long double>(l); }
 

src/include/units/physical/si/derived/power.h

@@ -124,4 +124,26 @@ constexpr auto operator"" _q_YW(long double l) { return power<yottawatt, long do
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto W = power<watt, detail::one_rep>{};
+inline constexpr auto yW = power<yoctowatt, detail::one_rep>{};
+inline constexpr auto zW = power<zeptowatt, detail::one_rep>{};
+inline constexpr auto aW = power<attowatt, detail::one_rep>{};
+inline constexpr auto fW = power<femtowatt, detail::one_rep>{};
+inline constexpr auto pW = power<picowatt, detail::one_rep>{};
+inline constexpr auto nW = power<nanowatt, detail::one_rep>{};
+inline constexpr auto uW = power<microwatt, detail::one_rep>{};
+inline constexpr auto mW = power<milliwatt, detail::one_rep>{};
+inline constexpr auto kW = power<kilowatt, detail::one_rep>{};
+inline constexpr auto MW = power<megawatt, detail::one_rep>{};
+inline constexpr auto GW = power<gigawatt, detail::one_rep>{};
+inline constexpr auto TW = power<terawatt, detail::one_rep>{};
+inline constexpr auto PW = power<petawatt, detail::one_rep>{};
+inline constexpr auto EW = power<exawatt, detail::one_rep>{};
+inline constexpr auto ZW = power<zettawatt, detail::one_rep>{};
+inline constexpr auto YW = power<yottawatt, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si

src/include/units/physical/si/derived/pressure.h

@@ -145,4 +145,30 @@ constexpr auto operator"" _q_YPa(long double l) { return pressure<yottapascal, l
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto Pa = pressure<pascal, detail::one_rep>{};
+inline constexpr auto yPa = pressure<yoctopascal, detail::one_rep>{};
+inline constexpr auto zPa = pressure<zeptopascal, detail::one_rep>{};
+inline constexpr auto aPa = pressure<attopascal, detail::one_rep>{};
+inline constexpr auto fPa = pressure<femtopascal, detail::one_rep>{};
+inline constexpr auto pPa = pressure<picopascal, detail::one_rep>{};
+inline constexpr auto nPa = pressure<nanopascal, detail::one_rep>{};
+inline constexpr auto uPa = pressure<micropascal, detail::one_rep>{};
+inline constexpr auto mPa = pressure<millipascal, detail::one_rep>{};
+inline constexpr auto cPa = pressure<centipascal, detail::one_rep>{};
+inline constexpr auto dPa = pressure<decipascal, detail::one_rep>{};
+inline constexpr auto daPa = pressure<decapascal, detail::one_rep>{};
+inline constexpr auto hPa = pressure<hectopascal, detail::one_rep>{};
+inline constexpr auto kPa = pressure<kilopascal, detail::one_rep>{};
+inline constexpr auto MPa = pressure<megapascal, detail::one_rep>{};
+inline constexpr auto GPa = pressure<gigapascal, detail::one_rep>{};
+inline constexpr auto TPa = pressure<terapascal, detail::one_rep>{};
+inline constexpr auto PPa = pressure<petapascal, detail::one_rep>{};
+inline constexpr auto EPa = pressure<exapascal, detail::one_rep>{};
+inline constexpr auto ZPa = pressure<zettapascal, detail::one_rep>{};
+inline constexpr auto YPa = pressure<yottapascal, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si

src/include/units/physical/si/derived/resistance.h

@@ -125,4 +125,26 @@ constexpr auto operator"" _q_YR(long double l) { return resistance<yottaohm, lon
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto R = resistance<ohm, detail::one_rep>{};
+inline constexpr auto yR = resistance<yoctoohm, detail::one_rep>{};
+inline constexpr auto zR = resistance<zeptoohm, detail::one_rep>{};
+inline constexpr auto aR = resistance<attoohm, detail::one_rep>{};
+inline constexpr auto fR = resistance<femtoohm, detail::one_rep>{};
+inline constexpr auto pR = resistance<picoohm, detail::one_rep>{};
+inline constexpr auto nR = resistance<nanoohm, detail::one_rep>{};
+inline constexpr auto uR = resistance<microohm, detail::one_rep>{};
+inline constexpr auto mR = resistance<milliohm, detail::one_rep>{};
+inline constexpr auto kR = resistance<kiloohm, detail::one_rep>{};
+inline constexpr auto MR = resistance<megaohm, detail::one_rep>{};
+inline constexpr auto GR = resistance<gigaohm, detail::one_rep>{};
+inline constexpr auto TR = resistance<teraohm, detail::one_rep>{};
+inline constexpr auto PR = resistance<petaohm, detail::one_rep>{};
+inline constexpr auto ER = resistance<exaohm, detail::one_rep>{};
+inline constexpr auto ZR = resistance<zettaohm, detail::one_rep>{};
+inline constexpr auto YR = resistance<yottaohm, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si

src/include/units/physical/si/derived/speed.h

@@ -39,11 +39,11 @@ using speed = quantity<dim_speed, U, Rep>;
 
 inline namespace literals {
 
-// mps
+// m/s
 constexpr auto operator"" _q_m_per_s(unsigned long long l) { return speed<metre_per_second, std::int64_t>(l); }
 constexpr auto operator"" _q_m_per_s(long double l) { return speed<metre_per_second, long double>(l); }
 
-// kmph
+// km/h
 constexpr auto operator"" _q_km_per_h(unsigned long long l) { return speed<kilometre_per_hour, std::int64_t>(l); }
 constexpr auto operator"" _q_km_per_h(long double l) { return speed<kilometre_per_hour, long double>(l); }
 

src/include/units/physical/si/derived/surface_tension.h

@@ -37,9 +37,9 @@ using surface_tension = quantity<dim_surface_tension, U, Rep>;
 
 inline namespace literals {
 
-  // Nm
-  constexpr auto operator"" _q_N_per_m(unsigned long long l) { return surface_tension<newton_per_metre, std::int64_t>(l); }
-  constexpr auto operator"" _q_N_per_m(long double l) { return surface_tension<newton_per_metre, long double>(l); }
+// N/m
+constexpr auto operator"" _q_N_per_m(unsigned long long l) { return surface_tension<newton_per_metre, std::int64_t>(l); }
+constexpr auto operator"" _q_N_per_m(long double l) { return surface_tension<newton_per_metre, long double>(l); }
 
 }  // namespace literals
 

src/include/units/physical/si/derived/thermal_conductivity.h

@@ -38,7 +38,7 @@ using thermal_conductivity = quantity<dim_thermal_conductivity, U, Rep>;
 
 inline namespace literals {
 
-// J/K
+// W/(m K)
 constexpr auto operator"" _q_W_per_m_K(unsigned long long l) { return thermal_conductivity<watt_per_metre_kelvin, std::int64_t>(l); }
 constexpr auto operator"" _q_W_per_m_K(long double l) { return thermal_conductivity<watt_per_metre_kelvin, long double>(l); }
 

src/include/units/physical/si/derived/torque.h

@@ -45,4 +45,10 @@ constexpr auto operator"" _q_Nm(long double l) { return torque<newton_metre, lon
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto Nm = torque<newton_metre, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si

src/include/units/physical/si/derived/voltage.h

@@ -145,4 +145,30 @@ constexpr auto operator"" _q_YV(long double l) { return voltage<yottavolt, long
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto V = voltage<volt, detail::one_rep>{};
+inline constexpr auto yV = voltage<yoctovolt, detail::one_rep>{};
+inline constexpr auto zV = voltage<zeptovolt, detail::one_rep>{};
+inline constexpr auto aV = voltage<attovolt, detail::one_rep>{};
+inline constexpr auto fV = voltage<femtovolt, detail::one_rep>{};
+inline constexpr auto pV = voltage<picovolt, detail::one_rep>{};
+inline constexpr auto nV = voltage<nanovolt, detail::one_rep>{};
+inline constexpr auto uV = voltage<microvolt, detail::one_rep>{};
+inline constexpr auto mV = voltage<millivolt, detail::one_rep>{};
+inline constexpr auto cV = voltage<centivolt, detail::one_rep>{};
+inline constexpr auto dV = voltage<decivolt, detail::one_rep>{};
+inline constexpr auto daV = voltage<decavolt, detail::one_rep>{};
+inline constexpr auto hV = voltage<hectovolt, detail::one_rep>{};
+inline constexpr auto kV = voltage<kilovolt, detail::one_rep>{};
+inline constexpr auto MV = voltage<megavolt, detail::one_rep>{};
+inline constexpr auto GV = voltage<gigavolt, detail::one_rep>{};
+inline constexpr auto TV = voltage<teravolt, detail::one_rep>{};
+inline constexpr auto PV = voltage<petavolt, detail::one_rep>{};
+inline constexpr auto EV = voltage<exavolt, detail::one_rep>{};
+inline constexpr auto ZV = voltage<zettavolt, detail::one_rep>{};
+inline constexpr auto YV = voltage<yottavolt, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si

src/include/units/physical/si/derived/volume.h

@@ -249,4 +249,51 @@ constexpr auto operator"" _q_Yl(long double l) { return volume<yottalitre, long
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto m3 = volume<cubic_metre, detail::one_rep>{};
+inline constexpr auto ym3 = volume<cubic_yoctometre, detail::one_rep>{};
+inline constexpr auto zm3 = volume<cubic_zeptometre, detail::one_rep>{};
+inline constexpr auto am3 = volume<cubic_attometre, detail::one_rep>{};
+inline constexpr auto fm3 = volume<cubic_femtometre, detail::one_rep>{};
+inline constexpr auto pm3 = volume<cubic_picometre, detail::one_rep>{};
+inline constexpr auto nm3 = volume<cubic_nanometre, detail::one_rep>{};
+inline constexpr auto um3 = volume<cubic_micrometre, detail::one_rep>{};
+inline constexpr auto mm3 = volume<cubic_millimetre, detail::one_rep>{};
+inline constexpr auto cm3 = volume<cubic_centimetre, detail::one_rep>{};
+inline constexpr auto dm3 = volume<cubic_decimetre, detail::one_rep>{};
+inline constexpr auto dam3 = volume<cubic_decametre, detail::one_rep>{};
+inline constexpr auto hm3 = volume<cubic_hectometre, detail::one_rep>{};
+inline constexpr auto km3 = volume<cubic_kilometre, detail::one_rep>{};
+inline constexpr auto Mm3 = volume<cubic_megametre, detail::one_rep>{};
+inline constexpr auto Gm3 = volume<cubic_gigametre, detail::one_rep>{};
+inline constexpr auto Tm3 = volume<cubic_terametre, detail::one_rep>{};
+inline constexpr auto Pm3 = volume<cubic_petametre, detail::one_rep>{};
+inline constexpr auto Em3 = volume<cubic_exametre, detail::one_rep>{};
+inline constexpr auto Zm3 = volume<cubic_zettametre, detail::one_rep>{};
+inline constexpr auto Ym3 = volume<cubic_yottametre, detail::one_rep>{};
+inline constexpr auto l = volume<litre, detail::one_rep>{};
+inline constexpr auto yl = volume<yoctolitre, detail::one_rep>{};
+inline constexpr auto zl = volume<zeptolitre, detail::one_rep>{};
+inline constexpr auto al = volume<attolitre, detail::one_rep>{};
+inline constexpr auto fl = volume<femtolitre, detail::one_rep>{};
+inline constexpr auto pl = volume<picolitre, detail::one_rep>{};
+inline constexpr auto nl = volume<nanolitre, detail::one_rep>{};
+inline constexpr auto ul = volume<microlitre, detail::one_rep>{};
+inline constexpr auto ml = volume<millilitre, detail::one_rep>{};
+inline constexpr auto cl = volume<centilitre, detail::one_rep>{};
+inline constexpr auto dl = volume<decilitre, detail::one_rep>{};
+inline constexpr auto dal = volume<decalitre, detail::one_rep>{};
+inline constexpr auto hl = volume<hectolitre, detail::one_rep>{};
+inline constexpr auto kl = volume<kilolitre, detail::one_rep>{};
+inline constexpr auto Ml = volume<megalitre, detail::one_rep>{};
+inline constexpr auto Gl = volume<gigalitre, detail::one_rep>{};
+inline constexpr auto Tl = volume<teralitre, detail::one_rep>{};
+inline constexpr auto Pl = volume<petalitre, detail::one_rep>{};
+inline constexpr auto El = volume<exalitre, detail::one_rep>{};
+inline constexpr auto Zl = volume<zettalitre, detail::one_rep>{};
+inline constexpr auto Yl = volume<yottalitre, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si

src/include/units/physical/si/fps/base/length.h

@@ -91,7 +91,21 @@ constexpr auto operator"" _q_mile(long double l) { return length<mile, long doub
 constexpr auto operator"" _q_naut_mi(unsigned long long l) { return length<nautical_mile, std::int64_t>(l); }
 constexpr auto operator"" _q_naut_mi(long double l) { return length<nautical_mile, long double>(l); }
 
+}  // namespace literals
 
-}
+namespace unit_constants {
+
+inline constexpr auto thou = length<thousandth, detail::one_rep>{};
+inline constexpr auto mil = thou;
+
+inline constexpr auto in = length<inch, detail::one_rep>{};
+inline constexpr auto ft = length<foot, detail::one_rep>{};
+inline constexpr auto yd = length<yard, detail::one_rep>{};
+inline constexpr auto ftm = length<fathom, detail::one_rep>{};
+inline constexpr auto kyd = length<kiloyard, detail::one_rep>{};
+inline constexpr auto mile = length<fps::mile, detail::one_rep>{};
+inline constexpr auto naut_mi = length<nautical_mile, detail::one_rep>{};
+
+}  // namespace unit_constants
 
 }  // namespace units::physical::si::fps

src/include/units/physical/si/fps/base/mass.h

@@ -89,7 +89,20 @@ constexpr auto operator"" _q_ston(long double l) { return mass<short_ton, long d
 constexpr auto operator"" _q_lton(unsigned long long l) { return mass<long_ton, std::int64_t>(l); }
 constexpr auto operator"" _q_lton(long double l) { return mass<long_ton, long double>(l); }
 
+}  // namespace literals
 
-}
+namespace unit_constants {
+
+inline constexpr auto gr = mass<grain, detail::one_rep>{};
+inline constexpr auto dr = mass<dram, detail::one_rep>{};
+inline constexpr auto oz = mass<ounce, detail::one_rep>{};
+inline constexpr auto lb = mass<pound, detail::one_rep>{};
+inline constexpr auto st = mass<stone, detail::one_rep>{};
+inline constexpr auto qr = mass<quarter, detail::one_rep>{};
+inline constexpr auto cwt = mass<hundredweight, detail::one_rep>{};
+inline constexpr auto ston = mass<short_ton, detail::one_rep>{};
+inline constexpr auto lton = mass<long_ton, detail::one_rep>{};
+
+}  // namespace unit_constants
 
 }  // namespace units::physical::si::fps

src/include/units/physical/si/fps/base/time.h

@@ -38,6 +38,12 @@ inline namespace literals {
 
 using si::literals::operator"" _q_s;
 
-}
+}  // namespace literals
+
+namespace unit_constants {
+
+using si::unit_constants::s;
+
+}  // namespace unit_constants
 
 }  // namespace units::physical::si::fps

src/include/units/physical/si/fps/derived/acceleration.h

@@ -36,7 +36,7 @@ using acceleration = quantity<dim_acceleration, U, Rep>;
 
 inline namespace literals {
 
-// ft_per_s2
+// ft/s2
 constexpr auto operator"" _q_ft_per_s2(unsigned long long l) { return acceleration<foot_per_second_sq, std::int64_t>(l); }
 constexpr auto operator"" _q_ft_per_s2(long double l) { return acceleration<foot_per_second_sq, long double>(l); }
 

src/include/units/physical/si/fps/derived/area.h

@@ -41,6 +41,12 @@ inline namespace literals {
 constexpr auto operator"" _q_ft2(unsigned long long l) { return area<square_foot, std::int64_t>(l); }
 constexpr auto operator"" _q_ft2(long double l) { return area<square_foot, long double>(l); }
 
-}
+}  // namespace literals
+
+namespace unit_constants {
+
+inline constexpr auto ft2 = area<square_foot, detail::one_rep>{};
+
+}  // namespace unit_constants
 
 }  // namespace units::physical::si::fps

src/include/units/physical/si/fps/derived/density.h

@@ -38,6 +38,7 @@ using density = quantity<dim_density, U, Rep>;
 
 inline namespace literals {
 
+// lb/ft³
 constexpr auto operator"" _q_lb_per_ft3(unsigned long long l) { return density<pound_per_foot_cub, std::int64_t>(l); }
 constexpr auto operator"" _q_lb_per_ft3(long double l) { return density<pound_per_foot_cub, long double>(l); }
 

src/include/units/physical/si/fps/derived/energy.h

@@ -45,6 +45,7 @@ using energy = quantity<dim_energy, U, Rep>;
 
 inline namespace literals {
 
+// foot poundal
 constexpr auto operator"" _q_ft_pdl(unsigned long long l) { return energy<foot_poundal, std::int64_t>(l); }
 constexpr auto operator"" _q_ft_pdl(long double l) { return energy<foot_poundal, long double>(l); }
 
@@ -54,4 +55,11 @@ constexpr auto operator"" _q_ft_lbf(long double l) { return energy<foot_pound_fo
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto ft_pdl = energy<foot_poundal, detail::one_rep>{};
+inline constexpr auto ft_lbf = energy<foot_pound_force, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si::fps

src/include/units/physical/si/fps/derived/force.h

@@ -62,4 +62,12 @@ constexpr auto operator"" _q_klbf(long double l) { return force<kilopound_force,
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto pdl = force<poundal, detail::one_rep>{};
+inline constexpr auto lbf = force<pound_force, detail::one_rep>{};
+inline constexpr auto klbf = force<kilopound_force, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si::fps

src/include/units/physical/si/fps/derived/power.h

@@ -46,15 +46,20 @@ inline namespace literals {
 constexpr auto operator"" _q_ft_pdl_per_s(unsigned long long l) { return power<foot_poundal_per_second, std::int64_t>(l); }
 constexpr auto operator"" _q_ft_pdl_per_s(long double l) { return power<foot_poundal_per_second, long double>(l); }
 
-
 // foot pound force per second
 constexpr auto operator"" _q_ft_lbf_per_s(unsigned long long l) { return power<foot_pound_force_per_second, std::int64_t>(l); }
 constexpr auto operator"" _q_ft_lbf_per_s(long double l) { return power<foot_pound_force_per_second, long double>(l); }
 
-
+// horse power
 constexpr auto operator"" _q_hp(unsigned long long l) { return power<horse_power, std::int64_t>(l); }
 constexpr auto operator"" _q_hp(long double l) { return power<horse_power, long double>(l); }
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto hp = power<horse_power, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si::fps

src/include/units/physical/si/fps/derived/pressure.h

@@ -44,6 +44,7 @@ struct pound_force_per_inch_sq : named_scaled_unit<pound_force_per_inch_sq, "psi
 struct kilopound_force_per_inch_sq : prefixed_unit<kilopound_force_per_inch_sq, si::kilo, pound_force_per_inch_sq> {};
 
 inline namespace literals {
+
 // Poundal per square foot
 constexpr auto operator"" _q_pdl_per_ft2(unsigned long long l) { return pressure<poundal_per_foot_sq, std::int64_t>(l); }
 constexpr auto operator"" _q_pdl_per_ft2(long double l) { return pressure<poundal_per_foot_sq, long double>(l); }
@@ -58,4 +59,11 @@ constexpr auto operator"" _q_kpsi(long double l) { return pressure<kilopound_for
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto psi = pressure<pound_force_per_inch_sq, detail::one_rep>{};
+inline constexpr auto kpsi = pressure<kilopound_force_per_inch_sq, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si::fps

src/include/units/physical/si/fps/derived/speed.h

@@ -44,16 +44,25 @@ struct knot : alias_unit<nautical_mile_per_hour, "knot", no_prefix> {};
 
 inline namespace literals {
 
+// ft/s
 constexpr auto operator"" _q_ft_per_s(unsigned long long l) { return speed<foot_per_second, std::int64_t>(l); }
 constexpr auto operator"" _q_ft_per_s(long double l) { return speed<foot_per_second, long double>(l); }
 
+// mph
 constexpr auto operator"" _q_mph(unsigned long long l) { return speed<mile_per_hour, std::int64_t>(l); }
 constexpr auto operator"" _q_mph(long double l) { return speed<mile_per_hour, long double>(l); }
 
+// kn
 constexpr auto operator"" _q_knot(unsigned long long l) { return speed<knot, std::int64_t>(l); }
 constexpr auto operator"" _q_knot(long double l) { return speed<knot, long double>(l); }
 
-
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto mph = speed<mile_per_hour, detail::one_rep>{};
+inline constexpr auto knot = speed<fps::knot, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si::fps

src/include/units/physical/si/fps/derived/volume.h

@@ -42,10 +42,17 @@ inline namespace literals {
 constexpr auto operator"" _q_ft3(unsigned long long l) { return volume<cubic_foot, std::int64_t>(l); }
 constexpr auto operator"" _q_ft3(long double l) { return volume<cubic_foot, long double>(l); }
 
-// yard3
+// yd3
 constexpr auto operator"" _q_yd3(unsigned long long l) { return volume<cubic_yard, std::int64_t>(l); }
 constexpr auto operator"" _q_yd3(long double l) { return volume<cubic_yard, long double>(l); }
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto ft3 = volume<cubic_foot, detail::one_rep>{};
+inline constexpr auto yd3 = volume<cubic_yard, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si::fps

src/include/units/physical/si/iau/base/length.h

@@ -38,15 +38,26 @@ struct angstrom : named_scaled_unit<angstrom, "angstrom", no_prefix, ratio(1, 1,
 
 inline namespace literals {
 
+// ly
 constexpr auto operator"" _q_ly(unsigned long long l) { return si::length<light_year, std::int64_t>(l); }
 constexpr auto operator"" _q_ly(long double l) { return si::length<light_year, long double>(l); }
 
+// pc
 constexpr auto operator"" _q_pc(unsigned long long l) { return si::length<parsec, std::int64_t>(l); }
 constexpr auto operator"" _q_pc(long double l) { return si::length<parsec, long double>(l); }
 
+// angstrom
 constexpr auto operator"" _q_angstrom(unsigned long long l) { return si::length<angstrom, std::int64_t>(l); }
 constexpr auto operator"" _q_angstrom(long double l) { return si::length<angstrom, long double>(l); }
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto ly = si::length<light_year, detail::one_rep>{};
+inline constexpr auto pc = si::length<parsec, detail::one_rep>{};
+inline constexpr auto angstrom = si::length<iau::angstrom, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si::iau

src/include/units/physical/si/imperial/base/length.h

@@ -34,12 +34,21 @@ struct rod : named_scaled_unit<rod, "rd", no_prefix, ratio(1, 4), chain> {};
 
 inline namespace literals {
 
+// ch
 constexpr auto operator"" _q_ch(unsigned long long l) { return si::length<chain, std::int64_t>(l); }
 constexpr auto operator"" _q_ch(long double l) { return si::length<chain, long double>(l); }
 
+// rd
 constexpr auto operator"" _q_rd(unsigned long long l) { return si::length<rod, std::int64_t>(l); }
 constexpr auto operator"" _q_rd(long double l) { return si::length<rod, long double>(l); }
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto ch = si::length<chain, detail::one_rep>{};
+inline constexpr auto rd = si::length<rod, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si::imperial

src/include/units/physical/si/international/base/length.h

@@ -94,4 +94,17 @@ constexpr auto operator"" _q_mil(long double l) { return si::length<mil, long do
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto yd = si::length<yard, detail::one_rep>{};
+inline constexpr auto ft = si::length<foot, detail::one_rep>{};
+inline constexpr auto fathom = si::length<international::fathom, detail::one_rep>{};
+inline constexpr auto in = si::length<inch, detail::one_rep>{};
+inline constexpr auto mi = si::length<mile, detail::one_rep>{};
+inline constexpr auto mi_naut = si::length<nautical_mile, detail::one_rep>{};
+inline constexpr auto thou = si::length<international::thou, detail::one_rep>{};
+inline constexpr auto mil = si::length<international::mil, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si::international

src/include/units/physical/si/international/derived/area.h

@@ -37,4 +37,10 @@ constexpr auto operator"" _q_ft2(long double l) { return si::area<square_foot, l
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto ft2 = si::area<square_foot, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si::international

src/include/units/physical/si/international/derived/speed.h

@@ -31,7 +31,7 @@ struct mile_per_hour : deduced_unit<mile_per_hour, si::dim_speed, si::internatio
 
 inline namespace literals {
 
-// mph
+// mi/h
 constexpr auto operator"" _q_mi_per_h(unsigned long long l) { return si::speed<mile_per_hour, std::int64_t>(l); }
 constexpr auto operator"" _q_mi_per_h(long double l) { return si::speed<mile_per_hour, long double>(l); }
 

src/include/units/physical/si/international/derived/volume.h

@@ -37,4 +37,10 @@ constexpr auto operator"" _q_ft3(long double l) { return si::volume<cubic_foot,
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto ft3 = si::volume<cubic_foot, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si::international

src/include/units/physical/si/typographic/base/length.h

@@ -53,4 +53,13 @@ constexpr auto operator"" _q_point_prn(long double l) { return si::length<point_
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto pica_comp = si::length<typographic::pica_comp, detail::one_rep>{};
+inline constexpr auto pica_prn = si::length<typographic::pica_prn, detail::one_rep>{};
+inline constexpr auto point_comp = si::length<typographic::point_comp, detail::one_rep>{};
+inline constexpr auto point_prn = si::length<typographic::point_prn, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si::typographic

src/include/units/physical/si/us/base/length.h

@@ -47,10 +47,18 @@ constexpr auto operator"" _q_ft_us(long double l) { return si::length<units::phy
 constexpr auto operator"" _q_fathom_us(unsigned long long l) { return si::length<units::physical::si::us::fathom, std::int64_t>(l); }
 constexpr auto operator"" _q_fathom_us(long double l) { return si::length<units::physical::si::us::fathom, long double>(l); }
 
-// ft
+// mi
 constexpr auto operator"" _q_mi_us(unsigned long long l) { return si::length<units::physical::si::us::mile, std::int64_t>(l); }
 constexpr auto operator"" _q_mi_us(long double l) { return si::length<units::physical::si::us::mile, long double>(l); }
 
 }  // namespace literals
 
+namespace unit_constants {
+
+inline constexpr auto ft = si::length<units::physical::si::us::foot, detail::one_rep>{};
+inline constexpr auto fathom = si::length<units::physical::si::us::fathom, detail::one_rep>{};
+inline constexpr auto mi = si::length<units::physical::si::us::mile, detail::one_rep>{};
+
+}  // namespace unit_constants
+
 }  // namespace units::physical::si::us

test/unit_test/static/CMakeLists.txt

@@ -43,6 +43,7 @@ add_library(unit_tests_static
     si_fps_test.cpp
     symbol_text_test.cpp
     type_list_test.cpp
+    unit_constants.cpp
     unit_test.cpp
     us_test.cpp
 )

test/unit_test/static/unit_constants.cpp

@@ -0,0 +1,85 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2018 Mateusz Pusz
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include "units/bits/external/hacks.h"
+#include "units/physical/dimensions/length.h"
+#include "units/physical/dimensions/speed.h"
+#include "units/physical/si/base/length.h"
+#include "units/physical/si/base/mass.h"
+#include "units/physical/si/base/time.h"
+#include "units/physical/si/derived/area.h"
+#include "units/physical/si/derived/speed.h"
+#include <cassert>
+#include <cstdint>
+#include <type_traits>
+
+#if defined(COMP_MSVC)
+#pragma warning( disable : 4459 ) // Disable shadowing warning.
+#endif
+
+using namespace units::physical;
+using namespace si;
+using namespace unit_constants;
+
+static_assert(2 * m == 2_q_m);
+static_assert(2 * s == 2_q_s);
+#if !defined(COMP_MSVC) || defined(NDEBUG)
+static_assert([]<auto& s = ::s>() {
+  assert(!requires { s / 2; });
+  assert(!requires { s * 2; });
+  assert(!requires { s + 2; });
+  assert(!requires { s + s; });
+  return 1_q_s + s == 2_q_s;
+}());
+#endif
+
+constexpr auto m_per_s = m / s;
+
+static_assert(2_q_m / s == 2_q_m_per_s);
+static_assert(2 * m / s == 2_q_m_per_s);
+static_assert(2 / s * m == 2_q_m_per_s);
+static_assert(2 * (m / s) == 2_q_m_per_s);
+static_assert(2 * ::m_per_s == 2_q_m_per_s);
+static_assert(std::is_same_v<decltype(::m_per_s)::rep, decltype(m)::rep>);
+
+static_assert(120 * km / (2 * h) == 60_q_km_per_h);
+static_assert(120 * km / 2 / h == 60_q_km_per_h);
+static_assert([] {
+  const auto length{120};
+  const auto duration{2};
+  return length * km / (duration * h);
+}() == 60_q_km_per_h);
+static_assert(std::is_same_v<decltype(std::int64_t{120} * km / (2 * h)), decltype(60_q_km_per_h)>);
+static_assert(std::is_same_v<decltype(std::int64_t{120} * km / 2 / h), decltype(60_q_km_per_h)>);
+static_assert(std::is_same_v<decltype(120.L * km / 2 / h), decltype(60._q_km_per_h)>);
+
+static_assert(1. / 4 * m2 == 1._q_m2 / 4);
+
+static_assert([] {
+  Speed auto v0 = 10 * m / s;
+  signed s = 2;  // hides  ^
+  Length auto v = 20 * m / s;
+  /*      */ v0 = 10 * m / ::s;
+  return !std::is_same_v<decltype(v0), decltype(v)>;
+}());
+
+int main() {}