style: clang-format applied to the remaining files

src/core/include/units/generic/angle.h

@@ -48,12 +48,16 @@ using angle = quantity<dim_angle<>, U, Rep>;
 inline namespace literals {
 
 // rad
-constexpr auto operator"" _q_rad(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return angle<radian, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_rad(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return angle<radian, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_rad(long double l) { return angle<radian, long double>(l); }
 
 }  // namespace literals
 
-#endif // UNITS_NO_LITERALS
+#endif  // UNITS_NO_LITERALS
 
 #ifndef UNITS_NO_REFERENCES
 
@@ -69,6 +73,6 @@ using namespace angle_references;
 
 }  // namespace references
 
-#endif // UNITS_NO_REFERENCES
+#endif  // UNITS_NO_REFERENCES
 
 }  // namespace units

src/systems/si-fps/include/units/isq/si/fps/acceleration.h

@@ -44,12 +44,16 @@ using acceleration = quantity<dim_acceleration, U, Rep>;
 inline namespace literals {
 
 // ft/s2
-constexpr auto operator"" _q_ft_per_s2(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return acceleration<foot_per_second_sq, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_ft_per_s2(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return acceleration<foot_per_second_sq, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_ft_per_s2(long double l) { return acceleration<foot_per_second_sq, long double>(l); }
 
 }  // namespace literals
 
-#endif // UNITS_NO_LITERALS
+#endif  // UNITS_NO_LITERALS
 
 }  // namespace units::isq::si::fps
 
@@ -57,8 +61,9 @@ constexpr auto operator"" _q_ft_per_s2(long double l) { return acceleration<foot
 
 namespace units::aliases::isq::si::fps::inline acceleration {
 
-template<Representation Rep = double> using ft_per_s2 = units::isq::si::fps::acceleration<units::isq::si::fps::foot_per_second_sq, Rep>;
+template<Representation Rep = double>
+using ft_per_s2 = units::isq::si::fps::acceleration<units::isq::si::fps::foot_per_second_sq, Rep>;
 
 }  // namespace units::aliases::isq::si::fps::inline acceleration
 
-#endif // UNITS_NO_ALIASES
+#endif  // UNITS_NO_ALIASES

src/systems/si-fps/include/units/isq/si/fps/area.h

@@ -46,12 +46,16 @@ using area = quantity<dim_area, U, Rep>;
 inline namespace literals {
 
 // ft2
-constexpr auto operator"" _q_ft2(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return area<square_foot, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_ft2(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return area<square_foot, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_ft2(long double l) { return area<square_foot, long double>(l); }
 
 }  // namespace literals
 
-#endif // UNITS_NO_LITERALS
+#endif  // UNITS_NO_LITERALS
 
 #ifndef UNITS_NO_REFERENCES
 
@@ -67,7 +71,7 @@ using namespace area_references;
 
 }  // namespace references
 
-#endif // UNITS_NO_REFERENCES
+#endif  // UNITS_NO_REFERENCES
 
 }  // namespace units::isq::si::fps
 
@@ -75,8 +79,9 @@ using namespace area_references;
 
 namespace units::aliases::isq::si::fps::inline area {
 
-template<Representation Rep = double> using ft2 = units::isq::si::fps::area<units::isq::si::fps::square_foot, Rep>;
+template<Representation Rep = double>
+using ft2 = units::isq::si::fps::area<units::isq::si::fps::square_foot, Rep>;
 
-}  // namespace units::aliases::isq::si::fps::inlipne area
+}  // namespace units::aliases::isq::si::fps::inline area
 
-#endif // UNITS_NO_ALIASES
+#endif  // UNITS_NO_ALIASES

src/systems/si-fps/include/units/isq/si/fps/density.h

@@ -28,8 +28,8 @@
 #include <units/symbol_text.h>
 // IWYU pragma: end_exports
 
-#include <units/isq/si/fps/mass.h>
 #include <units/isq/si/fps/length.h>
+#include <units/isq/si/fps/mass.h>
 #include <units/unit.h>
 
 namespace units::isq::si::fps {
@@ -46,12 +46,16 @@ using density = quantity<dim_density, U, Rep>;
 inline namespace literals {
 
 // lb/ft³
-constexpr auto operator"" _q_lb_per_ft3(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return density<pound_per_foot_cub, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_lb_per_ft3(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return density<pound_per_foot_cub, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_lb_per_ft3(long double l) { return density<pound_per_foot_cub, long double>(l); }
 
 }  // namespace literals
 
-#endif // UNITS_NO_LITERALS
+#endif  // UNITS_NO_LITERALS
 
 }  // namespace units::isq::si::fps
 
@@ -59,8 +63,9 @@ constexpr auto operator"" _q_lb_per_ft3(long double l) { return density<pound_pe
 
 namespace units::aliases::isq::si::fps::inline density {
 
-template<Representation Rep = double> using lb_per_ft3 = units::isq::si::fps::density<units::isq::si::fps::pound_per_foot_cub, Rep>;
+template<Representation Rep = double>
+using lb_per_ft3 = units::isq::si::fps::density<units::isq::si::fps::pound_per_foot_cub, Rep>;
 
 }  // namespace units::aliases::isq::si::fps::inline density
 
-#endif // UNITS_NO_ALIASES
+#endif  // UNITS_NO_ALIASES

src/systems/si-fps/include/units/isq/si/fps/energy.h

@@ -40,7 +40,7 @@ struct foot_poundal : unit<foot_poundal> {};
 struct dim_energy : isq::dim_energy<dim_energy, foot_poundal, dim_length, dim_force> {};
 
 // https://en.wikipedia.org/wiki/Foot-pound_(energy)
- struct foot_pound_force : derived_unit<foot_pound_force, dim_energy, foot, pound_force> {};
+struct foot_pound_force : derived_unit<foot_pound_force, dim_energy, foot, pound_force> {};
 
 template<UnitOf<dim_energy> U, Representation Rep = double>
 using energy = quantity<dim_energy, U, Rep>;
@@ -50,16 +50,24 @@ using energy = quantity<dim_energy, U, Rep>;
 inline namespace literals {
 
 // foot poundal
-constexpr auto operator"" _q_ft_pdl(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return energy<foot_poundal, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_ft_pdl(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return energy<foot_poundal, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_ft_pdl(long double l) { return energy<foot_poundal, long double>(l); }
 
 // foot_pound force
-constexpr auto operator"" _q_ft_lbf(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return energy<foot_pound_force, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_ft_lbf(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return energy<foot_pound_force, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_ft_lbf(long double l) { return energy<foot_pound_force, long double>(l); }
 
 }  // namespace literals
 
-#endif // UNITS_NO_LITERALS
+#endif  // UNITS_NO_LITERALS
 
 }  // namespace units::isq::si::fps
 
@@ -67,9 +75,11 @@ constexpr auto operator"" _q_ft_lbf(long double l) { return energy<foot_pound_fo
 
 namespace units::aliases::isq::si::fps::inline energy {
 
-template<Representation Rep = double> using ft_pdl = units::isq::si::fps::energy<units::isq::si::fps::foot_poundal, Rep>;
-template<Representation Rep = double> using ft_lbf = units::isq::si::fps::energy<units::isq::si::fps::foot_pound_force, Rep>;
+template<Representation Rep = double>
+using ft_pdl = units::isq::si::fps::energy<units::isq::si::fps::foot_poundal, Rep>;
+template<Representation Rep = double>
+using ft_lbf = units::isq::si::fps::energy<units::isq::si::fps::foot_pound_force, Rep>;
 
 }  // namespace units::aliases::isq::si::fps::inline energy
 
-#endif // UNITS_NO_ALIASES
+#endif  // UNITS_NO_ALIASES

src/systems/si-fps/include/units/isq/si/fps/force.h

@@ -57,20 +57,32 @@ using force = quantity<dim_force, U, Rep>;
 inline namespace literals {
 
 // poundal
-constexpr auto operator"" _q_pdl(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return force<poundal, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_pdl(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return force<poundal, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_pdl(long double l) { return force<poundal, long double>(l); }
 
 // pound force
-constexpr auto operator"" _q_lbf(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return force<pound_force, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_lbf(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return force<pound_force, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_lbf(long double l) { return force<pound_force, long double>(l); }
 
 // kilopound force
-constexpr auto operator"" _q_klbf(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return force<kilopound_force, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_klbf(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return force<kilopound_force, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_klbf(long double l) { return force<kilopound_force, long double>(l); }
 
 }  // namespace literals
 
-#endif // UNITS_NO_LITERALS
+#endif  // UNITS_NO_LITERALS
 
 #ifndef UNITS_NO_REFERENCES
 
@@ -88,7 +100,7 @@ using namespace force_references;
 
 }  // namespace references
 
-#endif // UNITS_NO_REFERENCES
+#endif  // UNITS_NO_REFERENCES
 
 }  // namespace units::isq::si::fps
 
@@ -96,10 +108,13 @@ using namespace force_references;
 
 namespace units::aliases::isq::si::fps::inline force {
 
-template<Representation Rep = double> using pdl = units::isq::si::fps::force<units::isq::si::fps::poundal, Rep>;
-template<Representation Rep = double> using lbf = units::isq::si::fps::force<units::isq::si::fps::pound_force, Rep>;
-template<Representation Rep = double> using klbf = units::isq::si::fps::force<units::isq::si::fps::kilopound_force, Rep>;
+template<Representation Rep = double>
+using pdl = units::isq::si::fps::force<units::isq::si::fps::poundal, Rep>;
+template<Representation Rep = double>
+using lbf = units::isq::si::fps::force<units::isq::si::fps::pound_force, Rep>;
+template<Representation Rep = double>
+using klbf = units::isq::si::fps::force<units::isq::si::fps::kilopound_force, Rep>;
 
 }  // namespace units::aliases::isq::si::fps::inline force
 
-#endif // UNITS_NO_ALIASES
+#endif  // UNITS_NO_ALIASES

src/systems/si-fps/include/units/isq/si/fps/fps.h

@@ -23,17 +23,16 @@
 #pragma once
 
 // IWYU pragma: begin_exports
-#include <units/isq/si/fps/length.h>
-#include <units/isq/si/fps/mass.h>
-#include <units/isq/si/fps/time.h>
-
 #include <units/isq/si/fps/acceleration.h>
 #include <units/isq/si/fps/area.h>
 #include <units/isq/si/fps/density.h>
 #include <units/isq/si/fps/energy.h>
 #include <units/isq/si/fps/force.h>
+#include <units/isq/si/fps/length.h>
+#include <units/isq/si/fps/mass.h>
 #include <units/isq/si/fps/power.h>
 #include <units/isq/si/fps/pressure.h>
 #include <units/isq/si/fps/speed.h>
+#include <units/isq/si/fps/time.h>
 #include <units/isq/si/fps/volume.h>
 // IWYU pragma: end_exports

src/systems/si-fps/include/units/isq/si/fps/pressure.h

@@ -43,9 +43,12 @@ struct dim_pressure : isq::dim_pressure<dim_pressure, poundal_per_foot_sq, dim_f
 template<UnitOf<dim_pressure> U, Representation Rep = double>
 using pressure = quantity<dim_pressure, U, Rep>;
 
-struct pound_force_per_foot_sq : named_scaled_unit<pound_force_per_foot_sq, "lbf ft2", si::prefix, ratio(32'174'049, 1'000'000), poundal_per_foot_sq> {};
+struct pound_force_per_foot_sq :
+    named_scaled_unit<pound_force_per_foot_sq, "lbf ft2", si::prefix, ratio(32'174'049, 1'000'000),
+                      poundal_per_foot_sq> {};
 
-struct pound_force_per_inch_sq : named_scaled_unit<pound_force_per_inch_sq, "psi", si::prefix, ratio(1, 144), pound_force_per_foot_sq> {};
+struct pound_force_per_inch_sq :
+    named_scaled_unit<pound_force_per_inch_sq, "psi", si::prefix, ratio(1, 144), pound_force_per_foot_sq> {};
 
 struct kilopound_force_per_inch_sq : prefixed_unit<kilopound_force_per_inch_sq, si::kilo, pound_force_per_inch_sq> {};
 
@@ -54,20 +57,32 @@ struct kilopound_force_per_inch_sq : prefixed_unit<kilopound_force_per_inch_sq,
 inline namespace literals {
 
 // Poundal per square foot
-constexpr auto operator"" _q_pdl_per_ft2(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return pressure<poundal_per_foot_sq, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_pdl_per_ft2(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return pressure<poundal_per_foot_sq, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_pdl_per_ft2(long double l) { return pressure<poundal_per_foot_sq, long double>(l); }
 
 // Pounds per square inch
-constexpr auto operator"" _q_psi(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return pressure<pound_force_per_inch_sq, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_psi(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return pressure<pound_force_per_inch_sq, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_psi(long double l) { return pressure<pound_force_per_inch_sq, long double>(l); }
 
 // kilopounds per square inch
-constexpr auto operator"" _q_kpsi(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return pressure<kilopound_force_per_inch_sq, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_kpsi(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return pressure<kilopound_force_per_inch_sq, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_kpsi(long double l) { return pressure<kilopound_force_per_inch_sq, long double>(l); }
 
 }  // namespace literals
 
-#endif // UNITS_NO_LITERALS
+#endif  // UNITS_NO_LITERALS
 
 #ifndef UNITS_NO_REFERENCES
 
@@ -84,7 +99,7 @@ using namespace pressure_references;
 
 }  // namespace references
 
-#endif // UNITS_NO_REFERENCES
+#endif  // UNITS_NO_REFERENCES
 
 }  // namespace units::isq::si::fps
 
@@ -92,10 +107,13 @@ using namespace pressure_references;
 
 namespace units::aliases::isq::si::fps::inline pressure {
 
-template<Representation Rep = double> using pdl_per_ft2 = units::isq::si::fps::pressure<units::isq::si::fps::poundal_per_foot_sq, Rep>;
-template<Representation Rep = double> using psi = units::isq::si::fps::pressure<units::isq::si::fps::pound_force_per_inch_sq, Rep>;
-template<Representation Rep = double> using kpsi = units::isq::si::fps::pressure<units::isq::si::fps::kilopound_force_per_inch_sq, Rep>;
+template<Representation Rep = double>
+using pdl_per_ft2 = units::isq::si::fps::pressure<units::isq::si::fps::poundal_per_foot_sq, Rep>;
+template<Representation Rep = double>
+using psi = units::isq::si::fps::pressure<units::isq::si::fps::pound_force_per_inch_sq, Rep>;
+template<Representation Rep = double>
+using kpsi = units::isq::si::fps::pressure<units::isq::si::fps::kilopound_force_per_inch_sq, Rep>;
 
 }  // namespace units::aliases::isq::si::fps::inline pressure
 
-#endif // UNITS_NO_ALIASES
+#endif  // UNITS_NO_ALIASES

src/systems/si-fps/include/units/isq/si/fps/speed.h

@@ -41,8 +41,8 @@ struct dim_speed : isq::dim_speed<dim_speed, foot_per_second, dim_length, dim_ti
 template<UnitOf<dim_speed> U, Representation Rep = double>
 using speed = quantity<dim_speed, U, Rep>;
 
-struct mile_per_hour : derived_unit<mile_per_hour, dim_speed, mile, hour>{};
-struct nautical_mile_per_hour : derived_unit<nautical_mile_per_hour, dim_speed, nautical_mile, hour>{};
+struct mile_per_hour : derived_unit<mile_per_hour, dim_speed, mile, hour> {};
+struct nautical_mile_per_hour : derived_unit<nautical_mile_per_hour, dim_speed, nautical_mile, hour> {};
 struct knot : alias_unit<nautical_mile_per_hour, "knot", no_prefix> {};
 
 #ifndef UNITS_NO_LITERALS
@@ -50,20 +50,32 @@ 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) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return speed<foot_per_second, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_ft_per_s(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return speed<foot_per_second, std::int64_t>(static_cast<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) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return speed<mile_per_hour, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_mph(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return speed<mile_per_hour, std::int64_t>(static_cast<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) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return speed<knot, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_knot(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return speed<knot, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_knot(long double l) { return speed<knot, long double>(l); }
 
 }  // namespace literals
 
-#endif // UNITS_NO_LITERALS
+#endif  // UNITS_NO_LITERALS
 
 #ifndef UNITS_NO_REFERENCES
 
@@ -80,7 +92,7 @@ using namespace speed_references;
 
 }  // namespace references
 
-#endif // UNITS_NO_REFERENCES
+#endif  // UNITS_NO_REFERENCES
 
 }  // namespace units::isq::si::fps
 
@@ -88,10 +100,13 @@ using namespace speed_references;
 
 namespace units::aliases::isq::si::fps::inline speed {
 
-template<Representation Rep = double> using ft_per_s = units::isq::si::fps::speed<units::isq::si::fps::foot_per_second, Rep>;
-template<Representation Rep = double> using mph = units::isq::si::fps::speed<units::isq::si::fps::mile_per_hour, Rep>;
-template<Representation Rep = double> using knot = units::isq::si::fps::speed<units::isq::si::fps::knot, Rep>;
+template<Representation Rep = double>
+using ft_per_s = units::isq::si::fps::speed<units::isq::si::fps::foot_per_second, Rep>;
+template<Representation Rep = double>
+using mph = units::isq::si::fps::speed<units::isq::si::fps::mile_per_hour, Rep>;
+template<Representation Rep = double>
+using knot = units::isq::si::fps::speed<units::isq::si::fps::knot, Rep>;
 
 }  // namespace units::aliases::isq::si::fps::inline speed
 
-#endif // UNITS_NO_ALIASES
+#endif  // UNITS_NO_ALIASES

src/systems/si-hep/include/units/isq/si/hep/area.h

@@ -50,27 +50,63 @@ struct milli_barn : prefixed_unit<milli_barn, milli, barn> {};
 #ifndef UNITS_NO_LITERALS
 
 inline namespace literals {
-constexpr auto operator"" _q_yb(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return area<yocto_barn, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_yb(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return area<yocto_barn, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_yb(long double l) { return area<yocto_barn, long double>(l); }
-constexpr auto operator"" _q_zb(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return area<zepto_barn, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_zb(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return area<zepto_barn, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_zb(long double l) { return area<zepto_barn, long double>(l); }
-constexpr auto operator"" _q_ab(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return area<atto_barn, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_ab(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return area<atto_barn, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_ab(long double l) { return area<atto_barn, long double>(l); }
-constexpr auto operator"" _q_fb(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return area<femto_barn, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_fb(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return area<femto_barn, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_fb(long double l) { return area<femto_barn, long double>(l); }
-constexpr auto operator"" _q_pb(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return area<pico_barn, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_pb(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return area<pico_barn, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_pb(long double l) { return area<pico_barn, long double>(l); }
-constexpr auto operator"" _q_nb(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return area<nano_barn, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_nb(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return area<nano_barn, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_nb(long double l) { return area<nano_barn, long double>(l); }
-constexpr auto operator"" _q_ub(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return area<micro_barn, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_ub(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return area<micro_barn, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_ub(long double l) { return area<micro_barn, long double>(l); }
-constexpr auto operator"" _q_mb(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return area<milli_barn, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_mb(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return area<milli_barn, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_mb(long double l) { return area<milli_barn, long double>(l); }
-constexpr auto operator"" _q_b(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return area<barn, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_b(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return area<barn, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_b(long double l) { return area<barn, long double>(l); }
 }  // namespace literals
 
-#endif // UNITS_NO_LITERALS
+#endif  // UNITS_NO_LITERALS
 
 #ifndef UNITS_NO_REFERENCES
 
@@ -86,7 +122,7 @@ using namespace area_references;
 
 }  // namespace references
 
-#endif // UNITS_NO_REFERENCES
+#endif  // UNITS_NO_REFERENCES
 
 }  // namespace units::isq::si::hep
 
@@ -94,8 +130,9 @@ using namespace area_references;
 
 namespace units::aliases::isq::si::hep::inline area {
 
-template<Representation Rep = double> using barn = units::isq::si::area<units::isq::si::hep::barn, Rep>;
+template<Representation Rep = double>
+using barn = units::isq::si::area<units::isq::si::hep::barn, Rep>;
 
 }  // namespace units::aliases::isq::si::hep::inline area
 
-#endif // UNITS_NO_ALIASES
+#endif  // UNITS_NO_ALIASES

src/systems/si-international/include/units/isq/si/international/area.h

@@ -42,12 +42,16 @@ struct square_foot : derived_unit<square_foot, si::dim_area, si::international::
 inline namespace literals {
 
 // ft2
-constexpr auto operator"" _q_ft2(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return si::area<square_foot, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_ft2(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return si::area<square_foot, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_ft2(long double l) { return si::area<square_foot, long double>(l); }
 
 }  // namespace literals
 
-#endif // UNITS_NO_LITERALS
+#endif  // UNITS_NO_LITERALS
 
 #ifndef UNITS_NO_REFERENCES
 
@@ -63,7 +67,7 @@ using namespace area_references;
 
 }  // namespace references
 
-#endif // UNITS_NO_REFERENCES
+#endif  // UNITS_NO_REFERENCES
 
 }  // namespace units::isq::si::international
 
@@ -71,8 +75,9 @@ using namespace area_references;
 
 namespace units::aliases::isq::si::international::inline area {
 
-template<Representation Rep = double> using ft2 = units::isq::si::area<units::isq::si::international::square_foot, Rep>;
+template<Representation Rep = double>
+using ft2 = units::isq::si::area<units::isq::si::international::square_foot, Rep>;
 
 }  // namespace units::aliases::isq::si::international::inline area
 
-#endif // UNITS_NO_ALIASES
+#endif  // UNITS_NO_ALIASES

src/systems/si-international/include/units/isq/si/international/international.h

@@ -23,9 +23,8 @@
 #pragma once
 
 // IWYU pragma: begin_exports
-#include <units/isq/si/international/length.h>
-
 #include <units/isq/si/international/area.h>
+#include <units/isq/si/international/length.h>
 #include <units/isq/si/international/speed.h>
 #include <units/isq/si/international/volume.h>
 // IWYU pragma: end_exports

src/systems/si/include/units/isq/si/absorbed_dose.h

@@ -67,92 +67,176 @@ using absorbed_dose = quantity<dim_absorbed_dose, U, Rep>;
 inline namespace literals {
 
 // Gy
-constexpr auto operator"" _q_Gy(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return absorbed_dose<gray, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_Gy(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return absorbed_dose<gray, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_Gy(long double l) { return absorbed_dose<gray, long double>(l); }
 
 // yGy
-constexpr auto operator"" _q_yGy(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return absorbed_dose<yoctogray, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_yGy(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return absorbed_dose<yoctogray, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_yGy(long double l) { return absorbed_dose<yoctogray, long double>(l); }
 
 // zGy
-constexpr auto operator"" _q_zGy(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return absorbed_dose<zeptogray, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_zGy(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return absorbed_dose<zeptogray, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_zGy(long double l) { return absorbed_dose<zeptogray, long double>(l); }
 
 // aGy
-constexpr auto operator"" _q_aGy(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return absorbed_dose<attogray, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_aGy(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return absorbed_dose<attogray, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_aGy(long double l) { return absorbed_dose<attogray, long double>(l); }
 
 // fGy
-constexpr auto operator"" _q_fGy(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return absorbed_dose<femtogray, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_fGy(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return absorbed_dose<femtogray, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_fGy(long double l) { return absorbed_dose<femtogray, long double>(l); }
 
 // pGy
-constexpr auto operator"" _q_pGy(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return absorbed_dose<picogray, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_pGy(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return absorbed_dose<picogray, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_pGy(long double l) { return absorbed_dose<picogray, long double>(l); }
 
 // nGy
-constexpr auto operator"" _q_nGy(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return absorbed_dose<nanogray, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_nGy(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return absorbed_dose<nanogray, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_nGy(long double l) { return absorbed_dose<nanogray, long double>(l); }
 
 // uGy
-constexpr auto operator"" _q_uGy(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return absorbed_dose<microgray, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_uGy(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return absorbed_dose<microgray, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_uGy(long double l) { return absorbed_dose<microgray, long double>(l); }
 
 // mGy
-constexpr auto operator"" _q_mGy(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return absorbed_dose<milligray, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_mGy(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return absorbed_dose<milligray, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_mGy(long double l) { return absorbed_dose<milligray, long double>(l); }
 
 // cGy
-constexpr auto operator"" _q_cGy(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return absorbed_dose<centigray, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_cGy(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return absorbed_dose<centigray, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_cGy(long double l) { return absorbed_dose<centigray, long double>(l); }
 
 // dGy
-constexpr auto operator"" _q_dGy(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return absorbed_dose<decigray, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_dGy(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return absorbed_dose<decigray, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_dGy(long double l) { return absorbed_dose<decigray, long double>(l); }
 
 // daGy
-constexpr auto operator"" _q_daGy(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return absorbed_dose<decagray, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_daGy(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return absorbed_dose<decagray, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_daGy(long double l) { return absorbed_dose<decagray, long double>(l); }
 
 // hGy
-constexpr auto operator"" _q_hGy(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return absorbed_dose<hectogray, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_hGy(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return absorbed_dose<hectogray, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_hGy(long double l) { return absorbed_dose<hectogray, long double>(l); }
 
 // kGy
-constexpr auto operator"" _q_kGy(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return absorbed_dose<kilogray, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_kGy(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return absorbed_dose<kilogray, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_kGy(long double l) { return absorbed_dose<kilogray, long double>(l); }
 
 // MGy
-constexpr auto operator"" _q_MGy(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return absorbed_dose<megagray, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_MGy(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return absorbed_dose<megagray, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_MGy(long double l) { return absorbed_dose<megagray, long double>(l); }
 
 // GGy
-constexpr auto operator"" _q_GGy(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return absorbed_dose<gigagray, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_GGy(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return absorbed_dose<gigagray, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_GGy(long double l) { return absorbed_dose<gigagray, long double>(l); }
 
 // TGy
-constexpr auto operator"" _q_TGy(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return absorbed_dose<teragray, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_TGy(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return absorbed_dose<teragray, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_TGy(long double l) { return absorbed_dose<teragray, long double>(l); }
 
 // PGy
-constexpr auto operator"" _q_PGy(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return absorbed_dose<petagray, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_PGy(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return absorbed_dose<petagray, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_PGy(long double l) { return absorbed_dose<petagray, long double>(l); }
 
 // EGy
-constexpr auto operator"" _q_EGy(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return absorbed_dose<exagray, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_EGy(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return absorbed_dose<exagray, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_EGy(long double l) { return absorbed_dose<exagray, long double>(l); }
 
 // ZGy
-constexpr auto operator"" _q_ZGy(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return absorbed_dose<zettagray, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_ZGy(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return absorbed_dose<zettagray, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_ZGy(long double l) { return absorbed_dose<zettagray, long double>(l); }
 
 // YGy
-constexpr auto operator"" _q_YGy(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return absorbed_dose<yottagray, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_YGy(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return absorbed_dose<yottagray, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_YGy(long double l) { return absorbed_dose<yottagray, long double>(l); }
 
 }  // namespace literals
 
-#endif // UNITS_NO_LITERALS
+#endif  // UNITS_NO_LITERALS
 
 #ifndef UNITS_NO_REFERENCES
 
@@ -188,7 +272,7 @@ using namespace absorbed_dose_references;
 
 }  // namespace references
 
-#endif // UNITS_NO_REFERENCES
+#endif  // UNITS_NO_REFERENCES
 
 }  // namespace units::isq::si
 
@@ -196,28 +280,49 @@ using namespace absorbed_dose_references;
 
 namespace units::aliases::isq::si::inline absorbed_dose {
 
-template<Representation Rep = double> using Gy = units::isq::si::absorbed_dose<units::isq::si::gray, Rep>;
-template<Representation Rep = double> using yGy = units::isq::si::absorbed_dose<units::isq::si::yoctogray, Rep>;
-template<Representation Rep = double> using zGy = units::isq::si::absorbed_dose<units::isq::si::zeptogray, Rep>;
-template<Representation Rep = double> using aGy = units::isq::si::absorbed_dose<units::isq::si::attogray, Rep>;
-template<Representation Rep = double> using fGy = units::isq::si::absorbed_dose<units::isq::si::femtogray, Rep>;
-template<Representation Rep = double> using pGy = units::isq::si::absorbed_dose<units::isq::si::picogray, Rep>;
-template<Representation Rep = double> using nGy = units::isq::si::absorbed_dose<units::isq::si::nanogray, Rep>;
-template<Representation Rep = double> using uGy = units::isq::si::absorbed_dose<units::isq::si::microgray, Rep>;
-template<Representation Rep = double> using mGy = units::isq::si::absorbed_dose<units::isq::si::milligray, Rep>;
-template<Representation Rep = double> using cGy = units::isq::si::absorbed_dose<units::isq::si::centigray, Rep>;
-template<Representation Rep = double> using dGy = units::isq::si::absorbed_dose<units::isq::si::decigray, Rep>;
-template<Representation Rep = double> using daGy = units::isq::si::absorbed_dose<units::isq::si::decagray, Rep>;
-template<Representation Rep = double> using hGy = units::isq::si::absorbed_dose<units::isq::si::hectogray, Rep>;
-template<Representation Rep = double> using kGy = units::isq::si::absorbed_dose<units::isq::si::kilogray, Rep>;
-template<Representation Rep = double> using MGy = units::isq::si::absorbed_dose<units::isq::si::megagray, Rep>;
-template<Representation Rep = double> using GGy = units::isq::si::absorbed_dose<units::isq::si::gigagray, Rep>;
-template<Representation Rep = double> using TGy = units::isq::si::absorbed_dose<units::isq::si::teragray, Rep>;
-template<Representation Rep = double> using PGy = units::isq::si::absorbed_dose<units::isq::si::petagray, Rep>;
-template<Representation Rep = double> using EGy = units::isq::si::absorbed_dose<units::isq::si::exagray, Rep>;
-template<Representation Rep = double> using ZGy = units::isq::si::absorbed_dose<units::isq::si::zettagray, Rep>;
-template<Representation Rep = double> using YGy = units::isq::si::absorbed_dose<units::isq::si::yottagray, Rep>;
+template<Representation Rep = double>
+using Gy = units::isq::si::absorbed_dose<units::isq::si::gray, Rep>;
+template<Representation Rep = double>
+using yGy = units::isq::si::absorbed_dose<units::isq::si::yoctogray, Rep>;
+template<Representation Rep = double>
+using zGy = units::isq::si::absorbed_dose<units::isq::si::zeptogray, Rep>;
+template<Representation Rep = double>
+using aGy = units::isq::si::absorbed_dose<units::isq::si::attogray, Rep>;
+template<Representation Rep = double>
+using fGy = units::isq::si::absorbed_dose<units::isq::si::femtogray, Rep>;
+template<Representation Rep = double>
+using pGy = units::isq::si::absorbed_dose<units::isq::si::picogray, Rep>;
+template<Representation Rep = double>
+using nGy = units::isq::si::absorbed_dose<units::isq::si::nanogray, Rep>;
+template<Representation Rep = double>
+using uGy = units::isq::si::absorbed_dose<units::isq::si::microgray, Rep>;
+template<Representation Rep = double>
+using mGy = units::isq::si::absorbed_dose<units::isq::si::milligray, Rep>;
+template<Representation Rep = double>
+using cGy = units::isq::si::absorbed_dose<units::isq::si::centigray, Rep>;
+template<Representation Rep = double>
+using dGy = units::isq::si::absorbed_dose<units::isq::si::decigray, Rep>;
+template<Representation Rep = double>
+using daGy = units::isq::si::absorbed_dose<units::isq::si::decagray, Rep>;
+template<Representation Rep = double>
+using hGy = units::isq::si::absorbed_dose<units::isq::si::hectogray, Rep>;
+template<Representation Rep = double>
+using kGy = units::isq::si::absorbed_dose<units::isq::si::kilogray, Rep>;
+template<Representation Rep = double>
+using MGy = units::isq::si::absorbed_dose<units::isq::si::megagray, Rep>;
+template<Representation Rep = double>
+using GGy = units::isq::si::absorbed_dose<units::isq::si::gigagray, Rep>;
+template<Representation Rep = double>
+using TGy = units::isq::si::absorbed_dose<units::isq::si::teragray, Rep>;
+template<Representation Rep = double>
+using PGy = units::isq::si::absorbed_dose<units::isq::si::petagray, Rep>;
+template<Representation Rep = double>
+using EGy = units::isq::si::absorbed_dose<units::isq::si::exagray, Rep>;
+template<Representation Rep = double>
+using ZGy = units::isq::si::absorbed_dose<units::isq::si::zettagray, Rep>;
+template<Representation Rep = double>
+using YGy = units::isq::si::absorbed_dose<units::isq::si::yottagray, Rep>;
 
 }  // namespace units::aliases::isq::si::inline absorbed_dose
 
-#endif // UNITS_NO_ALIASES
+#endif  // UNITS_NO_ALIASES

src/systems/si/include/units/isq/si/acceleration.h

@@ -44,12 +44,16 @@ using acceleration = quantity<dim_acceleration, U, Rep>;
 inline namespace literals {
 
 // m/s2
-constexpr auto operator"" _q_m_per_s2(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return acceleration<metre_per_second_sq, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_m_per_s2(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return acceleration<metre_per_second_sq, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_m_per_s2(long double l) { return acceleration<metre_per_second_sq, long double>(l); }
 
 }  // namespace literals
 
-#endif // UNITS_NO_LITERALS
+#endif  // UNITS_NO_LITERALS
 
 }  // namespace units::isq::si
 
@@ -57,8 +61,9 @@ constexpr auto operator"" _q_m_per_s2(long double l) { return acceleration<metre
 
 namespace units::aliases::isq::si::inline acceleration {
 
-template<Representation Rep = double> using m_per_s2 = units::isq::si::acceleration<units::isq::si::metre_per_second_sq, Rep>;
+template<Representation Rep = double>
+using m_per_s2 = units::isq::si::acceleration<units::isq::si::metre_per_second_sq, Rep>;
 
 }  // namespace units::aliases::isq::si::inline acceleration
 
-#endif // UNITS_NO_ALIASES
+#endif  // UNITS_NO_ALIASES

src/systems/si/include/units/isq/si/amount_of_substance.h

@@ -46,12 +46,16 @@ using amount_of_substance = quantity<dim_amount_of_substance, U, Rep>;
 inline namespace literals {
 
 // mol
-constexpr auto operator"" _q_mol(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return amount_of_substance<mole, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_mol(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return amount_of_substance<mole, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_mol(long double l) { return amount_of_substance<mole, long double>(l); }
 
 }  // namespace literals
 
-#endif // UNITS_NO_LITERALS
+#endif  // UNITS_NO_LITERALS
 
 #ifndef UNITS_NO_REFERENCES
 
@@ -67,7 +71,7 @@ using namespace amount_of_substance_references;
 
 }  // namespace references
 
-#endif // UNITS_NO_REFERENCES
+#endif  // UNITS_NO_REFERENCES
 
 }  // namespace units::isq::si
 
@@ -75,8 +79,9 @@ using namespace amount_of_substance_references;
 
 namespace units::aliases::isq::si::inline amount_of_substance {
 
-template<Representation Rep = double> using mol = units::isq::si::amount_of_substance<units::isq::si::mole, Rep>;
+template<Representation Rep = double>
+using mol = units::isq::si::amount_of_substance<units::isq::si::mole, Rep>;
 
 }  // namespace units::aliases::isq::si::inline amount_of_substance
 
-#endif // UNITS_NO_ALIASES
+#endif  // UNITS_NO_ALIASES

src/systems/si/include/units/isq/si/angular_velocity.h

@@ -36,7 +36,8 @@ namespace units::isq::si {
 
 struct radian_per_second : named_unit<radian_per_second, basic_symbol_text{"ω", "w"}, no_prefix> {};
 
-struct dim_angular_velocity : isq::dim_angular_velocity<dim_angular_velocity, radian_per_second, dim_angle<>, dim_time> {};
+struct dim_angular_velocity :
+    isq::dim_angular_velocity<dim_angular_velocity, radian_per_second, dim_angle<>, dim_time> {};
 
 template<UnitOf<dim_angular_velocity> U, Representation Rep = double>
 using angular_velocity = quantity<dim_angular_velocity, U, Rep>;
@@ -46,12 +47,16 @@ using angular_velocity = quantity<dim_angular_velocity, U, Rep>;
 inline namespace literals {
 
 // rad / s
-constexpr auto operator"" _q_rad_per_s(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return angular_velocity<radian_per_second, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_rad_per_s(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return angular_velocity<radian_per_second, std::int64_t>(static_cast<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
 
-#endif // UNITS_NO_LITERALS
+#endif  // UNITS_NO_LITERALS
 
 }  // namespace units::isq::si
 
@@ -59,8 +64,9 @@ constexpr auto operator"" _q_rad_per_s(long double l) { return angular_velocity<
 
 namespace units::aliases::isq::si::inline angular_velocity {
 
-template<Representation Rep = double> using rad_per_s = units::isq::si::angular_velocity<units::isq::si::radian_per_second, Rep>;
+template<Representation Rep = double>
+using rad_per_s = units::isq::si::angular_velocity<units::isq::si::radian_per_second, Rep>;
 
 }  // namespace units::aliases::isq::si::inline angular_velocity
 
-#endif // UNITS_NO_ALIASES
+#endif  // UNITS_NO_ALIASES

src/systems/si/include/units/isq/si/area.h

@@ -68,96 +68,184 @@ using area = quantity<dim_area, U, Rep>;
 inline namespace literals {
 
 // m2
-constexpr auto operator"" _q_m2(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return area<square_metre, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_m2(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return area<square_metre, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_m2(long double l) { return area<square_metre, long double>(l); }
 
 // ym2
-constexpr auto operator"" _q_ym2(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return area<square_yoctometre, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_ym2(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return area<square_yoctometre, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_ym2(long double l) { return area<square_yoctometre, long double>(l); }
 
 // zm2
-constexpr auto operator"" _q_zm2(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return area<square_zeptometre, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_zm2(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return area<square_zeptometre, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_zm2(long double l) { return area<square_zeptometre, long double>(l); }
 
 // am2
-constexpr auto operator"" _q_am2(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return area<square_attometre, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_am2(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return area<square_attometre, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_am2(long double l) { return area<square_attometre, long double>(l); }
 
 // fm2
-constexpr auto operator"" _q_fm2(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return area<square_femtometre, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_fm2(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return area<square_femtometre, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_fm2(long double l) { return area<square_femtometre, long double>(l); }
 
 // pm2
-constexpr auto operator"" _q_pm2(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return area<square_picometre, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_pm2(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return area<square_picometre, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_pm2(long double l) { return area<square_picometre, long double>(l); }
 
 // nm2
-constexpr auto operator"" _q_nm2(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return area<square_nanometre, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_nm2(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return area<square_nanometre, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_nm2(long double l) { return area<square_nanometre, long double>(l); }
 
 // um2
-constexpr auto operator"" _q_um2(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return area<square_micrometre, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_um2(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return area<square_micrometre, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_um2(long double l) { return area<square_micrometre, long double>(l); }
 
 // mm2
-constexpr auto operator"" _q_mm2(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return area<square_millimetre, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_mm2(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return area<square_millimetre, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_mm2(long double l) { return area<square_millimetre, long double>(l); }
 
 // cm2
-constexpr auto operator"" _q_cm2(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return area<square_centimetre, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_cm2(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return area<square_centimetre, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_cm2(long double l) { return area<square_centimetre, long double>(l); }
 
 // dm2
-constexpr auto operator"" _q_dm2(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return area<square_decimetre, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_dm2(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return area<square_decimetre, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_dm2(long double l) { return area<square_decimetre, long double>(l); }
 
 // dam2
-constexpr auto operator"" _q_dam2(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return area<square_decametre, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_dam2(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return area<square_decametre, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_dam2(long double l) { return area<square_decametre, long double>(l); }
 
 // hm2
-constexpr auto operator"" _q_hm2(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return area<square_hectometre, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_hm2(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return area<square_hectometre, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_hm2(long double l) { return area<square_hectometre, long double>(l); }
 
 // km2
-constexpr auto operator"" _q_km2(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return area<square_kilometre, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_km2(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return area<square_kilometre, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_km2(long double l) { return area<square_kilometre, long double>(l); }
 
 // Mm2
-constexpr auto operator"" _q_Mm2(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return area<square_megametre, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_Mm2(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return area<square_megametre, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_Mm2(long double l) { return area<square_megametre, long double>(l); }
 
 // Gm2
-constexpr auto operator"" _q_Gm2(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return area<square_gigametre, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_Gm2(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return area<square_gigametre, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_Gm2(long double l) { return area<square_gigametre, long double>(l); }
 
 // Tm2
-constexpr auto operator"" _q_Tm2(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return area<square_terametre, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_Tm2(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return area<square_terametre, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_Tm2(long double l) { return area<square_terametre, long double>(l); }
 
 // Pm2
-constexpr auto operator"" _q_Pm2(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return area<square_petametre, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_Pm2(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return area<square_petametre, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_Pm2(long double l) { return area<square_petametre, long double>(l); }
 
 // Em2
-constexpr auto operator"" _q_Em2(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return area<square_exametre, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_Em2(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return area<square_exametre, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_Em2(long double l) { return area<square_exametre, long double>(l); }
 
 // Zm2
-constexpr auto operator"" _q_Zm2(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return area<square_zettametre, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_Zm2(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return area<square_zettametre, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_Zm2(long double l) { return area<square_zettametre, long double>(l); }
 
 // Ym2
-constexpr auto operator"" _q_Ym2(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return area<square_yottametre, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_Ym2(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return area<square_yottametre, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_Ym2(long double l) { return area<square_yottametre, long double>(l); }
 
 // ha
-constexpr auto operator"" _q_ha(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return area<hectare, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_ha(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return area<hectare, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_ha(long double l) { return area<hectare, long double>(l); }
 
 }  // namespace literals
 
-#endif // UNITS_NO_LITERALS
+#endif  // UNITS_NO_LITERALS
 
 #ifndef UNITS_NO_REFERENCES
 
@@ -195,7 +283,7 @@ using namespace area_references;
 
 }  // namespace references
 
-#endif // UNITS_NO_REFERENCES
+#endif  // UNITS_NO_REFERENCES
 
 }  // namespace units::isq::si
 
@@ -203,30 +291,52 @@ using namespace area_references;
 
 namespace units::aliases::isq::si::inline area {
 
-template<Representation Rep = double> using m2 = units::isq::si::area<units::isq::si::square_metre, Rep>;
-template<Representation Rep = double> using ym2 = units::isq::si::area<units::isq::si::square_yoctometre, Rep>;
-template<Representation Rep = double> using zm2 = units::isq::si::area<units::isq::si::square_zeptometre, Rep>;
-template<Representation Rep = double> using am2 = units::isq::si::area<units::isq::si::square_attometre, Rep>;
-template<Representation Rep = double> using fm2 = units::isq::si::area<units::isq::si::square_femtometre, Rep>;
-template<Representation Rep = double> using pm2 = units::isq::si::area<units::isq::si::square_picometre, Rep>;
-template<Representation Rep = double> using nm2 = units::isq::si::area<units::isq::si::square_nanometre, Rep>;
-template<Representation Rep = double> using um2 = units::isq::si::area<units::isq::si::square_micrometre, Rep>;
-template<Representation Rep = double> using mm2 = units::isq::si::area<units::isq::si::square_millimetre, Rep>;
-template<Representation Rep = double> using cm2 = units::isq::si::area<units::isq::si::square_centimetre, Rep>;
-template<Representation Rep = double> using dm2 = units::isq::si::area<units::isq::si::square_decimetre, Rep>;
-template<Representation Rep = double> using dam2 = units::isq::si::area<units::isq::si::square_decametre, Rep>;
-template<Representation Rep = double> using hm2 = units::isq::si::area<units::isq::si::square_hectometre, Rep>;
-template<Representation Rep = double> using km2 = units::isq::si::area<units::isq::si::square_kilometre, Rep>;
-template<Representation Rep = double> using Mm2 = units::isq::si::area<units::isq::si::square_megametre, Rep>;
-template<Representation Rep = double> using Gm2 = units::isq::si::area<units::isq::si::square_gigametre, Rep>;
-template<Representation Rep = double> using Tm2 = units::isq::si::area<units::isq::si::square_terametre, Rep>;
-template<Representation Rep = double> using Pm2 = units::isq::si::area<units::isq::si::square_petametre, Rep>;
-template<Representation Rep = double> using Em2 = units::isq::si::area<units::isq::si::square_exametre, Rep>;
-template<Representation Rep = double> using Zm2 = units::isq::si::area<units::isq::si::square_zettametre, Rep>;
-template<Representation Rep = double> using Ym2 = units::isq::si::area<units::isq::si::square_yottametre, Rep>;
+template<Representation Rep = double>
+using m2 = units::isq::si::area<units::isq::si::square_metre, Rep>;
+template<Representation Rep = double>
+using ym2 = units::isq::si::area<units::isq::si::square_yoctometre, Rep>;
+template<Representation Rep = double>
+using zm2 = units::isq::si::area<units::isq::si::square_zeptometre, Rep>;
+template<Representation Rep = double>
+using am2 = units::isq::si::area<units::isq::si::square_attometre, Rep>;
+template<Representation Rep = double>
+using fm2 = units::isq::si::area<units::isq::si::square_femtometre, Rep>;
+template<Representation Rep = double>
+using pm2 = units::isq::si::area<units::isq::si::square_picometre, Rep>;
+template<Representation Rep = double>
+using nm2 = units::isq::si::area<units::isq::si::square_nanometre, Rep>;
+template<Representation Rep = double>
+using um2 = units::isq::si::area<units::isq::si::square_micrometre, Rep>;
+template<Representation Rep = double>
+using mm2 = units::isq::si::area<units::isq::si::square_millimetre, Rep>;
+template<Representation Rep = double>
+using cm2 = units::isq::si::area<units::isq::si::square_centimetre, Rep>;
+template<Representation Rep = double>
+using dm2 = units::isq::si::area<units::isq::si::square_decimetre, Rep>;
+template<Representation Rep = double>
+using dam2 = units::isq::si::area<units::isq::si::square_decametre, Rep>;
+template<Representation Rep = double>
+using hm2 = units::isq::si::area<units::isq::si::square_hectometre, Rep>;
+template<Representation Rep = double>
+using km2 = units::isq::si::area<units::isq::si::square_kilometre, Rep>;
+template<Representation Rep = double>
+using Mm2 = units::isq::si::area<units::isq::si::square_megametre, Rep>;
+template<Representation Rep = double>
+using Gm2 = units::isq::si::area<units::isq::si::square_gigametre, Rep>;
+template<Representation Rep = double>
+using Tm2 = units::isq::si::area<units::isq::si::square_terametre, Rep>;
+template<Representation Rep = double>
+using Pm2 = units::isq::si::area<units::isq::si::square_petametre, Rep>;
+template<Representation Rep = double>
+using Em2 = units::isq::si::area<units::isq::si::square_exametre, Rep>;
+template<Representation Rep = double>
+using Zm2 = units::isq::si::area<units::isq::si::square_zettametre, Rep>;
+template<Representation Rep = double>
+using Ym2 = units::isq::si::area<units::isq::si::square_yottametre, Rep>;
 
-template<Representation Rep = double> using ha = units::isq::si::area<units::isq::si::hectare, Rep>;
+template<Representation Rep = double>
+using ha = units::isq::si::area<units::isq::si::hectare, Rep>;
 
 }  // namespace units::aliases::isq::si::inline area
 
-#endif // UNITS_NO_ALIASES
+#endif  // UNITS_NO_ALIASES

src/systems/si/include/units/isq/si/capacitance.h

@@ -30,8 +30,8 @@
 // IWYU pragma: end_exports
 
 #include <units/isq/si/electric_charge.h>
-#include <units/isq/si/voltage.h>
 #include <units/isq/si/prefixes.h>
+#include <units/isq/si/voltage.h>
 #include <units/unit.h>
 
 namespace units::isq::si {
@@ -68,92 +68,176 @@ using capacitance = quantity<dim_capacitance, U, Rep>;
 inline namespace literals {
 
 // F
-constexpr auto operator"" _q_F(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return capacitance<farad, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_F(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return capacitance<farad, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_F(long double l) { return capacitance<farad, long double>(l); }
 
 // yF
-constexpr auto operator"" _q_yF(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return capacitance<yoctofarad, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_yF(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return capacitance<yoctofarad, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_yF(long double l) { return capacitance<yoctofarad, long double>(l); }
 
 // zF
-constexpr auto operator"" _q_zF(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return capacitance<zeptofarad, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_zF(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return capacitance<zeptofarad, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_zF(long double l) { return capacitance<zeptofarad, long double>(l); }
 
 // aF
-constexpr auto operator"" _q_aF(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return capacitance<attofarad, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_aF(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return capacitance<attofarad, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_aF(long double l) { return capacitance<attofarad, long double>(l); }
 
 // fF
-constexpr auto operator"" _q_fF(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return capacitance<femtofarad, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_fF(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return capacitance<femtofarad, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_fF(long double l) { return capacitance<femtofarad, long double>(l); }
 
 // pF
-constexpr auto operator"" _q_pF(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return capacitance<picofarad, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_pF(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return capacitance<picofarad, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_pF(long double l) { return capacitance<picofarad, long double>(l); }
 
 // nF
-constexpr auto operator"" _q_nF(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return capacitance<nanofarad, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_nF(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return capacitance<nanofarad, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_nF(long double l) { return capacitance<nanofarad, long double>(l); }
 
 // uF
-constexpr auto operator"" _q_uF(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return capacitance<microfarad, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_uF(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return capacitance<microfarad, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_uF(long double l) { return capacitance<microfarad, long double>(l); }
 
 // mF
-constexpr auto operator"" _q_mF(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return capacitance<millifarad, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_mF(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return capacitance<millifarad, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_mF(long double l) { return capacitance<millifarad, long double>(l); }
 
 // cF
-constexpr auto operator"" _q_cF(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return capacitance<centifarad, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_cF(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return capacitance<centifarad, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_cF(long double l) { return capacitance<centifarad, long double>(l); }
 
 // dF
-constexpr auto operator"" _q_dF(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return capacitance<decifarad, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_dF(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return capacitance<decifarad, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_dF(long double l) { return capacitance<decifarad, long double>(l); }
 
 // daF
-constexpr auto operator"" _q_daF(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return capacitance<decafarad, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_daF(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return capacitance<decafarad, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_daF(long double l) { return capacitance<decafarad, long double>(l); }
 
 // hF
-constexpr auto operator"" _q_hF(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return capacitance<hectofarad, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_hF(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return capacitance<hectofarad, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_hF(long double l) { return capacitance<hectofarad, long double>(l); }
 
 // kF
-constexpr auto operator"" _q_kF(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return capacitance<kilofarad, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_kF(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return capacitance<kilofarad, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_kF(long double l) { return capacitance<kilofarad, long double>(l); }
 
 // MF
-constexpr auto operator"" _q_MF(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return capacitance<megafarad, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_MF(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return capacitance<megafarad, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_MF(long double l) { return capacitance<megafarad, long double>(l); }
 
 // GF
-constexpr auto operator"" _q_GF(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return capacitance<gigafarad, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_GF(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return capacitance<gigafarad, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_GF(long double l) { return capacitance<gigafarad, long double>(l); }
 
 // TF
-constexpr auto operator"" _q_TF(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return capacitance<terafarad, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_TF(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return capacitance<terafarad, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_TF(long double l) { return capacitance<terafarad, long double>(l); }
 
 // PF
-constexpr auto operator"" _q_PF(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return capacitance<petafarad, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_PF(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return capacitance<petafarad, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_PF(long double l) { return capacitance<petafarad, long double>(l); }
 
 // EF
-constexpr auto operator"" _q_EF(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return capacitance<exafarad, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_EF(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return capacitance<exafarad, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_EF(long double l) { return capacitance<exafarad, long double>(l); }
 
 // ZF
-constexpr auto operator"" _q_ZF(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return capacitance<zettafarad, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_ZF(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return capacitance<zettafarad, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_ZF(long double l) { return capacitance<zettafarad, long double>(l); }
 
 // YF
-constexpr auto operator"" _q_YF(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return capacitance<yottafarad, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_YF(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return capacitance<yottafarad, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_YF(long double l) { return capacitance<yottafarad, long double>(l); }
 
 }  // namespace literals
 
-#endif // UNITS_NO_LITERALS
+#endif  // UNITS_NO_LITERALS
 
 #ifndef UNITS_NO_REFERENCES
 
@@ -189,7 +273,7 @@ using namespace capacitance_references;
 
 }  // namespace references
 
-#endif // UNITS_NO_REFERENCES
+#endif  // UNITS_NO_REFERENCES
 
 }  // namespace units::isq::si
 
@@ -197,28 +281,49 @@ using namespace capacitance_references;
 
 namespace units::aliases::isq::si::inline capacitance {
 
-template<Representation Rep = double> using F = units::isq::si::capacitance<units::isq::si::farad, Rep>;
-template<Representation Rep = double> using yF = units::isq::si::capacitance<units::isq::si::yoctofarad, Rep>;
-template<Representation Rep = double> using zF = units::isq::si::capacitance<units::isq::si::zeptofarad, Rep>;
-template<Representation Rep = double> using aF = units::isq::si::capacitance<units::isq::si::attofarad, Rep>;
-template<Representation Rep = double> using fF = units::isq::si::capacitance<units::isq::si::femtofarad, Rep>;
-template<Representation Rep = double> using pF = units::isq::si::capacitance<units::isq::si::picofarad, Rep>;
-template<Representation Rep = double> using nF = units::isq::si::capacitance<units::isq::si::nanofarad, Rep>;
-template<Representation Rep = double> using uF = units::isq::si::capacitance<units::isq::si::microfarad, Rep>;
-template<Representation Rep = double> using mF = units::isq::si::capacitance<units::isq::si::millifarad, Rep>;
-template<Representation Rep = double> using cF = units::isq::si::capacitance<units::isq::si::centifarad, Rep>;
-template<Representation Rep = double> using dF = units::isq::si::capacitance<units::isq::si::decifarad, Rep>;
-template<Representation Rep = double> using daF = units::isq::si::capacitance<units::isq::si::decafarad, Rep>;
-template<Representation Rep = double> using hF = units::isq::si::capacitance<units::isq::si::hectofarad, Rep>;
-template<Representation Rep = double> using kF = units::isq::si::capacitance<units::isq::si::kilofarad, Rep>;
-template<Representation Rep = double> using MF = units::isq::si::capacitance<units::isq::si::megafarad, Rep>;
-template<Representation Rep = double> using GF = units::isq::si::capacitance<units::isq::si::gigafarad, Rep>;
-template<Representation Rep = double> using TF = units::isq::si::capacitance<units::isq::si::terafarad, Rep>;
-template<Representation Rep = double> using PF = units::isq::si::capacitance<units::isq::si::petafarad, Rep>;
-template<Representation Rep = double> using EF = units::isq::si::capacitance<units::isq::si::exafarad, Rep>;
-template<Representation Rep = double> using ZF = units::isq::si::capacitance<units::isq::si::zettafarad, Rep>;
-template<Representation Rep = double> using YF = units::isq::si::capacitance<units::isq::si::yottafarad, Rep>;
+template<Representation Rep = double>
+using F = units::isq::si::capacitance<units::isq::si::farad, Rep>;
+template<Representation Rep = double>
+using yF = units::isq::si::capacitance<units::isq::si::yoctofarad, Rep>;
+template<Representation Rep = double>
+using zF = units::isq::si::capacitance<units::isq::si::zeptofarad, Rep>;
+template<Representation Rep = double>
+using aF = units::isq::si::capacitance<units::isq::si::attofarad, Rep>;
+template<Representation Rep = double>
+using fF = units::isq::si::capacitance<units::isq::si::femtofarad, Rep>;
+template<Representation Rep = double>
+using pF = units::isq::si::capacitance<units::isq::si::picofarad, Rep>;
+template<Representation Rep = double>
+using nF = units::isq::si::capacitance<units::isq::si::nanofarad, Rep>;
+template<Representation Rep = double>
+using uF = units::isq::si::capacitance<units::isq::si::microfarad, Rep>;
+template<Representation Rep = double>
+using mF = units::isq::si::capacitance<units::isq::si::millifarad, Rep>;
+template<Representation Rep = double>
+using cF = units::isq::si::capacitance<units::isq::si::centifarad, Rep>;
+template<Representation Rep = double>
+using dF = units::isq::si::capacitance<units::isq::si::decifarad, Rep>;
+template<Representation Rep = double>
+using daF = units::isq::si::capacitance<units::isq::si::decafarad, Rep>;
+template<Representation Rep = double>
+using hF = units::isq::si::capacitance<units::isq::si::hectofarad, Rep>;
+template<Representation Rep = double>
+using kF = units::isq::si::capacitance<units::isq::si::kilofarad, Rep>;
+template<Representation Rep = double>
+using MF = units::isq::si::capacitance<units::isq::si::megafarad, Rep>;
+template<Representation Rep = double>
+using GF = units::isq::si::capacitance<units::isq::si::gigafarad, Rep>;
+template<Representation Rep = double>
+using TF = units::isq::si::capacitance<units::isq::si::terafarad, Rep>;
+template<Representation Rep = double>
+using PF = units::isq::si::capacitance<units::isq::si::petafarad, Rep>;
+template<Representation Rep = double>
+using EF = units::isq::si::capacitance<units::isq::si::exafarad, Rep>;
+template<Representation Rep = double>
+using ZF = units::isq::si::capacitance<units::isq::si::zettafarad, Rep>;
+template<Representation Rep = double>
+using YF = units::isq::si::capacitance<units::isq::si::yottafarad, Rep>;
 
 }  // namespace units::aliases::isq::si::inline capacitance
 
-#endif // UNITS_NO_ALIASES
+#endif  // UNITS_NO_ALIASES

src/systems/si/include/units/isq/si/concentration.h

@@ -28,14 +28,15 @@
 #include <units/symbol_text.h>
 // IWYU pragma: end_exports
 
-#include <units/isq/si/length.h>
 #include <units/isq/si/amount_of_substance.h>
+#include <units/isq/si/length.h>
 #include <units/unit.h>
 
 namespace units::isq::si {
 
 struct mol_per_metre_cub : unit<mol_per_metre_cub> {};
-struct dim_concentration : isq::dim_concentration<dim_concentration, mol_per_metre_cub, dim_amount_of_substance, dim_length> {};
+struct dim_concentration :
+    isq::dim_concentration<dim_concentration, mol_per_metre_cub, dim_amount_of_substance, dim_length> {};
 
 template<UnitOf<dim_concentration> U, Representation Rep = double>
 using concentration = quantity<dim_concentration, U, Rep>;
@@ -45,12 +46,16 @@ using concentration = quantity<dim_concentration, U, Rep>;
 inline namespace literals {
 
 // mol/m³
-constexpr auto operator"" _q_mol_per_m3(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return concentration<mol_per_metre_cub, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_mol_per_m3(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return concentration<mol_per_metre_cub, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_mol_per_m3(long double l) { return concentration<mol_per_metre_cub, long double>(l); }
 
 }  // namespace literals
 
-#endif // UNITS_NO_LITERALS
+#endif  // UNITS_NO_LITERALS
 
 }  // namespace units::isq::si
 
@@ -58,8 +63,9 @@ constexpr auto operator"" _q_mol_per_m3(long double l) { return concentration<mo
 
 namespace units::aliases::isq::si::inline concentration {
 
-template<Representation Rep = double> using mol_per_m3 = units::isq::si::concentration<units::isq::si::mol_per_metre_cub, Rep>;
+template<Representation Rep = double>
+using mol_per_m3 = units::isq::si::concentration<units::isq::si::mol_per_metre_cub, Rep>;
 
 }  // namespace units::aliases::isq::si::inline concentration
 
-#endif // UNITS_NO_ALIASES
+#endif  // UNITS_NO_ALIASES

src/systems/si/include/units/isq/si/conductance.h

@@ -29,8 +29,8 @@
 #include <units/symbol_text.h>
 // IWYU pragma: end_exports
 
-#include <units/isq/si/resistance.h>
 #include <units/isq/si/prefixes.h>
+#include <units/isq/si/resistance.h>
 #include <units/unit.h>
 
 namespace units::isq::si {
@@ -63,76 +63,144 @@ using conductance = quantity<dim_conductance, U, Rep>;
 inline namespace literals {
 
 // R
-constexpr auto operator"" _q_S(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return conductance<siemens, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_S(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return conductance<siemens, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_S(long double l) { return conductance<siemens, long double>(l); }
 
 // yS
-constexpr auto operator"" _q_yS(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return conductance<yoctosiemens, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_yS(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return conductance<yoctosiemens, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_yS(long double l) { return conductance<yoctosiemens, long double>(l); }
 
 // zS
-constexpr auto operator"" _q_zS(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return conductance<zeptosiemens, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_zS(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return conductance<zeptosiemens, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_zS(long double l) { return conductance<zeptosiemens, long double>(l); }
 
 // aS
-constexpr auto operator"" _q_aS(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return conductance<attosiemens, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_aS(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return conductance<attosiemens, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_aS(long double l) { return conductance<attosiemens, long double>(l); }
 
 // fS
-constexpr auto operator"" _q_fS(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return conductance<femtosiemens, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_fS(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return conductance<femtosiemens, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_fS(long double l) { return conductance<femtosiemens, long double>(l); }
 
 // pS
-constexpr auto operator"" _q_pS(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return conductance<picosiemens, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_pS(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return conductance<picosiemens, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_pS(long double l) { return conductance<picosiemens, long double>(l); }
 
 // nS
-constexpr auto operator"" _q_nS(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return conductance<nanosiemens, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_nS(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return conductance<nanosiemens, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_nS(long double l) { return conductance<nanosiemens, long double>(l); }
 
 // µS
-constexpr auto operator"" _q_uS(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return conductance<microsiemens, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_uS(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return conductance<microsiemens, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_uS(long double l) { return conductance<microsiemens, long double>(l); }
 
 // mS
-constexpr auto operator"" _q_mS(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return conductance<millisiemens, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_mS(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return conductance<millisiemens, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_mS(long double l) { return conductance<millisiemens, long double>(l); }
 
 // kS
-constexpr auto operator"" _q_kS(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return conductance<kilosiemens, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_kS(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return conductance<kilosiemens, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_kS(long double l) { return conductance<kilosiemens, long double>(l); }
 
 // MS
-constexpr auto operator"" _q_MS(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return conductance<megasiemens, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_MS(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return conductance<megasiemens, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_MS(long double l) { return conductance<megasiemens, long double>(l); }
 
 // GS
-constexpr auto operator"" _q_GS(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return conductance<gigasiemens, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_GS(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return conductance<gigasiemens, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_GS(long double l) { return conductance<gigasiemens, long double>(l); }
 
 // TS
-constexpr auto operator"" _q_TS(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return conductance<terasiemens, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_TS(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return conductance<terasiemens, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_TS(long double l) { return conductance<terasiemens, long double>(l); }
 
 // PS
-constexpr auto operator"" _q_PS(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return conductance<petasiemens, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_PS(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return conductance<petasiemens, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_PS(long double l) { return conductance<petasiemens, long double>(l); }
 
 // ES
-constexpr auto operator"" _q_ES(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return conductance<exasiemens, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_ES(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return conductance<exasiemens, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_ES(long double l) { return conductance<exasiemens, long double>(l); }
 
 // ZS
-constexpr auto operator"" _q_ZS(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return conductance<zettasiemens, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_ZS(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return conductance<zettasiemens, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_ZS(long double l) { return conductance<zettasiemens, long double>(l); }
 
 // YS
-constexpr auto operator"" _q_YS(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return conductance<yottasiemens, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_YS(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return conductance<yottasiemens, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_YS(long double l) { return conductance<yottasiemens, long double>(l); }
 
 }  // namespace literals
 
-#endif // UNITS_NO_LITERALS
+#endif  // UNITS_NO_LITERALS
 
 #ifndef UNITS_NO_REFERENCES
 
@@ -164,7 +232,7 @@ using namespace conductance_references;
 
 }  // namespace references
 
-#endif // UNITS_NO_REFERENCES
+#endif  // UNITS_NO_REFERENCES
 
 }  // namespace units::isq::si
 
@@ -172,24 +240,41 @@ using namespace conductance_references;
 
 namespace units::aliases::isq::si::inline conductance {
 
-template<Representation Rep = double> using S = units::isq::si::conductance<units::isq::si::siemens, Rep>;
-template<Representation Rep = double> using yS = units::isq::si::conductance<units::isq::si::yoctosiemens, Rep>;
-template<Representation Rep = double> using zS = units::isq::si::conductance<units::isq::si::zeptosiemens, Rep>;
-template<Representation Rep = double> using aS = units::isq::si::conductance<units::isq::si::attosiemens, Rep>;
-template<Representation Rep = double> using fS = units::isq::si::conductance<units::isq::si::femtosiemens, Rep>;
-template<Representation Rep = double> using pS = units::isq::si::conductance<units::isq::si::picosiemens, Rep>;
-template<Representation Rep = double> using nS = units::isq::si::conductance<units::isq::si::nanosiemens, Rep>;
-template<Representation Rep = double> using uS = units::isq::si::conductance<units::isq::si::microsiemens, Rep>;
-template<Representation Rep = double> using mS = units::isq::si::conductance<units::isq::si::millisiemens, Rep>;
-template<Representation Rep = double> using kS = units::isq::si::conductance<units::isq::si::kilosiemens, Rep>;
-template<Representation Rep = double> using MS = units::isq::si::conductance<units::isq::si::megasiemens, Rep>;
-template<Representation Rep = double> using GS = units::isq::si::conductance<units::isq::si::gigasiemens, Rep>;
-template<Representation Rep = double> using TS = units::isq::si::conductance<units::isq::si::terasiemens, Rep>;
-template<Representation Rep = double> using PS = units::isq::si::conductance<units::isq::si::petasiemens, Rep>;
-template<Representation Rep = double> using ES = units::isq::si::conductance<units::isq::si::exasiemens, Rep>;
-template<Representation Rep = double> using ZS = units::isq::si::conductance<units::isq::si::zettasiemens, Rep>;
-template<Representation Rep = double> using YS = units::isq::si::conductance<units::isq::si::yottasiemens, Rep>;
+template<Representation Rep = double>
+using S = units::isq::si::conductance<units::isq::si::siemens, Rep>;
+template<Representation Rep = double>
+using yS = units::isq::si::conductance<units::isq::si::yoctosiemens, Rep>;
+template<Representation Rep = double>
+using zS = units::isq::si::conductance<units::isq::si::zeptosiemens, Rep>;
+template<Representation Rep = double>
+using aS = units::isq::si::conductance<units::isq::si::attosiemens, Rep>;
+template<Representation Rep = double>
+using fS = units::isq::si::conductance<units::isq::si::femtosiemens, Rep>;
+template<Representation Rep = double>
+using pS = units::isq::si::conductance<units::isq::si::picosiemens, Rep>;
+template<Representation Rep = double>
+using nS = units::isq::si::conductance<units::isq::si::nanosiemens, Rep>;
+template<Representation Rep = double>
+using uS = units::isq::si::conductance<units::isq::si::microsiemens, Rep>;
+template<Representation Rep = double>
+using mS = units::isq::si::conductance<units::isq::si::millisiemens, Rep>;
+template<Representation Rep = double>
+using kS = units::isq::si::conductance<units::isq::si::kilosiemens, Rep>;
+template<Representation Rep = double>
+using MS = units::isq::si::conductance<units::isq::si::megasiemens, Rep>;
+template<Representation Rep = double>
+using GS = units::isq::si::conductance<units::isq::si::gigasiemens, Rep>;
+template<Representation Rep = double>
+using TS = units::isq::si::conductance<units::isq::si::terasiemens, Rep>;
+template<Representation Rep = double>
+using PS = units::isq::si::conductance<units::isq::si::petasiemens, Rep>;
+template<Representation Rep = double>
+using ES = units::isq::si::conductance<units::isq::si::exasiemens, Rep>;
+template<Representation Rep = double>
+using ZS = units::isq::si::conductance<units::isq::si::zettasiemens, Rep>;
+template<Representation Rep = double>
+using YS = units::isq::si::conductance<units::isq::si::yottasiemens, Rep>;
 
 }  // namespace units::aliases::isq::si::inline conductance
 
-#endif // UNITS_NO_ALIASES
+#endif  // UNITS_NO_ALIASES

src/systems/si/include/units/isq/si/density.h

@@ -28,8 +28,8 @@
 #include <units/symbol_text.h>
 // IWYU pragma: end_exports
 
-#include <units/isq/si/mass.h>
 #include <units/isq/si/length.h>
+#include <units/isq/si/mass.h>
 #include <units/isq/si/prefixes.h>
 #include <units/unit.h>
 
@@ -47,12 +47,16 @@ using density = quantity<dim_density, U, Rep>;
 inline namespace literals {
 
 // kg / m³
-constexpr auto operator"" _q_kg_per_m3(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return density<kilogram_per_metre_cub, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_kg_per_m3(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return density<kilogram_per_metre_cub, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_kg_per_m3(long double l) { return density<kilogram_per_metre_cub, long double>(l); }
 
 }  // namespace literals
 
-#endif // UNITS_NO_LITERALS
+#endif  // UNITS_NO_LITERALS
 
 }  // namespace units::isq::si
 
@@ -60,8 +64,9 @@ constexpr auto operator"" _q_kg_per_m3(long double l) { return density<kilogram_
 
 namespace units::aliases::isq::si::inline density {
 
-template<Representation Rep = double> using kg_per_m3 = units::isq::si::density<units::isq::si::kilogram_per_metre_cub, Rep>;
+template<Representation Rep = double>
+using kg_per_m3 = units::isq::si::density<units::isq::si::kilogram_per_metre_cub, Rep>;
 
 }  // namespace units::aliases::isq::si::inline density
 
-#endif // UNITS_NO_ALIASES
+#endif  // UNITS_NO_ALIASES

src/systems/si/include/units/isq/si/energy.h

@@ -53,7 +53,8 @@ struct exajoule : prefixed_unit<exajoule, exa, joule> {};
 struct zettajoule : prefixed_unit<zettajoule, zetta, joule> {};
 struct yottajoule : prefixed_unit<yottajoule, yotta, joule> {};
 
-// N.B. electron charge (and eV) is an exact constant: https://www.bipm.org/documents/20126/41483022/SI-Brochure-9.pdf#page=147
+// N.B. electron charge (and eV) is an exact constant:
+// https://www.bipm.org/documents/20126/41483022/SI-Brochure-9.pdf#page=147
 struct electronvolt : named_scaled_unit<electronvolt, "eV", prefix, ratio(1'602'176'634, 1'000'000'000, -19), joule> {};
 struct gigaelectronvolt : prefixed_unit<gigaelectronvolt, giga, electronvolt> {};
 
@@ -67,84 +68,160 @@ using energy = quantity<dim_energy, U, Rep>;
 inline namespace literals {
 
 // J
-constexpr auto operator"" _q_J(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return energy<joule, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_J(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return energy<joule, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_J(long double l) { return energy<joule, long double>(l); }
 
 // yJ
-constexpr auto operator"" _q_yJ(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return energy<yoctojoule, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_yJ(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return energy<yoctojoule, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_yJ(long double l) { return energy<yoctojoule, long double>(l); }
 
 // zJ
-constexpr auto operator"" _q_zJ(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return energy<zeptojoule, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_zJ(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return energy<zeptojoule, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_zJ(long double l) { return energy<zeptojoule, long double>(l); }
 
 // aJ
-constexpr auto operator"" _q_aJ(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return energy<attojoule, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_aJ(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return energy<attojoule, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_aJ(long double l) { return energy<attojoule, long double>(l); }
 
 // fJ
-constexpr auto operator"" _q_fJ(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return energy<femtojoule, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_fJ(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return energy<femtojoule, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_fJ(long double l) { return energy<femtojoule, long double>(l); }
 
 // pJ
-constexpr auto operator"" _q_pJ(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return energy<picojoule, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_pJ(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return energy<picojoule, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_pJ(long double l) { return energy<picojoule, long double>(l); }
 
 // nJ
-constexpr auto operator"" _q_nJ(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return energy<nanojoule, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_nJ(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return energy<nanojoule, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_nJ(long double l) { return energy<nanojoule, long double>(l); }
 
 // uJ
-constexpr auto operator"" _q_uJ(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return energy<microjoule, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_uJ(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return energy<microjoule, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_uJ(long double l) { return energy<microjoule, long double>(l); }
 
 // mJ
-constexpr auto operator"" _q_mJ(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return energy<millijoule, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_mJ(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return energy<millijoule, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_mJ(long double l) { return energy<millijoule, long double>(l); }
 
 // kJ
-constexpr auto operator"" _q_kJ(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return energy<kilojoule, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_kJ(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return energy<kilojoule, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_kJ(long double l) { return energy<kilojoule, long double>(l); }
 
 // MJ
-constexpr auto operator"" _q_MJ(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return energy<megajoule, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_MJ(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return energy<megajoule, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_MJ(long double l) { return energy<megajoule, long double>(l); }
 
 // GJ
-constexpr auto operator"" _q_GJ(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return energy<gigajoule, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_GJ(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return energy<gigajoule, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_GJ(long double l) { return energy<gigajoule, long double>(l); }
 
 // TJ
-constexpr auto operator"" _q_TJ(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return energy<terajoule, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_TJ(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return energy<terajoule, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_TJ(long double l) { return energy<terajoule, long double>(l); }
 
 // PJ
-constexpr auto operator"" _q_PJ(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return energy<petajoule, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_PJ(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return energy<petajoule, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_PJ(long double l) { return energy<petajoule, long double>(l); }
 
 // EJ
-constexpr auto operator"" _q_EJ(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return energy<exajoule, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_EJ(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return energy<exajoule, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_EJ(long double l) { return energy<exajoule, long double>(l); }
 
 // ZJ
-constexpr auto operator"" _q_ZJ(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return energy<zettajoule, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_ZJ(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return energy<zettajoule, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_ZJ(long double l) { return energy<zettajoule, long double>(l); }
 
 // YJ
-constexpr auto operator"" _q_YJ(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return energy<yottajoule, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_YJ(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return energy<yottajoule, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_YJ(long double l) { return energy<yottajoule, long double>(l); }
 
 // eV
-constexpr auto operator"" _q_eV(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return energy<electronvolt, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_eV(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return energy<electronvolt, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_eV(long double l) { return energy<electronvolt, long double>(l); }
 
 // GeV
-constexpr auto operator"" _q_GeV(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return energy<gigaelectronvolt, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_GeV(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return energy<gigaelectronvolt, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_GeV(long double l) { return energy<gigaelectronvolt, long double>(l); }
 
 }  // namespace literals
 
-#endif // UNITS_NO_LITERALS
+#endif  // UNITS_NO_LITERALS
 
 #ifndef UNITS_NO_REFERENCES
 
@@ -179,7 +256,7 @@ using namespace energy_references;
 
 }  // namespace references
 
-#endif // UNITS_NO_REFERENCES
+#endif  // UNITS_NO_REFERENCES
 
 }  // namespace units::isq::si
 
@@ -187,27 +264,46 @@ using namespace energy_references;
 
 namespace units::aliases::isq::si::inline energy {
 
-template<Representation Rep = double> using J = units::isq::si::energy<units::isq::si::joule, Rep>;
-template<Representation Rep = double> using yJ = units::isq::si::energy<units::isq::si::yoctojoule, Rep>;
-template<Representation Rep = double> using zJ = units::isq::si::energy<units::isq::si::zeptojoule, Rep>;
-template<Representation Rep = double> using aJ = units::isq::si::energy<units::isq::si::attojoule, Rep>;
-template<Representation Rep = double> using fJ = units::isq::si::energy<units::isq::si::femtojoule, Rep>;
-template<Representation Rep = double> using pJ = units::isq::si::energy<units::isq::si::picojoule, Rep>;
-template<Representation Rep = double> using nJ = units::isq::si::energy<units::isq::si::nanojoule, Rep>;
-template<Representation Rep = double> using uJ = units::isq::si::energy<units::isq::si::microjoule, Rep>;
-template<Representation Rep = double> using mJ = units::isq::si::energy<units::isq::si::millijoule, Rep>;
-template<Representation Rep = double> using kJ = units::isq::si::energy<units::isq::si::kilojoule, Rep>;
-template<Representation Rep = double> using MJ = units::isq::si::energy<units::isq::si::megajoule, Rep>;
-template<Representation Rep = double> using GJ = units::isq::si::energy<units::isq::si::gigajoule, Rep>;
-template<Representation Rep = double> using TJ = units::isq::si::energy<units::isq::si::terajoule, Rep>;
-template<Representation Rep = double> using PJ = units::isq::si::energy<units::isq::si::petajoule, Rep>;
-template<Representation Rep = double> using EJ = units::isq::si::energy<units::isq::si::exajoule, Rep>;
-template<Representation Rep = double> using ZJ = units::isq::si::energy<units::isq::si::zettajoule, Rep>;
-template<Representation Rep = double> using YJ = units::isq::si::energy<units::isq::si::yottajoule, Rep>;
+template<Representation Rep = double>
+using J = units::isq::si::energy<units::isq::si::joule, Rep>;
+template<Representation Rep = double>
+using yJ = units::isq::si::energy<units::isq::si::yoctojoule, Rep>;
+template<Representation Rep = double>
+using zJ = units::isq::si::energy<units::isq::si::zeptojoule, Rep>;
+template<Representation Rep = double>
+using aJ = units::isq::si::energy<units::isq::si::attojoule, Rep>;
+template<Representation Rep = double>
+using fJ = units::isq::si::energy<units::isq::si::femtojoule, Rep>;
+template<Representation Rep = double>
+using pJ = units::isq::si::energy<units::isq::si::picojoule, Rep>;
+template<Representation Rep = double>
+using nJ = units::isq::si::energy<units::isq::si::nanojoule, Rep>;
+template<Representation Rep = double>
+using uJ = units::isq::si::energy<units::isq::si::microjoule, Rep>;
+template<Representation Rep = double>
+using mJ = units::isq::si::energy<units::isq::si::millijoule, Rep>;
+template<Representation Rep = double>
+using kJ = units::isq::si::energy<units::isq::si::kilojoule, Rep>;
+template<Representation Rep = double>
+using MJ = units::isq::si::energy<units::isq::si::megajoule, Rep>;
+template<Representation Rep = double>
+using GJ = units::isq::si::energy<units::isq::si::gigajoule, Rep>;
+template<Representation Rep = double>
+using TJ = units::isq::si::energy<units::isq::si::terajoule, Rep>;
+template<Representation Rep = double>
+using PJ = units::isq::si::energy<units::isq::si::petajoule, Rep>;
+template<Representation Rep = double>
+using EJ = units::isq::si::energy<units::isq::si::exajoule, Rep>;
+template<Representation Rep = double>
+using ZJ = units::isq::si::energy<units::isq::si::zettajoule, Rep>;
+template<Representation Rep = double>
+using YJ = units::isq::si::energy<units::isq::si::yottajoule, Rep>;
 
-template<Representation Rep = double> using eV = units::isq::si::energy<units::isq::si::electronvolt, Rep>;
-template<Representation Rep = double> using GeV = units::isq::si::energy<units::isq::si::gigaelectronvolt, Rep>;
+template<Representation Rep = double>
+using eV = units::isq::si::energy<units::isq::si::electronvolt, Rep>;
+template<Representation Rep = double>
+using GeV = units::isq::si::energy<units::isq::si::gigaelectronvolt, Rep>;
 
 }  // namespace units::aliases::isq::si::inline energy
 
-#endif // UNITS_NO_ALIASES
+#endif  // UNITS_NO_ALIASES

src/systems/si/include/units/isq/si/force.h

@@ -68,92 +68,176 @@ using force = quantity<dim_force, U, Rep>;
 inline namespace literals {
 
 // N
-constexpr auto operator"" _q_N(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return force<newton, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_N(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return force<newton, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_N(long double l) { return force<newton, long double>(l); }
 
 // yN
-constexpr auto operator"" _q_yN(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return force<yoctonewton, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_yN(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return force<yoctonewton, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_yN(long double l) { return force<yoctonewton, long double>(l); }
 
 // zN
-constexpr auto operator"" _q_zN(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return force<zeptonewton, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_zN(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return force<zeptonewton, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_zN(long double l) { return force<zeptonewton, long double>(l); }
 
 // aN
-constexpr auto operator"" _q_aN(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return force<attonewton, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_aN(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return force<attonewton, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_aN(long double l) { return force<attonewton, long double>(l); }
 
 // fN
-constexpr auto operator"" _q_fN(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return force<femtonewton, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_fN(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return force<femtonewton, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_fN(long double l) { return force<femtonewton, long double>(l); }
 
 // pN
-constexpr auto operator"" _q_pN(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return force<piconewton, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_pN(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return force<piconewton, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_pN(long double l) { return force<piconewton, long double>(l); }
 
 // nN
-constexpr auto operator"" _q_nN(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return force<nanonewton, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_nN(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return force<nanonewton, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_nN(long double l) { return force<nanonewton, long double>(l); }
 
 // uN
-constexpr auto operator"" _q_uN(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return force<micronewton, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_uN(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return force<micronewton, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_uN(long double l) { return force<micronewton, long double>(l); }
 
 // mN
-constexpr auto operator"" _q_mN(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return force<millinewton, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_mN(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return force<millinewton, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_mN(long double l) { return force<millinewton, long double>(l); }
 
 // cN
-constexpr auto operator"" _q_cN(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return force<centinewton, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_cN(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return force<centinewton, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_cN(long double l) { return force<centinewton, long double>(l); }
 
 // dN
-constexpr auto operator"" _q_dN(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return force<decinewton, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_dN(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return force<decinewton, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_dN(long double l) { return force<decinewton, long double>(l); }
 
 // daN
-constexpr auto operator"" _q_daN(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return force<decanewton, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_daN(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return force<decanewton, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_daN(long double l) { return force<decanewton, long double>(l); }
 
 // hN
-constexpr auto operator"" _q_hN(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return force<hectonewton, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_hN(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return force<hectonewton, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_hN(long double l) { return force<hectonewton, long double>(l); }
 
 // kN
-constexpr auto operator"" _q_kN(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return force<kilonewton, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_kN(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return force<kilonewton, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_kN(long double l) { return force<kilonewton, long double>(l); }
 
 // MN
-constexpr auto operator"" _q_MN(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return force<meganewton, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_MN(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return force<meganewton, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_MN(long double l) { return force<meganewton, long double>(l); }
 
 // GN
-constexpr auto operator"" _q_GN(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return force<giganewton, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_GN(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return force<giganewton, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_GN(long double l) { return force<giganewton, long double>(l); }
 
 // TN
-constexpr auto operator"" _q_TN(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return force<teranewton, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_TN(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return force<teranewton, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_TN(long double l) { return force<teranewton, long double>(l); }
 
 // PN
-constexpr auto operator"" _q_PN(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return force<petanewton, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_PN(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return force<petanewton, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_PN(long double l) { return force<petanewton, long double>(l); }
 
 // EN
-constexpr auto operator"" _q_EN(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return force<exanewton, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_EN(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return force<exanewton, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_EN(long double l) { return force<exanewton, long double>(l); }
 
 // ZN
-constexpr auto operator"" _q_ZN(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return force<zettanewton, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_ZN(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return force<zettanewton, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_ZN(long double l) { return force<zettanewton, long double>(l); }
 
 // YN
-constexpr auto operator"" _q_YN(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return force<yottanewton, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_YN(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return force<yottanewton, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_YN(long double l) { return force<yottanewton, long double>(l); }
 
 }  // namespace literals
 
-#endif // UNITS_NO_LITERALS
+#endif  // UNITS_NO_LITERALS
 
 #ifndef UNITS_NO_REFERENCES
 
@@ -189,7 +273,7 @@ using namespace force_references;
 
 }  // namespace references
 
-#endif // UNITS_NO_REFERENCES
+#endif  // UNITS_NO_REFERENCES
 
 }  // namespace units::isq::si
 
@@ -197,28 +281,49 @@ using namespace force_references;
 
 namespace units::aliases::isq::si::inline force {
 
-template<Representation Rep = double> using N = units::isq::si::force<units::isq::si::newton, Rep>;
-template<Representation Rep = double> using yN = units::isq::si::force<units::isq::si::yoctonewton, Rep>;
-template<Representation Rep = double> using zN = units::isq::si::force<units::isq::si::zeptonewton, Rep>;
-template<Representation Rep = double> using aN = units::isq::si::force<units::isq::si::attonewton, Rep>;
-template<Representation Rep = double> using fN = units::isq::si::force<units::isq::si::femtonewton, Rep>;
-template<Representation Rep = double> using pN = units::isq::si::force<units::isq::si::piconewton, Rep>;
-template<Representation Rep = double> using nN = units::isq::si::force<units::isq::si::nanonewton, Rep>;
-template<Representation Rep = double> using uN = units::isq::si::force<units::isq::si::micronewton, Rep>;
-template<Representation Rep = double> using mN = units::isq::si::force<units::isq::si::millinewton, Rep>;
-template<Representation Rep = double> using cN = units::isq::si::force<units::isq::si::centinewton, Rep>;
-template<Representation Rep = double> using dN = units::isq::si::force<units::isq::si::decinewton, Rep>;
-template<Representation Rep = double> using daN = units::isq::si::force<units::isq::si::decanewton, Rep>;
-template<Representation Rep = double> using hN = units::isq::si::force<units::isq::si::hectonewton, Rep>;
-template<Representation Rep = double> using kN = units::isq::si::force<units::isq::si::kilonewton, Rep>;
-template<Representation Rep = double> using MN = units::isq::si::force<units::isq::si::meganewton, Rep>;
-template<Representation Rep = double> using GN = units::isq::si::force<units::isq::si::giganewton, Rep>;
-template<Representation Rep = double> using TN = units::isq::si::force<units::isq::si::teranewton, Rep>;
-template<Representation Rep = double> using PN = units::isq::si::force<units::isq::si::petanewton, Rep>;
-template<Representation Rep = double> using EN = units::isq::si::force<units::isq::si::exanewton, Rep>;
-template<Representation Rep = double> using ZN = units::isq::si::force<units::isq::si::zettanewton, Rep>;
-template<Representation Rep = double> using YN = units::isq::si::force<units::isq::si::yottanewton, Rep>;
+template<Representation Rep = double>
+using N = units::isq::si::force<units::isq::si::newton, Rep>;
+template<Representation Rep = double>
+using yN = units::isq::si::force<units::isq::si::yoctonewton, Rep>;
+template<Representation Rep = double>
+using zN = units::isq::si::force<units::isq::si::zeptonewton, Rep>;
+template<Representation Rep = double>
+using aN = units::isq::si::force<units::isq::si::attonewton, Rep>;
+template<Representation Rep = double>
+using fN = units::isq::si::force<units::isq::si::femtonewton, Rep>;
+template<Representation Rep = double>
+using pN = units::isq::si::force<units::isq::si::piconewton, Rep>;
+template<Representation Rep = double>
+using nN = units::isq::si::force<units::isq::si::nanonewton, Rep>;
+template<Representation Rep = double>
+using uN = units::isq::si::force<units::isq::si::micronewton, Rep>;
+template<Representation Rep = double>
+using mN = units::isq::si::force<units::isq::si::millinewton, Rep>;
+template<Representation Rep = double>
+using cN = units::isq::si::force<units::isq::si::centinewton, Rep>;
+template<Representation Rep = double>
+using dN = units::isq::si::force<units::isq::si::decinewton, Rep>;
+template<Representation Rep = double>
+using daN = units::isq::si::force<units::isq::si::decanewton, Rep>;
+template<Representation Rep = double>
+using hN = units::isq::si::force<units::isq::si::hectonewton, Rep>;
+template<Representation Rep = double>
+using kN = units::isq::si::force<units::isq::si::kilonewton, Rep>;
+template<Representation Rep = double>
+using MN = units::isq::si::force<units::isq::si::meganewton, Rep>;
+template<Representation Rep = double>
+using GN = units::isq::si::force<units::isq::si::giganewton, Rep>;
+template<Representation Rep = double>
+using TN = units::isq::si::force<units::isq::si::teranewton, Rep>;
+template<Representation Rep = double>
+using PN = units::isq::si::force<units::isq::si::petanewton, Rep>;
+template<Representation Rep = double>
+using EN = units::isq::si::force<units::isq::si::exanewton, Rep>;
+template<Representation Rep = double>
+using ZN = units::isq::si::force<units::isq::si::zettanewton, Rep>;
+template<Representation Rep = double>
+using YN = units::isq::si::force<units::isq::si::yottanewton, Rep>;
 
 }  // namespace units::aliases::isq::si::inline force
 
-#endif // UNITS_NO_ALIASES
+#endif  // UNITS_NO_ALIASES

src/systems/si/include/units/isq/si/luminance.h

@@ -45,12 +45,16 @@ using luminance = quantity<dim_luminance, U, Rep>;
 inline namespace literals {
 
 // cd/m²
-constexpr auto operator"" _q_cd_per_m2(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return luminance<candela_per_metre_sq, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_cd_per_m2(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return luminance<candela_per_metre_sq, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_cd_per_m2(long double l) { return luminance<candela_per_metre_sq, long double>(l); }
 
 }  // namespace literals
 
-#endif // UNITS_NO_LITERALS
+#endif  // UNITS_NO_LITERALS
 
 }  // namespace units::isq::si
 
@@ -58,8 +62,9 @@ constexpr auto operator"" _q_cd_per_m2(long double l) { return luminance<candela
 
 namespace units::aliases::isq::si::inline luminance {
 
-template<Representation Rep = double> using cd_per_m2 = units::isq::si::luminance<units::isq::si::candela_per_metre_sq, Rep>;
+template<Representation Rep = double>
+using cd_per_m2 = units::isq::si::luminance<units::isq::si::candela_per_metre_sq, Rep>;
 
 }  // namespace units::aliases::isq::si::inline luminance
 
-#endif // UNITS_NO_ALIASES
+#endif  // UNITS_NO_ALIASES

src/systems/si/include/units/isq/si/luminous_intensity.h

@@ -66,92 +66,176 @@ using luminous_intensity = quantity<dim_luminous_intensity, U, Rep>;
 inline namespace literals {
 
 // cd
-constexpr auto operator"" _q_cd(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return luminous_intensity<candela, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_cd(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return luminous_intensity<candela, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_cd(long double l) { return luminous_intensity<candela, long double>(l); }
 
 // ycd
-constexpr auto operator"" _q_ycd(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return luminous_intensity<yoctocandela, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_ycd(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return luminous_intensity<yoctocandela, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_ycd(long double l) { return luminous_intensity<yoctocandela, long double>(l); }
 
 // zcd
-constexpr auto operator"" _q_zcd(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return luminous_intensity<zeptocandela, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_zcd(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return luminous_intensity<zeptocandela, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_zcd(long double l) { return luminous_intensity<zeptocandela, long double>(l); }
 
 // acd
-constexpr auto operator"" _q_acd(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return luminous_intensity<attocandela, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_acd(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return luminous_intensity<attocandela, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_acd(long double l) { return luminous_intensity<attocandela, long double>(l); }
 
 // fcd
-constexpr auto operator"" _q_fcd(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return luminous_intensity<femtocandela, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_fcd(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return luminous_intensity<femtocandela, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_fcd(long double l) { return luminous_intensity<femtocandela, long double>(l); }
 
 // pcd
-constexpr auto operator"" _q_pcd(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return luminous_intensity<picocandela, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_pcd(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return luminous_intensity<picocandela, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_pcd(long double l) { return luminous_intensity<picocandela, long double>(l); }
 
 // ncd
-constexpr auto operator"" _q_ncd(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return luminous_intensity<nanocandela, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_ncd(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return luminous_intensity<nanocandela, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_ncd(long double l) { return luminous_intensity<nanocandela, long double>(l); }
 
 // ucd
-constexpr auto operator"" _q_ucd(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return luminous_intensity<microcandela, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_ucd(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return luminous_intensity<microcandela, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_ucd(long double l) { return luminous_intensity<microcandela, long double>(l); }
 
 // mcd
-constexpr auto operator"" _q_mcd(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return luminous_intensity<millicandela, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_mcd(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return luminous_intensity<millicandela, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_mcd(long double l) { return luminous_intensity<millicandela, long double>(l); }
 
 // ccd
-constexpr auto operator"" _q_ccd(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return luminous_intensity<centicandela, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_ccd(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return luminous_intensity<centicandela, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_ccd(long double l) { return luminous_intensity<centicandela, long double>(l); }
 
 // dcd
-constexpr auto operator"" _q_dcd(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return luminous_intensity<decicandela, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_dcd(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return luminous_intensity<decicandela, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_dcd(long double l) { return luminous_intensity<decicandela, long double>(l); }
 
 // dacd
-constexpr auto operator"" _q_dacd(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return luminous_intensity<decacandela, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_dacd(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return luminous_intensity<decacandela, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_dacd(long double l) { return luminous_intensity<decacandela, long double>(l); }
 
 // hcd
-constexpr auto operator"" _q_hcd(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return luminous_intensity<hectocandela, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_hcd(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return luminous_intensity<hectocandela, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_hcd(long double l) { return luminous_intensity<hectocandela, long double>(l); }
 
 // kcd
-constexpr auto operator"" _q_kcd(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return luminous_intensity<kilocandela, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_kcd(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return luminous_intensity<kilocandela, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_kcd(long double l) { return luminous_intensity<kilocandela, long double>(l); }
 
 // Mcd
-constexpr auto operator"" _q_Mcd(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return luminous_intensity<megacandela, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_Mcd(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return luminous_intensity<megacandela, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_Mcd(long double l) { return luminous_intensity<megacandela, long double>(l); }
 
 // Gcd
-constexpr auto operator"" _q_Gcd(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return luminous_intensity<gigacandela, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_Gcd(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return luminous_intensity<gigacandela, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_Gcd(long double l) { return luminous_intensity<gigacandela, long double>(l); }
 
 // Tcd
-constexpr auto operator"" _q_Tcd(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return luminous_intensity<teracandela, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_Tcd(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return luminous_intensity<teracandela, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_Tcd(long double l) { return luminous_intensity<teracandela, long double>(l); }
 
 // Pcd
-constexpr auto operator"" _q_Pcd(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return luminous_intensity<petacandela, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_Pcd(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return luminous_intensity<petacandela, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_Pcd(long double l) { return luminous_intensity<petacandela, long double>(l); }
 
 // Ecd
-constexpr auto operator"" _q_Ecd(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return luminous_intensity<exacandela, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_Ecd(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return luminous_intensity<exacandela, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_Ecd(long double l) { return luminous_intensity<exacandela, long double>(l); }
 
 // Zcd
-constexpr auto operator"" _q_Zcd(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return luminous_intensity<zettacandela, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_Zcd(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return luminous_intensity<zettacandela, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_Zcd(long double l) { return luminous_intensity<zettacandela, long double>(l); }
 
 // Ycd
-constexpr auto operator"" _q_Ycd(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return luminous_intensity<yottacandela, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_Ycd(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return luminous_intensity<yottacandela, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_Ycd(long double l) { return luminous_intensity<yottacandela, long double>(l); }
 
 }  // namespace literals
 
-#endif // UNITS_NO_LITERALS
+#endif  // UNITS_NO_LITERALS
 
 #ifndef UNITS_NO_REFERENCES
 
@@ -187,7 +271,7 @@ using namespace luminous_intensity_references;
 
 }  // namespace references
 
-#endif // UNITS_NO_REFERENCES
+#endif  // UNITS_NO_REFERENCES
 
 }  // namespace units::isq::si
 
@@ -195,28 +279,49 @@ using namespace luminous_intensity_references;
 
 namespace units::aliases::isq::si::luminous_intensity {
 
-template<Representation Rep = double> using cd = units::isq::si::luminous_intensity<units::isq::si::candela, Rep>;
-template<Representation Rep = double> using ycd = units::isq::si::luminous_intensity<units::isq::si::yoctocandela, Rep>;
-template<Representation Rep = double> using zcd = units::isq::si::luminous_intensity<units::isq::si::zeptocandela, Rep>;
-template<Representation Rep = double> using acd = units::isq::si::luminous_intensity<units::isq::si::attocandela, Rep>;
-template<Representation Rep = double> using fcd = units::isq::si::luminous_intensity<units::isq::si::femtocandela, Rep>;
-template<Representation Rep = double> using pcd = units::isq::si::luminous_intensity<units::isq::si::picocandela, Rep>;
-template<Representation Rep = double> using ncd = units::isq::si::luminous_intensity<units::isq::si::nanocandela, Rep>;
-template<Representation Rep = double> using ucd = units::isq::si::luminous_intensity<units::isq::si::microcandela, Rep>;
-template<Representation Rep = double> using mcd = units::isq::si::luminous_intensity<units::isq::si::millicandela, Rep>;
-template<Representation Rep = double> using ccd = units::isq::si::luminous_intensity<units::isq::si::centicandela, Rep>;
-template<Representation Rep = double> using dcd = units::isq::si::luminous_intensity<units::isq::si::decicandela, Rep>;
-template<Representation Rep = double> using dacd = units::isq::si::luminous_intensity<units::isq::si::decacandela, Rep>;
-template<Representation Rep = double> using hcd = units::isq::si::luminous_intensity<units::isq::si::hectocandela, Rep>;
-template<Representation Rep = double> using kcd = units::isq::si::luminous_intensity<units::isq::si::kilocandela, Rep>;
-template<Representation Rep = double> using Mcd = units::isq::si::luminous_intensity<units::isq::si::megacandela, Rep>;
-template<Representation Rep = double> using Gcd = units::isq::si::luminous_intensity<units::isq::si::gigacandela, Rep>;
-template<Representation Rep = double> using Tcd = units::isq::si::luminous_intensity<units::isq::si::teracandela, Rep>;
-template<Representation Rep = double> using Pcd = units::isq::si::luminous_intensity<units::isq::si::petacandela, Rep>;
-template<Representation Rep = double> using Ecd = units::isq::si::luminous_intensity<units::isq::si::exacandela, Rep>;
-template<Representation Rep = double> using Zcd = units::isq::si::luminous_intensity<units::isq::si::zettacandela, Rep>;
-template<Representation Rep = double> using Ycd = units::isq::si::luminous_intensity<units::isq::si::yottacandela, Rep>;
+template<Representation Rep = double>
+using cd = units::isq::si::luminous_intensity<units::isq::si::candela, Rep>;
+template<Representation Rep = double>
+using ycd = units::isq::si::luminous_intensity<units::isq::si::yoctocandela, Rep>;
+template<Representation Rep = double>
+using zcd = units::isq::si::luminous_intensity<units::isq::si::zeptocandela, Rep>;
+template<Representation Rep = double>
+using acd = units::isq::si::luminous_intensity<units::isq::si::attocandela, Rep>;
+template<Representation Rep = double>
+using fcd = units::isq::si::luminous_intensity<units::isq::si::femtocandela, Rep>;
+template<Representation Rep = double>
+using pcd = units::isq::si::luminous_intensity<units::isq::si::picocandela, Rep>;
+template<Representation Rep = double>
+using ncd = units::isq::si::luminous_intensity<units::isq::si::nanocandela, Rep>;
+template<Representation Rep = double>
+using ucd = units::isq::si::luminous_intensity<units::isq::si::microcandela, Rep>;
+template<Representation Rep = double>
+using mcd = units::isq::si::luminous_intensity<units::isq::si::millicandela, Rep>;
+template<Representation Rep = double>
+using ccd = units::isq::si::luminous_intensity<units::isq::si::centicandela, Rep>;
+template<Representation Rep = double>
+using dcd = units::isq::si::luminous_intensity<units::isq::si::decicandela, Rep>;
+template<Representation Rep = double>
+using dacd = units::isq::si::luminous_intensity<units::isq::si::decacandela, Rep>;
+template<Representation Rep = double>
+using hcd = units::isq::si::luminous_intensity<units::isq::si::hectocandela, Rep>;
+template<Representation Rep = double>
+using kcd = units::isq::si::luminous_intensity<units::isq::si::kilocandela, Rep>;
+template<Representation Rep = double>
+using Mcd = units::isq::si::luminous_intensity<units::isq::si::megacandela, Rep>;
+template<Representation Rep = double>
+using Gcd = units::isq::si::luminous_intensity<units::isq::si::gigacandela, Rep>;
+template<Representation Rep = double>
+using Tcd = units::isq::si::luminous_intensity<units::isq::si::teracandela, Rep>;
+template<Representation Rep = double>
+using Pcd = units::isq::si::luminous_intensity<units::isq::si::petacandela, Rep>;
+template<Representation Rep = double>
+using Ecd = units::isq::si::luminous_intensity<units::isq::si::exacandela, Rep>;
+template<Representation Rep = double>
+using Zcd = units::isq::si::luminous_intensity<units::isq::si::zettacandela, Rep>;
+template<Representation Rep = double>
+using Ycd = units::isq::si::luminous_intensity<units::isq::si::yottacandela, Rep>;
 
 }  // namespace units::aliases::isq::si::luminous_intensity
 
-#endif // UNITS_NO_ALIASES
+#endif  // UNITS_NO_ALIASES

src/systems/si/include/units/isq/si/molar_energy.h

@@ -28,8 +28,8 @@
 #include <units/symbol_text.h>
 // IWYU pragma: end_exports
 
-#include <units/isq/si/energy.h>
 #include <units/isq/si/amount_of_substance.h>
+#include <units/isq/si/energy.h>
 #include <units/isq/si/prefixes.h>
 #include <units/unit.h>
 
@@ -37,7 +37,8 @@ namespace units::isq::si {
 
 struct joule_per_mole : unit<joule_per_mole> {};
 
-struct dim_molar_energy : isq::dim_molar_energy<dim_molar_energy, joule_per_mole, dim_energy, dim_amount_of_substance> {};
+struct dim_molar_energy :
+    isq::dim_molar_energy<dim_molar_energy, joule_per_mole, dim_energy, dim_amount_of_substance> {};
 
 template<UnitOf<dim_molar_energy> U, Representation Rep = double>
 using molar_energy = quantity<dim_molar_energy, U, Rep>;
@@ -47,12 +48,16 @@ using molar_energy = quantity<dim_molar_energy, U, Rep>;
 inline namespace literals {
 
 // J/mol
-constexpr auto operator"" _q_J_per_mol(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return molar_energy<joule_per_mole, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_J_per_mol(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return molar_energy<joule_per_mole, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_J_per_mol(long double l) { return molar_energy<joule_per_mole, long double>(l); }
 
 }  // namespace literals
 
-#endif // UNITS_NO_LITERALS
+#endif  // UNITS_NO_LITERALS
 
 }  // namespace units::isq::si
 
@@ -60,8 +65,9 @@ constexpr auto operator"" _q_J_per_mol(long double l) { return molar_energy<joul
 
 namespace units::aliases::isq::si::inline molar_energy {
 
-template<Representation Rep = double> using J_per_mol = units::isq::si::molar_energy<units::isq::si::joule_per_mole, Rep>;
+template<Representation Rep = double>
+using J_per_mol = units::isq::si::molar_energy<units::isq::si::joule_per_mole, Rep>;
 
 }  // namespace units::aliases::isq::si::inline molar_energy
 
-#endif // UNITS_NO_ALIASES
+#endif  // UNITS_NO_ALIASES

src/systems/si/include/units/isq/si/pressure.h

@@ -68,92 +68,176 @@ using pressure = quantity<dim_pressure, U, Rep>;
 inline namespace literals {
 
 // Pa
-constexpr auto operator"" _q_Pa(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return pressure<pascal, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_Pa(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return pressure<pascal, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_Pa(long double l) { return pressure<pascal, long double>(l); }
 
 // yPa
-constexpr auto operator"" _q_yPa(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return pressure<yoctopascal, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_yPa(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return pressure<yoctopascal, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_yPa(long double l) { return pressure<yoctopascal, long double>(l); }
 
 // zPa
-constexpr auto operator"" _q_zPa(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return pressure<zeptopascal, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_zPa(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return pressure<zeptopascal, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_zPa(long double l) { return pressure<zeptopascal, long double>(l); }
 
 // aPa
-constexpr auto operator"" _q_aPa(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return pressure<attopascal, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_aPa(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return pressure<attopascal, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_aPa(long double l) { return pressure<attopascal, long double>(l); }
 
 // fPa
-constexpr auto operator"" _q_fPa(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return pressure<femtopascal, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_fPa(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return pressure<femtopascal, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_fPa(long double l) { return pressure<femtopascal, long double>(l); }
 
 // pPa
-constexpr auto operator"" _q_pPa(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return pressure<picopascal, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_pPa(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return pressure<picopascal, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_pPa(long double l) { return pressure<picopascal, long double>(l); }
 
 // nPa
-constexpr auto operator"" _q_nPa(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return pressure<nanopascal, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_nPa(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return pressure<nanopascal, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_nPa(long double l) { return pressure<nanopascal, long double>(l); }
 
 // uPa
-constexpr auto operator"" _q_uPa(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return pressure<micropascal, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_uPa(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return pressure<micropascal, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_uPa(long double l) { return pressure<micropascal, long double>(l); }
 
 // mPa
-constexpr auto operator"" _q_mPa(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return pressure<millipascal, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_mPa(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return pressure<millipascal, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_mPa(long double l) { return pressure<millipascal, long double>(l); }
 
 // cPa
-constexpr auto operator"" _q_cPa(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return pressure<centipascal, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_cPa(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return pressure<centipascal, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_cPa(long double l) { return pressure<centipascal, long double>(l); }
 
 // dPa
-constexpr auto operator"" _q_dPa(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return pressure<decipascal, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_dPa(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return pressure<decipascal, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_dPa(long double l) { return pressure<decipascal, long double>(l); }
 
 // daPa
-constexpr auto operator"" _q_daPa(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return pressure<decapascal, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_daPa(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return pressure<decapascal, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_daPa(long double l) { return pressure<decapascal, long double>(l); }
 
 // hPa
-constexpr auto operator"" _q_hPa(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return pressure<hectopascal, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_hPa(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return pressure<hectopascal, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_hPa(long double l) { return pressure<hectopascal, long double>(l); }
 
 // kPa
-constexpr auto operator"" _q_kPa(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return pressure<kilopascal, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_kPa(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return pressure<kilopascal, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_kPa(long double l) { return pressure<kilopascal, long double>(l); }
 
 // MPa
-constexpr auto operator"" _q_MPa(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return pressure<megapascal, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_MPa(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return pressure<megapascal, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_MPa(long double l) { return pressure<megapascal, long double>(l); }
 
 // GPa
-constexpr auto operator"" _q_GPa(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return pressure<gigapascal, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_GPa(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return pressure<gigapascal, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_GPa(long double l) { return pressure<gigapascal, long double>(l); }
 
 // TPa
-constexpr auto operator"" _q_TPa(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return pressure<terapascal, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_TPa(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return pressure<terapascal, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_TPa(long double l) { return pressure<terapascal, long double>(l); }
 
 // PPa
-constexpr auto operator"" _q_PPa(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return pressure<petapascal, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_PPa(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return pressure<petapascal, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_PPa(long double l) { return pressure<petapascal, long double>(l); }
 
 // EPa
-constexpr auto operator"" _q_EPa(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return pressure<exapascal, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_EPa(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return pressure<exapascal, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_EPa(long double l) { return pressure<exapascal, long double>(l); }
 
 // ZPa
-constexpr auto operator"" _q_ZPa(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return pressure<zettapascal, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_ZPa(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return pressure<zettapascal, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_ZPa(long double l) { return pressure<zettapascal, long double>(l); }
 
 // YPa
-constexpr auto operator"" _q_YPa(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return pressure<yottapascal, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_YPa(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return pressure<yottapascal, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_YPa(long double l) { return pressure<yottapascal, long double>(l); }
 
 }  // namespace literals
 
-#endif // UNITS_NO_LITERALS
+#endif  // UNITS_NO_LITERALS
 
 #ifndef UNITS_NO_REFERENCES
 
@@ -189,7 +273,7 @@ using namespace pressure_references;
 
 }  // namespace references
 
-#endif // UNITS_NO_REFERENCES
+#endif  // UNITS_NO_REFERENCES
 
 }  // namespace units::isq::si
 
@@ -197,28 +281,49 @@ using namespace pressure_references;
 
 namespace units::aliases::isq::si::inline pressure {
 
-template<Representation Rep = double> using Pa = units::isq::si::pressure<units::isq::si::pascal, Rep>;
-template<Representation Rep = double> using yPa = units::isq::si::pressure<units::isq::si::yoctopascal, Rep>;
-template<Representation Rep = double> using zPa = units::isq::si::pressure<units::isq::si::zeptopascal, Rep>;
-template<Representation Rep = double> using aPa = units::isq::si::pressure<units::isq::si::attopascal, Rep>;
-template<Representation Rep = double> using fPa = units::isq::si::pressure<units::isq::si::femtopascal, Rep>;
-template<Representation Rep = double> using pPa = units::isq::si::pressure<units::isq::si::picopascal, Rep>;
-template<Representation Rep = double> using nPa = units::isq::si::pressure<units::isq::si::nanopascal, Rep>;
-template<Representation Rep = double> using uPa = units::isq::si::pressure<units::isq::si::micropascal, Rep>;
-template<Representation Rep = double> using mPa = units::isq::si::pressure<units::isq::si::millipascal, Rep>;
-template<Representation Rep = double> using cPa = units::isq::si::pressure<units::isq::si::centipascal, Rep>;
-template<Representation Rep = double> using dPa = units::isq::si::pressure<units::isq::si::decipascal, Rep>;
-template<Representation Rep = double> using daPa = units::isq::si::pressure<units::isq::si::decapascal, Rep>;
-template<Representation Rep = double> using hPa = units::isq::si::pressure<units::isq::si::hectopascal, Rep>;
-template<Representation Rep = double> using kPa = units::isq::si::pressure<units::isq::si::kilopascal, Rep>;
-template<Representation Rep = double> using MPa = units::isq::si::pressure<units::isq::si::megapascal, Rep>;
-template<Representation Rep = double> using GPa = units::isq::si::pressure<units::isq::si::gigapascal, Rep>;
-template<Representation Rep = double> using TPa = units::isq::si::pressure<units::isq::si::terapascal, Rep>;
-template<Representation Rep = double> using PPa = units::isq::si::pressure<units::isq::si::petapascal, Rep>;
-template<Representation Rep = double> using EPa = units::isq::si::pressure<units::isq::si::exapascal, Rep>;
-template<Representation Rep = double> using ZPa = units::isq::si::pressure<units::isq::si::zettapascal, Rep>;
-template<Representation Rep = double> using YPa = units::isq::si::pressure<units::isq::si::yottapascal, Rep>;
+template<Representation Rep = double>
+using Pa = units::isq::si::pressure<units::isq::si::pascal, Rep>;
+template<Representation Rep = double>
+using yPa = units::isq::si::pressure<units::isq::si::yoctopascal, Rep>;
+template<Representation Rep = double>
+using zPa = units::isq::si::pressure<units::isq::si::zeptopascal, Rep>;
+template<Representation Rep = double>
+using aPa = units::isq::si::pressure<units::isq::si::attopascal, Rep>;
+template<Representation Rep = double>
+using fPa = units::isq::si::pressure<units::isq::si::femtopascal, Rep>;
+template<Representation Rep = double>
+using pPa = units::isq::si::pressure<units::isq::si::picopascal, Rep>;
+template<Representation Rep = double>
+using nPa = units::isq::si::pressure<units::isq::si::nanopascal, Rep>;
+template<Representation Rep = double>
+using uPa = units::isq::si::pressure<units::isq::si::micropascal, Rep>;
+template<Representation Rep = double>
+using mPa = units::isq::si::pressure<units::isq::si::millipascal, Rep>;
+template<Representation Rep = double>
+using cPa = units::isq::si::pressure<units::isq::si::centipascal, Rep>;
+template<Representation Rep = double>
+using dPa = units::isq::si::pressure<units::isq::si::decipascal, Rep>;
+template<Representation Rep = double>
+using daPa = units::isq::si::pressure<units::isq::si::decapascal, Rep>;
+template<Representation Rep = double>
+using hPa = units::isq::si::pressure<units::isq::si::hectopascal, Rep>;
+template<Representation Rep = double>
+using kPa = units::isq::si::pressure<units::isq::si::kilopascal, Rep>;
+template<Representation Rep = double>
+using MPa = units::isq::si::pressure<units::isq::si::megapascal, Rep>;
+template<Representation Rep = double>
+using GPa = units::isq::si::pressure<units::isq::si::gigapascal, Rep>;
+template<Representation Rep = double>
+using TPa = units::isq::si::pressure<units::isq::si::terapascal, Rep>;
+template<Representation Rep = double>
+using PPa = units::isq::si::pressure<units::isq::si::petapascal, Rep>;
+template<Representation Rep = double>
+using EPa = units::isq::si::pressure<units::isq::si::exapascal, Rep>;
+template<Representation Rep = double>
+using ZPa = units::isq::si::pressure<units::isq::si::zettapascal, Rep>;
+template<Representation Rep = double>
+using YPa = units::isq::si::pressure<units::isq::si::yottapascal, Rep>;
 
 }  // namespace units::aliases::isq::si::inline pressure
 
-#endif // UNITS_NO_ALIASES
+#endif  // UNITS_NO_ALIASES

src/systems/si/include/units/isq/si/radioactivity.h

@@ -66,92 +66,176 @@ using radioactivity = quantity<dim_radioactivity, U, Rep>;
 inline namespace literals {
 
 // Bq
-constexpr auto operator"" _q_Bq(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return radioactivity<becquerel, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_Bq(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return radioactivity<becquerel, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_Bq(long double l) { return radioactivity<becquerel, long double>(l); }
 
 // yBq
-constexpr auto operator"" _q_yBq(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return radioactivity<yoctobecquerel, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_yBq(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return radioactivity<yoctobecquerel, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_yBq(long double l) { return radioactivity<yoctobecquerel, long double>(l); }
 
 // zBq
-constexpr auto operator"" _q_zBq(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return radioactivity<zeptobecquerel, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_zBq(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return radioactivity<zeptobecquerel, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_zBq(long double l) { return radioactivity<zeptobecquerel, long double>(l); }
 
 // aBq
-constexpr auto operator"" _q_aBq(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return radioactivity<attobecquerel, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_aBq(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return radioactivity<attobecquerel, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_aBq(long double l) { return radioactivity<attobecquerel, long double>(l); }
 
 // fBq
-constexpr auto operator"" _q_fBq(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return radioactivity<femtobecquerel, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_fBq(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return radioactivity<femtobecquerel, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_fBq(long double l) { return radioactivity<femtobecquerel, long double>(l); }
 
 // pBq
-constexpr auto operator"" _q_pBq(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return radioactivity<picobecquerel, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_pBq(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return radioactivity<picobecquerel, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_pBq(long double l) { return radioactivity<picobecquerel, long double>(l); }
 
 // nBq
-constexpr auto operator"" _q_nBq(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return radioactivity<nanobecquerel, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_nBq(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return radioactivity<nanobecquerel, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_nBq(long double l) { return radioactivity<nanobecquerel, long double>(l); }
 
 // uBq
-constexpr auto operator"" _q_uBq(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return radioactivity<microbecquerel, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_uBq(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return radioactivity<microbecquerel, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_uBq(long double l) { return radioactivity<microbecquerel, long double>(l); }
 
 // mBq
-constexpr auto operator"" _q_mBq(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return radioactivity<millibecquerel, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_mBq(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return radioactivity<millibecquerel, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_mBq(long double l) { return radioactivity<millibecquerel, long double>(l); }
 
 // cBq
-constexpr auto operator"" _q_cBq(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return radioactivity<centibecquerel, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_cBq(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return radioactivity<centibecquerel, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_cBq(long double l) { return radioactivity<centibecquerel, long double>(l); }
 
 // dBq
-constexpr auto operator"" _q_dBq(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return radioactivity<decibecquerel, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_dBq(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return radioactivity<decibecquerel, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_dBq(long double l) { return radioactivity<decibecquerel, long double>(l); }
 
 // daBq
-constexpr auto operator"" _q_daBq(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return radioactivity<decabecquerel, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_daBq(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return radioactivity<decabecquerel, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_daBq(long double l) { return radioactivity<decabecquerel, long double>(l); }
 
 // hBq
-constexpr auto operator"" _q_hBq(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return radioactivity<hectobecquerel, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_hBq(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return radioactivity<hectobecquerel, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_hBq(long double l) { return radioactivity<hectobecquerel, long double>(l); }
 
 // kBq
-constexpr auto operator"" _q_kBq(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return radioactivity<kilobecquerel, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_kBq(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return radioactivity<kilobecquerel, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_kBq(long double l) { return radioactivity<kilobecquerel, long double>(l); }
 
 // MBq
-constexpr auto operator"" _q_MBq(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return radioactivity<megabecquerel, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_MBq(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return radioactivity<megabecquerel, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_MBq(long double l) { return radioactivity<megabecquerel, long double>(l); }
 
 // GBq
-constexpr auto operator"" _q_GBq(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return radioactivity<gigabecquerel, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_GBq(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return radioactivity<gigabecquerel, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_GBq(long double l) { return radioactivity<gigabecquerel, long double>(l); }
 
 // TBq
-constexpr auto operator"" _q_TBq(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return radioactivity<terabecquerel, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_TBq(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return radioactivity<terabecquerel, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_TBq(long double l) { return radioactivity<terabecquerel, long double>(l); }
 
 // PBq
-constexpr auto operator"" _q_PBq(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return radioactivity<petabecquerel, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_PBq(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return radioactivity<petabecquerel, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_PBq(long double l) { return radioactivity<petabecquerel, long double>(l); }
 
 // EBq
-constexpr auto operator"" _q_EBq(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return radioactivity<exabecquerel, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_EBq(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return radioactivity<exabecquerel, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_EBq(long double l) { return radioactivity<exabecquerel, long double>(l); }
 
 // ZBq
-constexpr auto operator"" _q_ZBq(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return radioactivity<zettabecquerel, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_ZBq(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return radioactivity<zettabecquerel, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_ZBq(long double l) { return radioactivity<zettabecquerel, long double>(l); }
 
 // YBq
-constexpr auto operator"" _q_YBq(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return radioactivity<yottabecquerel, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_YBq(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return radioactivity<yottabecquerel, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_YBq(long double l) { return radioactivity<yottabecquerel, long double>(l); }
 
 }  // namespace literals
 
-#endif // UNITS_NO_LITERALS
+#endif  // UNITS_NO_LITERALS
 
 #ifndef UNITS_NO_REFERENCES
 
@@ -187,7 +271,7 @@ using namespace radioactivity_references;
 
 }  // namespace references
 
-#endif // UNITS_NO_REFERENCES
+#endif  // UNITS_NO_REFERENCES
 
 }  // namespace units::isq::si
 
@@ -195,28 +279,49 @@ using namespace radioactivity_references;
 
 namespace units::aliases::isq::si::inline radioactivity {
 
-template<Representation Rep = double> using Bq = units::isq::radioactivity<units::isq::becquerel, Rep>;
-template<Representation Rep = double> using yBq = units::isq::radioactivity<units::isq::yoctobecquerel, Rep>;
-template<Representation Rep = double> using zBq = units::isq::radioactivity<units::isq::zeptobecquerel, Rep>;
-template<Representation Rep = double> using aBq = units::isq::radioactivity<units::isq::attobecquerel, Rep>;
-template<Representation Rep = double> using fBq = units::isq::radioactivity<units::isq::femtobecquerel, Rep>;
-template<Representation Rep = double> using pBq = units::isq::radioactivity<units::isq::picobecquerel, Rep>;
-template<Representation Rep = double> using nBq = units::isq::radioactivity<units::isq::nanobecquerel, Rep>;
-template<Representation Rep = double> using uBq = units::isq::radioactivity<units::isq::microbecquerel, Rep>;
-template<Representation Rep = double> using mBq = units::isq::radioactivity<units::isq::millibecquerel, Rep>;
-template<Representation Rep = double> using cBq = units::isq::radioactivity<units::isq::centibecquerel, Rep>;
-template<Representation Rep = double> using dBq = units::isq::radioactivity<units::isq::decibecquerel, Rep>;
-template<Representation Rep = double> using daBq = units::isq::radioactivity<units::isq::decabecquerel, Rep>;
-template<Representation Rep = double> using hBq = units::isq::radioactivity<units::isq::hectobecquerel, Rep>;
-template<Representation Rep = double> using kBq = units::isq::radioactivity<units::isq::kilobecquerel, Rep>;
-template<Representation Rep = double> using MBq = units::isq::radioactivity<units::isq::megabecquerel, Rep>;
-template<Representation Rep = double> using GBq = units::isq::radioactivity<units::isq::gigabecquerel, Rep>;
-template<Representation Rep = double> using TBq = units::isq::radioactivity<units::isq::terabecquerel, Rep>;
-template<Representation Rep = double> using PBq = units::isq::radioactivity<units::isq::petabecquerel, Rep>;
-template<Representation Rep = double> using EBq = units::isq::radioactivity<units::isq::exabecquerel, Rep>;
-template<Representation Rep = double> using ZBq = units::isq::radioactivity<units::isq::zettabecquerel, Rep>;
-template<Representation Rep = double> using YBq = units::isq::radioactivity<units::isq::yottabecquerel, Rep>;
+template<Representation Rep = double>
+using Bq = units::isq::radioactivity<units::isq::becquerel, Rep>;
+template<Representation Rep = double>
+using yBq = units::isq::radioactivity<units::isq::yoctobecquerel, Rep>;
+template<Representation Rep = double>
+using zBq = units::isq::radioactivity<units::isq::zeptobecquerel, Rep>;
+template<Representation Rep = double>
+using aBq = units::isq::radioactivity<units::isq::attobecquerel, Rep>;
+template<Representation Rep = double>
+using fBq = units::isq::radioactivity<units::isq::femtobecquerel, Rep>;
+template<Representation Rep = double>
+using pBq = units::isq::radioactivity<units::isq::picobecquerel, Rep>;
+template<Representation Rep = double>
+using nBq = units::isq::radioactivity<units::isq::nanobecquerel, Rep>;
+template<Representation Rep = double>
+using uBq = units::isq::radioactivity<units::isq::microbecquerel, Rep>;
+template<Representation Rep = double>
+using mBq = units::isq::radioactivity<units::isq::millibecquerel, Rep>;
+template<Representation Rep = double>
+using cBq = units::isq::radioactivity<units::isq::centibecquerel, Rep>;
+template<Representation Rep = double>
+using dBq = units::isq::radioactivity<units::isq::decibecquerel, Rep>;
+template<Representation Rep = double>
+using daBq = units::isq::radioactivity<units::isq::decabecquerel, Rep>;
+template<Representation Rep = double>
+using hBq = units::isq::radioactivity<units::isq::hectobecquerel, Rep>;
+template<Representation Rep = double>
+using kBq = units::isq::radioactivity<units::isq::kilobecquerel, Rep>;
+template<Representation Rep = double>
+using MBq = units::isq::radioactivity<units::isq::megabecquerel, Rep>;
+template<Representation Rep = double>
+using GBq = units::isq::radioactivity<units::isq::gigabecquerel, Rep>;
+template<Representation Rep = double>
+using TBq = units::isq::radioactivity<units::isq::terabecquerel, Rep>;
+template<Representation Rep = double>
+using PBq = units::isq::radioactivity<units::isq::petabecquerel, Rep>;
+template<Representation Rep = double>
+using EBq = units::isq::radioactivity<units::isq::exabecquerel, Rep>;
+template<Representation Rep = double>
+using ZBq = units::isq::radioactivity<units::isq::zettabecquerel, Rep>;
+template<Representation Rep = double>
+using YBq = units::isq::radioactivity<units::isq::yottabecquerel, Rep>;
 
 }  // namespace units::aliases::isq::si::inline radioactivity
 
-#endif // UNITS_NO_ALIASES
+#endif  // UNITS_NO_ALIASES

src/systems/si/include/units/isq/si/voltage.h

@@ -68,92 +68,176 @@ using voltage = quantity<dim_voltage, U, Rep>;
 inline namespace literals {
 
 // V
-constexpr auto operator"" _q_V(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return voltage<volt, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_V(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return voltage<volt, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_V(long double l) { return voltage<volt, long double>(l); }
 
 // yV
-constexpr auto operator"" _q_yV(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return voltage<yoctovolt, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_yV(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return voltage<yoctovolt, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_yV(long double l) { return voltage<yoctovolt, long double>(l); }
 
 // zV
-constexpr auto operator"" _q_zV(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return voltage<zeptovolt, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_zV(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return voltage<zeptovolt, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_zV(long double l) { return voltage<zeptovolt, long double>(l); }
 
 // aV
-constexpr auto operator"" _q_aV(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return voltage<attovolt, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_aV(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return voltage<attovolt, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_aV(long double l) { return voltage<attovolt, long double>(l); }
 
 // fV
-constexpr auto operator"" _q_fV(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return voltage<femtovolt, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_fV(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return voltage<femtovolt, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_fV(long double l) { return voltage<femtovolt, long double>(l); }
 
 // pV
-constexpr auto operator"" _q_pV(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return voltage<picovolt, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_pV(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return voltage<picovolt, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_pV(long double l) { return voltage<picovolt, long double>(l); }
 
 // nV
-constexpr auto operator"" _q_nV(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return voltage<nanovolt, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_nV(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return voltage<nanovolt, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_nV(long double l) { return voltage<nanovolt, long double>(l); }
 
 // uV
-constexpr auto operator"" _q_uV(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return voltage<microvolt, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_uV(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return voltage<microvolt, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_uV(long double l) { return voltage<microvolt, long double>(l); }
 
 // mV
-constexpr auto operator"" _q_mV(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return voltage<millivolt, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_mV(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return voltage<millivolt, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_mV(long double l) { return voltage<millivolt, long double>(l); }
 
 // cV
-constexpr auto operator"" _q_cV(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return voltage<centivolt, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_cV(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return voltage<centivolt, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_cV(long double l) { return voltage<centivolt, long double>(l); }
 
 // dV
-constexpr auto operator"" _q_dV(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return voltage<decivolt, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_dV(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return voltage<decivolt, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_dV(long double l) { return voltage<decivolt, long double>(l); }
 
 // daV
-constexpr auto operator"" _q_daV(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return voltage<decavolt, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_daV(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return voltage<decavolt, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_daV(long double l) { return voltage<decavolt, long double>(l); }
 
 // hV
-constexpr auto operator"" _q_hV(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return voltage<hectovolt, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_hV(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return voltage<hectovolt, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_hV(long double l) { return voltage<hectovolt, long double>(l); }
 
 // kV
-constexpr auto operator"" _q_kV(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return voltage<kilovolt, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_kV(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return voltage<kilovolt, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_kV(long double l) { return voltage<kilovolt, long double>(l); }
 
 // MV
-constexpr auto operator"" _q_MV(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return voltage<megavolt, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_MV(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return voltage<megavolt, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_MV(long double l) { return voltage<megavolt, long double>(l); }
 
 // GV
-constexpr auto operator"" _q_GV(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return voltage<gigavolt, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_GV(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return voltage<gigavolt, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_GV(long double l) { return voltage<gigavolt, long double>(l); }
 
 // TV
-constexpr auto operator"" _q_TV(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return voltage<teravolt, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_TV(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return voltage<teravolt, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_TV(long double l) { return voltage<teravolt, long double>(l); }
 
 // PV
-constexpr auto operator"" _q_PV(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return voltage<petavolt, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_PV(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return voltage<petavolt, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_PV(long double l) { return voltage<petavolt, long double>(l); }
 
 // EV
-constexpr auto operator"" _q_EV(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return voltage<exavolt, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_EV(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return voltage<exavolt, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_EV(long double l) { return voltage<exavolt, long double>(l); }
 
 // ZV
-constexpr auto operator"" _q_ZV(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return voltage<zettavolt, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_ZV(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return voltage<zettavolt, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_ZV(long double l) { return voltage<zettavolt, long double>(l); }
 
 // YV
-constexpr auto operator"" _q_YV(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return voltage<yottavolt, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_YV(unsigned long long l)
+{
+  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
+  return voltage<yottavolt, std::int64_t>(static_cast<std::int64_t>(l));
+}
 constexpr auto operator"" _q_YV(long double l) { return voltage<yottavolt, long double>(l); }
 
 }  // namespace literals
 
-#endif // UNITS_NO_LITERALS
+#endif  // UNITS_NO_LITERALS
 
 #ifndef UNITS_NO_REFERENCES
 
@@ -189,7 +273,7 @@ using namespace voltage_references;
 
 }  // namespace references
 
-#endif // UNITS_NO_REFERENCES
+#endif  // UNITS_NO_REFERENCES
 
 }  // namespace units::isq::si
 
@@ -197,28 +281,49 @@ using namespace voltage_references;
 
 namespace units::aliases::isq::si::inline voltage {
 
-template<Representation Rep = double> using V = units::isq::si::voltage<units::isq::si::volt, Rep>;
-template<Representation Rep = double> using yV = units::isq::si::voltage<units::isq::si::yoctovolt, Rep>;
-template<Representation Rep = double> using zV = units::isq::si::voltage<units::isq::si::zeptovolt, Rep>;
-template<Representation Rep = double> using aV = units::isq::si::voltage<units::isq::si::attovolt, Rep>;
-template<Representation Rep = double> using fV = units::isq::si::voltage<units::isq::si::femtovolt, Rep>;
-template<Representation Rep = double> using pV = units::isq::si::voltage<units::isq::si::picovolt, Rep>;
-template<Representation Rep = double> using nV = units::isq::si::voltage<units::isq::si::nanovolt, Rep>;
-template<Representation Rep = double> using uV = units::isq::si::voltage<units::isq::si::microvolt, Rep>;
-template<Representation Rep = double> using mV = units::isq::si::voltage<units::isq::si::millivolt, Rep>;
-template<Representation Rep = double> using cV = units::isq::si::voltage<units::isq::si::centivolt, Rep>;
-template<Representation Rep = double> using dV = units::isq::si::voltage<units::isq::si::decivolt, Rep>;
-template<Representation Rep = double> using daV = units::isq::si::voltage<units::isq::si::decavolt, Rep>;
-template<Representation Rep = double> using hV = units::isq::si::voltage<units::isq::si::hectovolt, Rep>;
-template<Representation Rep = double> using kV = units::isq::si::voltage<units::isq::si::kilovolt, Rep>;
-template<Representation Rep = double> using MV = units::isq::si::voltage<units::isq::si::megavolt, Rep>;
-template<Representation Rep = double> using GV = units::isq::si::voltage<units::isq::si::gigavolt, Rep>;
-template<Representation Rep = double> using TV = units::isq::si::voltage<units::isq::si::teravolt, Rep>;
-template<Representation Rep = double> using PV = units::isq::si::voltage<units::isq::si::petavolt, Rep>;
-template<Representation Rep = double> using EV = units::isq::si::voltage<units::isq::si::exavolt, Rep>;
-template<Representation Rep = double> using ZV = units::isq::si::voltage<units::isq::si::zettavolt, Rep>;
-template<Representation Rep = double> using YV = units::isq::si::voltage<units::isq::si::yottavolt, Rep>;
+template<Representation Rep = double>
+using V = units::isq::si::voltage<units::isq::si::volt, Rep>;
+template<Representation Rep = double>
+using yV = units::isq::si::voltage<units::isq::si::yoctovolt, Rep>;
+template<Representation Rep = double>
+using zV = units::isq::si::voltage<units::isq::si::zeptovolt, Rep>;
+template<Representation Rep = double>
+using aV = units::isq::si::voltage<units::isq::si::attovolt, Rep>;
+template<Representation Rep = double>
+using fV = units::isq::si::voltage<units::isq::si::femtovolt, Rep>;
+template<Representation Rep = double>
+using pV = units::isq::si::voltage<units::isq::si::picovolt, Rep>;
+template<Representation Rep = double>
+using nV = units::isq::si::voltage<units::isq::si::nanovolt, Rep>;
+template<Representation Rep = double>
+using uV = units::isq::si::voltage<units::isq::si::microvolt, Rep>;
+template<Representation Rep = double>
+using mV = units::isq::si::voltage<units::isq::si::millivolt, Rep>;
+template<Representation Rep = double>
+using cV = units::isq::si::voltage<units::isq::si::centivolt, Rep>;
+template<Representation Rep = double>
+using dV = units::isq::si::voltage<units::isq::si::decivolt, Rep>;
+template<Representation Rep = double>
+using daV = units::isq::si::voltage<units::isq::si::decavolt, Rep>;
+template<Representation Rep = double>
+using hV = units::isq::si::voltage<units::isq::si::hectovolt, Rep>;
+template<Representation Rep = double>
+using kV = units::isq::si::voltage<units::isq::si::kilovolt, Rep>;
+template<Representation Rep = double>
+using MV = units::isq::si::voltage<units::isq::si::megavolt, Rep>;
+template<Representation Rep = double>
+using GV = units::isq::si::voltage<units::isq::si::gigavolt, Rep>;
+template<Representation Rep = double>
+using TV = units::isq::si::voltage<units::isq::si::teravolt, Rep>;
+template<Representation Rep = double>
+using PV = units::isq::si::voltage<units::isq::si::petavolt, Rep>;
+template<Representation Rep = double>
+using EV = units::isq::si::voltage<units::isq::si::exavolt, Rep>;
+template<Representation Rep = double>
+using ZV = units::isq::si::voltage<units::isq::si::zettavolt, Rep>;
+template<Representation Rep = double>
+using YV = units::isq::si::voltage<units::isq::si::yottavolt, Rep>;
 
 }  // namespace units::aliases::isq::si::inline voltage
 
-#endif // UNITS_NO_ALIASES
+#endif  // UNITS_NO_ALIASES