diff --git a/CMakeLists.txt b/CMakeLists.txt
index 29e11b68..37125b1b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -73,7 +73,7 @@ add_subdirectory(example)
 # add unit tests
 enable_testing()
 
-# add_subdirectory(test)
+add_subdirectory(test)
 
 # tests for standalone headers
 include(TestPublicHeaders)
diff --git a/docs/design/quantity.rst b/docs/design/quantity.rst
index 8c6b6fd5..47f65096 100644
--- a/docs/design/quantity.rst
+++ b/docs/design/quantity.rst
@@ -6,6 +6,11 @@ quantity
 Interface
 ---------
 
+    The value of a quantity is generally expressed as the product of a number and a unit. The
+    unit is simply a particular example of the quantity concerned which is used as a reference,
+    and the number is the ratio of the value of the quantity to the unit.
+
+
 `quantity` class template provides a similar interface to
 `std::chrono::duration <https://en.cppreference.com/w/cpp/chrono/duration>`_.
 The difference is that it uses ``double`` as a default representation and has
diff --git a/docs/framework/dimensions.rst b/docs/framework/dimensions.rst
index 524d1b8b..fbcc02a0 100644
--- a/docs/framework/dimensions.rst
+++ b/docs/framework/dimensions.rst
@@ -125,3 +125,68 @@ In order to obtain the base/coherent unit of any dimension type a
 
     static_assert(is_same_v<dimension_unit<si::dim_length>, si::metre>);
     static_assert(is_same_v<dimension_unit<si::dim_speed>, si::metre_per_second>);
+
+
+
+
+How do you feel about:
+
+inline constexpr second second;
+?
+
+We could do the same to dimensions to not have to type dim_length{} all the time.
+
+6 replies 2 new
+@JohelEGP
+JohelEGP
+2 days ago
+mp_units::units::second is a variable. The reference isq::si::second could stay a type and s continue to be a variable.
+
+@mpusz
+mpusz
+2 days ago
+Maintainer
+Author
+The problem is the following:
+
+Variables are really needed for a new design. We can ask users to put {} after every dimension unit, and reference types but it would be really nasty and a lot of boilerplate.
+Short names have to be opt-in as they collide with a lot of code (especially on MSVC).
+@JohelEGP
+JohelEGP
+yesterday
+As pointed out by #389 (reply in thread), I think it'd be OK suffix _t to the types.
+
+@mpusz
+mpusz
+10 hours ago
+Maintainer
+Author
+It will be visible in the compilation errors, which is inconvenient :-(
+
+Instead of:
+
+quantity<reference<derived_dimension<length_dim, per<time_dim>>, derived_unit<metre, per<second>>>
+we will have something like:
+
+quantity<reference<derived_dimension<length_dim_t, per<time_dim_t>>, derived_unit<metre_t, per<second_t>>>
+Personally, I like the first output more.
+
+Note that definition like:
+
+inline constexpr second second;
+besides, being really unconventional, is allowed by the language and will not impact our users at all. A user is about to always work with values in the code and observe types in the compilation errors. Using the same nicely blends those two domains together.
+
+@mpusz
+mpusz
+10 hours ago
+Maintainer
+Author
+I could use a list of values instead of types as template parameters in the dervied_dimension and derived_unit but in such case the error would look like:
+
+quantity<reference<derived_dimension<length_dim{}, per<time_dim{}>{}>{}, derived_unit<metre{}, per<second{}>{}>{}>>
+which also is not that nice.
+
+@JohelEGP
+JohelEGP
+6 hours ago
+That's convincing. This justification should definitely be part of the documentation.
diff --git a/docs/framework/units.rst b/docs/framework/units.rst
index c3ad6b96..d0541ccf 100644
--- a/docs/framework/units.rst
+++ b/docs/framework/units.rst
@@ -417,3 +417,18 @@ class template::
 
     To learn more about unknown units please refer to the
     :ref:`use_cases/unknown_dimensions:Working with Unknown Dimensions and Their Units` chapter.
+
+
+## System reference
+
+"It is important to emphasize that each physical quantity has only one coherent SI unit, even
+though this unit can be expressed in different forms by using some of the special names and
+symbols."
+The converse, however, is not true, because in general several different quantities may
+share the same SI unit.
+
+
+For example, for the quantity heat capacity as well as for the
+quantity entropy the SI unit is joule per kelvin. Similarly, for the base quantity electric
+current as well as the derived quantity magnetomotive force the SI unit is the ampere. It is
+therefore important not to use the unit alone to specify the quantity.
diff --git a/example/CMakeLists.txt b/example/CMakeLists.txt
index 686b57ac..c04c32c0 100644
--- a/example/CMakeLists.txt
+++ b/example/CMakeLists.txt
@@ -33,7 +33,7 @@ function(add_example target)
     target_link_libraries(${target} PRIVATE ${ARGN})
 endfunction()
 
-add_example(v2_framework mp-units::core-fmt mp-units::core-io mp-units::si)
+add_example(v2_framework mp-units::core mp-units::si)
 
 # add_example(conversion_factor mp-units::core-fmt mp-units::core-io mp-units::si)
 # add_example(custom_systems mp-units::core-io mp-units::si)
diff --git a/example/v2_framework.cpp b/example/v2_framework.cpp
index 6b9803ac..952f02bc 100644
--- a/example/v2_framework.cpp
+++ b/example/v2_framework.cpp
@@ -20,366 +20,135 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
-// #include <units/concepts.h>
-#include <units/dimension.h>
+#include <units/si/si.h>
 
-namespace units::isq {
-
-inline constexpr struct length_dim : base_dimension<"L"> {
-} length_dim;
-inline constexpr struct mass_dim : base_dimension<"M"> {
-} mass_dim;
-inline constexpr struct time_dim : base_dimension<"T"> {
-} time_dim;
-inline constexpr struct electric_current_dim : base_dimension<"I"> {
-} electric_current_dim;
-// TODO Should the below use basic_symbol_text? How to name it for ASCII?
-inline constexpr struct thermodynamic_temperature_dim : base_dimension<"Θ"> {
-} thermodynamic_temperature_dim;
-inline constexpr struct amount_of_substance_dim : base_dimension<"N"> {
-} amount_of_substance_dim;
-inline constexpr struct luminous_intensity_dim : base_dimension<"J"> {
-} luminous_intensity_dim;
-
-inline constexpr struct frequency_dim : decltype(1 / time_dim) {
-} frequency_dim;
-inline constexpr struct area_dim : decltype(length_dim * length_dim) {
-} area_dim;
-inline constexpr struct volume_dim : decltype(area_dim * length_dim) {
-} volume_dim;
-inline constexpr struct speed_dim : decltype(length_dim / time_dim) {
-} speed_dim;
-inline constexpr struct acceleration_dim : decltype(speed_dim / time_dim) {
-} acceleration_dim;
-
-// inline constexpr auto speed = length / time;
-
-// using speed_dim = decltype(length_dim / time_dim);
-// inline constexpr speed_dim speed_dim;
-
-// template<typename T>
-// concept Length = QuantityOf<T, length_dim>;
-
-}  // namespace units::isq
-
-#include <units/isq/si/prefixes.h>
-#include <units/unit.h>
-
-namespace units {
-
-namespace isq::si {
-
-// length units
-inline constexpr struct metre : named_unit<"m"> {
-} metre;
-inline constexpr struct kilometre : kilo<metre> {
-} kilometre;
-
-inline constexpr struct astronomical_unit : named_scaled_unit<"au", mag<149'597'870'700>(), metre> {
-} astronomical_unit;
-
-// area units
-inline constexpr struct square_metre : derived_unit<decltype(metre * metre)> {
-} square_metre;
-
-// volume units
-inline constexpr struct cubic_metre : derived_unit<decltype(metre * metre * metre)> {
-} cubic_metre;
-
-// time units
-inline constexpr struct second : named_unit<"s"> {
-} second;
-inline constexpr struct minute : named_scaled_unit<"min", mag<60>(), second> {
-} minute;
-inline constexpr struct hour : named_scaled_unit<"h", mag<60>(), minute> {
-} hour;
-inline constexpr struct day : named_scaled_unit<"d", mag<24>(), hour> {
-} day;
-
-// not time units!
-// TODO should those be provided for other scaled units like ms, h, ...
-inline constexpr struct second_squared : derived_unit<decltype(second * second)> {
-} second_squared;
-inline constexpr struct second_cubed : derived_unit<decltype(second * second * second)> {
-} second_cubed;
-
-// mass units
-inline constexpr struct gram : named_unit<"g"> {
-} gram;
-inline constexpr struct kilogram : kilo<gram> {
-} kilogram;
-inline constexpr struct tonne : named_scaled_unit<"t", mag<1000>(), gram> {
-} tonne;
-
-// other units
-inline constexpr struct hertz : named_unit<"Hz", 1 / second> {
-} hertz;
-inline constexpr struct newton : named_unit<"N", kilogram * metre / second_squared> {
-} newton;
-inline constexpr struct pascal : named_unit<"Pa", kilogram / (metre * second_squared)> {
-} pascal;
-inline constexpr struct joule : named_unit<"J", newton * metre> {
-} joule;
-inline constexpr struct watt : named_unit<"W", joule / second> {
-} watt;
-
-namespace unit_symbols {
-
-inline namespace length_units {
-
-inline constexpr auto m = metre;
-inline constexpr auto km = kilometre;
-inline constexpr auto au = astronomical_unit;
-
-}  // namespace length_units
-
-inline namespace area_units {
-
-inline constexpr auto m2 = square_metre;
 
+template<typename T, typename Expr>
+constexpr bool is_of_type(Expr)
+{
+  return std::is_same_v<Expr, T>;
 }
 
-inline namespace volume_units {
+namespace {
 
-inline constexpr auto m3 = cubic_metre;
+using namespace units;
+using namespace units::si::unit_symbols;
 
-}
-
-inline namespace time_units {
-
-inline constexpr auto s = second;
-inline constexpr auto min = minute;
-inline constexpr auto h = hour;
-inline constexpr auto d = day;
-
-inline constexpr auto s2 = second_squared;
-
-}  // namespace time_units
-
-inline namespace mass_units {
-
-inline constexpr auto g = gram;
-inline constexpr auto kg = kilogram;
-inline constexpr auto t = tonne;
-
-}  // namespace mass_units
-
-inline namespace frequency_units {
-
-inline constexpr auto Hz = hertz;
-
-}
-
-inline namespace force_units {
-
-inline constexpr auto N = newton;
-
-}
-
-inline namespace pressure_units {
-
-inline constexpr auto Pa = pascal;
-
-}
-
-inline namespace energy_units {
-
-inline constexpr auto J = joule;
-
-}
-
-inline namespace power_units {
-
-inline constexpr auto W = watt;
-
-}
-
-}  // namespace unit_symbols
-
-}  // namespace isq::si
-}  // namespace units
-
-#include <units/reference.h>
-
-namespace units {
-
-inline constexpr struct dimensionless : system_reference<dimensionless, one_dim, one> {
-} dimensionless;
-
-}  // namespace units
-
-namespace units::isq::si {
-
-inline constexpr struct length : system_reference<length, length_dim, metre> {
-} length;
-inline constexpr struct time : system_reference<time, time_dim, second> {
-} time;
-inline constexpr struct frequency : system_reference<frequency, frequency_dim, hertz> {
-} frequency;
-inline constexpr struct area : system_reference<area, area_dim, square_metre> {
-} area;
-inline constexpr struct volume : system_reference<volume, volume_dim, cubic_metre> {
-} volume;
-inline constexpr struct speed : system_reference<speed, speed_dim, metre / second> {
-} speed;
-inline constexpr struct acceleration : system_reference<acceleration, acceleration_dim, metre / second / second> {
-} acceleration;
-
-}  // namespace units::isq::si
-
-
-template<auto V, typename T>
-inline constexpr bool is_of_type = std::is_same_v<std::remove_cvref_t<decltype(V)>, T>;
-
-namespace units::isq {
-
-// derived dimension expression template syntax verification
-static_assert(is_of_type<1 / time_dim, derived_dimension<struct one_dim, per<struct time_dim>>>);
-static_assert(is_of_type<1 / (1 / time_dim), struct time_dim>);
-
-static_assert(is_of_type<one_dim * time_dim, struct time_dim>);
-static_assert(is_of_type<time_dim * one_dim, struct time_dim>);
-static_assert(is_of_type<one_dim * (1 / time_dim), derived_dimension<struct one_dim, per<struct time_dim>>>);
-static_assert(is_of_type<1 / time_dim * one_dim, derived_dimension<struct one_dim, per<struct time_dim>>>);
-
-static_assert(is_of_type<length_dim * time_dim, derived_dimension<struct length_dim, struct time_dim>>);
-static_assert(is_of_type<length_dim * length_dim, derived_dimension<power<struct length_dim, 2>>>);
+constexpr auto power = 5 * si::power[W];
+static_assert(is_of_type<quantity<reference<struct isq::power_dim, struct si::watt>{}, int>>(power));
 
+constexpr auto speed = 5 * si::speed[m / s];
 static_assert(
-  is_of_type<length_dim * length_dim * time_dim, derived_dimension<power<struct length_dim, 2>, struct time_dim>>);
-static_assert(
-  is_of_type<length_dim * time_dim * length_dim, derived_dimension<power<struct length_dim, 2>, struct time_dim>>);
+  is_of_type<quantity<reference<struct isq::speed_dim, derived_unit<struct si::metre, per<struct si::second>>>{}, int>>(
+    speed));
 
-static_assert(
-  is_of_type<length_dim*(time_dim* length_dim), derived_dimension<power<struct length_dim, 2>, struct time_dim>>);
-static_assert(
-  is_of_type<time_dim*(length_dim* length_dim), derived_dimension<power<struct length_dim, 2>, struct time_dim>>);
+constexpr auto q = 10 * si::length[m] / (2 * si::time[s]);
+static_assert(is_of_type<quantity<reference<derived_dimension<struct isq::length_dim, per<struct isq::time_dim>>,
+                                            derived_unit<struct si::metre, per<struct si::second>>>{},
+                                  int>>(q));
 
-static_assert(is_of_type<1 / time_dim * length_dim, derived_dimension<struct length_dim, per<struct time_dim>>>);
-static_assert(is_of_type<1 / time_dim * time_dim, struct one_dim>);
+constexpr auto distance = 5 * si::speed[m / s] * (5 * si::time[s]);
 
-static_assert(is_of_type<time_dim / one_dim, struct time_dim>);
-static_assert(is_of_type<1 / time_dim / one_dim, derived_dimension<struct one_dim, per<struct time_dim>>>);
+static_assert(is_of_type<quantity<reference<struct isq::length_dim, struct si::metre>{}, int>>(distance));
 
-static_assert(is_of_type<length_dim / time_dim * time_dim, struct length_dim>);
-static_assert(
-  is_of_type<1 / time_dim * (1 / time_dim), derived_dimension<struct one_dim, per<power<struct time_dim, 2>>>>);
-static_assert(is_of_type<1 / (time_dim * time_dim), derived_dimension<struct one_dim, per<power<struct time_dim, 2>>>>);
-static_assert(is_of_type<1 / (1 / (time_dim * time_dim)), derived_dimension<power<struct time_dim, 2>>>);
+constexpr auto dimensionless = 20 * si::speed[m / s] / (10 * si::length[m]) * (5 * si::time[s]);
 
-static_assert(is_of_type<length_dim / time_dim * (1 / time_dim),
-                         derived_dimension<struct length_dim, per<power<struct time_dim, 2>>>>);
-static_assert(is_of_type<length_dim / time_dim*(length_dim / time_dim),
-                         derived_dimension<power<struct length_dim, 2>, per<power<struct time_dim, 2>>>>);
-static_assert(is_of_type<length_dim / time_dim*(time_dim / length_dim), struct one_dim>);
-
-static_assert(is_of_type<speed_dim / acceleration_dim, struct time_dim>);
-static_assert(is_of_type<acceleration_dim / speed_dim, derived_dimension<struct one_dim, per<struct time_dim>>>);
-static_assert(
-  is_of_type<speed_dim * speed_dim / length_dim, derived_dimension<struct length_dim, per<power<struct time_dim, 2>>>>);
-static_assert(is_of_type<1 / (speed_dim * speed_dim) * length_dim,
-                         derived_dimension<power<struct time_dim, 2>, per<struct length_dim>>>);
-
-namespace si {
-
-// comparisons of equivalent dimensions
-static_assert(length_dim / length_dim == one_dim);
-
-static_assert(1 / time_dim == frequency_dim);
-static_assert(1 / frequency_dim == time_dim);
-static_assert(frequency_dim * time_dim == one_dim);
-
-static_assert(length_dim * length_dim == area_dim);
-static_assert(length_dim * length_dim != volume_dim);
-static_assert(area_dim / length_dim == length_dim);
-
-static_assert(length_dim * length_dim * length_dim == volume_dim);
-static_assert(area_dim * length_dim == volume_dim);
-static_assert(volume_dim / length_dim == area_dim);
-static_assert(volume_dim / length_dim / length_dim == length_dim);
-static_assert(area_dim * area_dim / length_dim == volume_dim);
-static_assert(area_dim * (area_dim / length_dim) == volume_dim);
-static_assert(volume_dim / (length_dim * length_dim) == length_dim);
-
-static_assert(length_dim / time_dim == speed_dim);
-static_assert(length_dim * time_dim != speed_dim);
-static_assert(length_dim / time_dim / time_dim != speed_dim);
-static_assert(length_dim / speed_dim == time_dim);
-static_assert(speed_dim * time_dim == length_dim);
-
-static_assert(length_dim / time_dim / time_dim == acceleration_dim);
-static_assert(length_dim / (time_dim * time_dim) == acceleration_dim);
-static_assert(speed_dim / time_dim == acceleration_dim);
-static_assert(speed_dim / acceleration_dim == time_dim);
-static_assert(acceleration_dim * time_dim == speed_dim);
-static_assert(acceleration_dim * (time_dim * time_dim) == length_dim);
-static_assert(acceleration_dim / speed_dim == frequency_dim);
-
-}  // namespace si
-
-}  // namespace units::isq
+static_assert(is_of_type<quantity<reference<struct one_dim, struct one>{}, int>>(dimensionless));
 
 
-namespace units::isq::si {
+// constexpr auto q1 = 10 * si::length[m] / (2 * si::time[s]) + 5 * si::speed[m / s];
+// static_assert(is_of_type<quantity<reference<derived_dimension<struct isq::length_dim, per<struct isq::time_dim>>,
+//                                             derived_unit<struct si::metre, per<struct si::second>>>{},
+//                                   int>>(q1));
+
+// static_assert(quantity_of<decltype(120 * si::length[km] / (2 * si::time[h])), isq::speed_dim>);
+// static_assert(quantity_of<decltype(120 * si::length[km] / (2 * si::time[h])), si::speed[km / h]>);
+// static_assert(!quantity_of<decltype(120 * si::length[km] / (2 * si::time[h])), si::speed[m / s]>);
+
+
+// quantity<reference<speed_dim, derived_unit<si::metre, per<si::second>>>, int> s = 5 * speed[m / s];
+// quantity<reference<derived_dimension<length_dim, per<time_dim>>, derived_unit<metre, per<second>>>, int> q =
+//   10 * length[m] / (2 * si::time[s]);
+
+// auto q1 = 10 * length[m] / (2 * si::time[s]) + 5 * speed[m / s];     // should this be allowed?
+// bool b1 = (10 * length[m] / (2 * si::time[s]) == 5 * speed[m / s]);  // should this be allowed?
+
+// auto q2 = 10 / (2 * si::time[s]) + 5 * frequency[Hz];     // should this be allowed?
+// bool b2 = (10 / (2 * si::time[s]) == 5 * frequency[Hz]);  // should this be allowed?
+
+// auto q3 = 5 * activity[Bq] + 5 * frequency[Hz];     // should this be allowed?
+// auto b3 = (5 * activity[Bq] == 5 * frequency[Hz]);  // should this be allowed?
+
+// auto q4 = 5 * activity[Bq] + 10 / (2 * si::time[s]) + 5 * frequency[Hz];  // should this be allowed?
+
+// auto q5 = 120 * length[km] / (2 * si::time[h]);  // not speed
+// auto q6 = quantity_cast<dim_speed>(120 * length[km] / (2 * si::time[h]));
+// auto q7 = quantity_cast<speed[m / s]>(120 * length[km] / (2 * si::time[h]));
+// quantity<speed[km / h]> s = q5;  // should this implicit conversion be allowed?
+
+}  // namespace
+
+namespace units::si {
 
 // derived unit expression template syntax verification
-static_assert(is_of_type<1 / second, derived_unit<struct one, per<struct second>>>);
-static_assert(is_of_type<1 / (1 / second), struct second>);
+static_assert(is_of_type<derived_unit<struct one, per<struct second>>>(1 / second));
+static_assert(is_of_type<struct second>(1 / (1 / second)));
 
-static_assert(is_of_type<one * second, struct second>);
-static_assert(is_of_type<second * one, struct second>);
-static_assert(is_of_type<one * (1 / second), derived_unit<struct one, per<struct second>>>);
-static_assert(is_of_type<1 / second * one, derived_unit<struct one, per<struct second>>>);
+static_assert(is_of_type<struct second>(one * second));
+static_assert(is_of_type<struct second>(second * one));
+static_assert(is_of_type<derived_unit<struct one, per<struct second>>>(one * (1 / second)));
+static_assert(is_of_type<derived_unit<struct one, per<struct second>>>(1 / second * one));
 
-static_assert(is_of_type<metre * second, derived_unit<struct metre, struct second>>);
-static_assert(is_of_type<metre * metre, derived_unit<power<struct metre, 2>>>);
+static_assert(is_of_type<derived_unit<struct metre, struct second>>(metre * second));
+static_assert(is_of_type<derived_unit<units::power<struct metre, 2>>>(metre * metre));
 
-static_assert(is_of_type<metre * metre * second, derived_unit<power<struct metre, 2>, struct second>>);
-static_assert(is_of_type<metre * second * metre, derived_unit<power<struct metre, 2>, struct second>>);
+static_assert(is_of_type<derived_unit<units::power<struct metre, 2>, struct second>>(metre * metre * second));
+static_assert(is_of_type<derived_unit<units::power<struct metre, 2>, struct second>>(metre * second * metre));
 
-static_assert(is_of_type<metre*(second* metre), derived_unit<power<struct metre, 2>, struct second>>);
-static_assert(is_of_type<second*(metre* metre), derived_unit<power<struct metre, 2>, struct second>>);
+static_assert(is_of_type<derived_unit<units::power<struct metre, 2>, struct second>>(metre * (second * metre)));
+static_assert(is_of_type<derived_unit<units::power<struct metre, 2>, struct second>>(second * (metre * metre)));
 
-static_assert(is_of_type<1 / second * metre, derived_unit<struct metre, per<struct second>>>);
-static_assert(is_of_type<1 / second * second, struct one>);
+static_assert(is_of_type<derived_unit<struct metre, per<struct second>>>(1 / second * metre));
+static_assert(is_of_type<struct one>(1 / second * second));
 
-static_assert(is_of_type<second / one, struct second>);
-static_assert(is_of_type<1 / second / one, derived_unit<struct one, per<struct second>>>);
+static_assert(is_of_type<struct second>(second / one));
+static_assert(is_of_type<derived_unit<struct one, per<struct second>>>(1 / second / one));
 
-static_assert(is_of_type<metre / second * second, struct metre>);
-static_assert(is_of_type<1 / second * (1 / second), derived_unit<struct one, per<power<struct second, 2>>>>);
-static_assert(is_of_type<1 / (second * second), derived_unit<struct one, per<power<struct second, 2>>>>);
-static_assert(is_of_type<1 / (1 / (second * second)), derived_unit<power<struct second, 2>>>);
+static_assert(is_of_type<struct metre>(metre / second * second));
+static_assert(is_of_type<derived_unit<struct one, per<units::power<struct second, 2>>>>(1 / second * (1 / second)));
+static_assert(is_of_type<derived_unit<struct one, per<units::power<struct second, 2>>>>(1 / (second * second)));
+static_assert(is_of_type<derived_unit<units::power<struct second, 2>>>(1 / (1 / (second * second))));
 
-static_assert(is_of_type<metre / second * (1 / second), derived_unit<struct metre, per<power<struct second, 2>>>>);
-static_assert(
-  is_of_type<metre / second*(metre / second), derived_unit<power<struct metre, 2>, per<power<struct second, 2>>>>);
-static_assert(is_of_type<metre / second*(second / metre), struct one>);
+static_assert(is_of_type<derived_unit<struct metre, per<units::power<struct second, 2>>>>(metre / second *
+                                                                                          (1 / second)));
+static_assert(is_of_type<derived_unit<units::power<struct metre, 2>, per<units::power<struct second, 2>>>>(
+  metre / second * (metre / second)));
+static_assert(is_of_type<struct one>(metre / second * (second / metre)));
 
-static_assert(is_of_type<watt / joule, derived_unit<struct watt, per<struct joule>>>);
-static_assert(is_of_type<joule / watt, derived_unit<struct joule, per<struct watt>>>);
+static_assert(is_of_type<derived_unit<struct watt, per<struct joule>>>(watt / joule));
+static_assert(is_of_type<derived_unit<struct joule, per<struct watt>>>(joule / watt));
 
 // comparisons of equivalent units
 static_assert(metre / metre == one);
-static_assert(metre * metre == square_metre);
-static_assert(second * second == second_squared);
-static_assert(second * second * second == second_cubed);
-static_assert(second * (second * second) == second_cubed);
-static_assert(second_squared * second == second_cubed);
-static_assert(second * second_squared == second_cubed);
+// static_assert(metre * metre == square_metre);
+// static_assert(second * second == second_squared);
+// static_assert(second * second * second == second_cubed);
+// static_assert(second * (second * second) == second_cubed);
+// static_assert(second_squared * second == second_cubed);
+// static_assert(second * second_squared == second_cubed);
 
-static_assert(1 / second * metre == metre / second);
-static_assert(metre * (1 / second) == metre / second);
-static_assert((metre / second) * (1 / second) == metre / second / second);
-static_assert((metre / second) * (1 / second) == metre / (second * second));
-static_assert((metre / second) * (1 / second) == metre / second_squared);
+// static_assert(1 / second * metre == metre / second);
+// static_assert(metre * (1 / second) == metre / second);
+// static_assert((metre / second) * (1 / second) == metre / second / second);
+// static_assert((metre / second) * (1 / second) == metre / (second * second));
+// static_assert((metre / second) * (1 / second) == metre / second_squared);
 
-static_assert(hertz == 1 / second);
-static_assert(newton == kilogram * metre / second_squared);
-static_assert(joule == kilogram * square_metre / second_squared);
-static_assert(joule == newton * metre);
-static_assert(watt == joule / second);
-static_assert(watt == kilogram * square_metre / second_cubed);
+// static_assert(hertz == 1 / second);
+// static_assert(newton == kilogram * metre / second_squared);
+// static_assert(joule == kilogram * square_metre / second_squared);
+// static_assert(joule == newton * metre);
+// static_assert(watt == joule / second);
+// static_assert(watt == kilogram * square_metre / second_cubed);
 
 // static_assert(1 / frequency_dim == second);
 // static_assert(frequency_dim * second == one);
@@ -416,18 +185,21 @@ static_assert(watt == kilogram * square_metre / second_cubed);
 // Bq + Hz + 1/s should compile?
 
 
-}  // namespace units::isq::si
+}  // namespace units::si
 
+namespace units {
 
 template<typename T, Dimension auto D, Unit auto U>
 inline constexpr bool is_exactly_quantity_of =
   is_same_v<decltype(T::dimension), decltype(D)> && is_same_v<decltype(T::unit), decltype(U)>;
 
+}
+
 namespace units::isq::si {
 
 // quantity tests
-static_assert(
-  is_exactly_quantity_of<decltype(4 * length[km] / (2 * length[m])), one_dim, derived_unit<kilometre, per<metre>>>);
+// static_assert(
+//   is_exactly_quantity_of<decltype(4 * length[km] / (2 * length[m])), one_dim, derived_unit<kilometre, per<metre>>>);
 
 // static_assert(QuantityOf<decltype(4 * length[km] / (2 * length[m])), one_dim, derived_unit<kilometre, per<metre>>);
 // static_assert(QuantityOf<decltype(4 * length[km] / (2 * length[m])), one_dim, derived_unit<metre, per<millimetre>>);
@@ -435,37 +207,57 @@ static_assert(
 
 }  // namespace units::isq::si
 
+// using namespace units;
+// using namespace units::si;
+// using namespace units::si::unit_symbols;
 
-using namespace units;
-using namespace units::isq::si;
-using namespace units::isq::si::unit_symbols;
+// /* Frequency */ auto freq1 = 20 * frequency[Hz];
+// // /* Frequency */ auto freq2 = 20 / (1 * si::time[s]);
+// quantity<frequency[Hz]> freq3(20);
+// quantity<frequency[1 / s]> freq4(20);
+// quantity<dimensionless[one] / si::time[s]> freq5(20);
 
-/* Frequency */ auto freq1 = 20 * frequency[Hz];
-// /* Frequency */ auto freq2 = 20 / (1 * isq::si::time[s]);
-quantity<frequency[Hz]> freq3(20);
-quantity<frequency[1 / s]> freq4(20);
-quantity<dimensionless[one] / isq::si::time[s]> freq5(20);
-
-/* Speed */ auto speed1 = 20 * speed[m / s];
-/* Speed */ auto speed2 = 20 * (length[m] / isq::si::time[s]);
-quantity<speed[m / s]> speed3(20);
-quantity<length[m] / isq::si::time[s]> speed4(20);
+// /* Speed */ auto speed1 = 20 * speed[m / s];
+// /* Speed */ auto speed2 = 20 * (length[m] / si::time[s]);
+// quantity<speed[km / s]> speed3(20);
+// quantity<length[m] / si::time[s]> speed4(20);
 
 template<typename T>
 void print();
 
-// constexpr auto avg_speed(quantity<length[km]> d, quantity<isq::si::time[h]> t) { return d / t; }
+// constexpr auto avg_speed(quantity<length[km]> d, quantity<si::time[h]> t) { return d / t; }
 
 int main()
 {
-  print<decltype(freq1)>();
-  // print<decltype(freq2)>();
-  print<decltype(freq3)>();
-  print<decltype(freq4)>();
-  print<decltype(freq5)>();
+  // print<decltype(speed)>();
+  // print<decltype(freq1)>();
+  // // print<decltype(freq2)>();
+  // print<decltype(freq3)>();
+  // print<decltype(freq4)>();
+  // print<decltype(freq5)>();
 
-  print<decltype(speed1)>();
-  print<decltype(speed2)>();
-  print<decltype(speed3)>();
-  print<decltype(speed4)>();
+  // print<decltype(speed1)>();
+  // print<decltype(speed2)>();
+  // print<decltype(speed3)>();
+  // print<decltype(speed4)>();
 }
+
+
+// 1 * joule + 1 * erg ???
+
+// joule * erg???
+// joule / erg???
+
+// auto d1 = 42 * isq::length_dim[si::kilo<si::metre>];
+// auto d2 = 42 * isq::length_dim[cgs::centimetre];
+
+// auto s1 = 42 * isq::speed_dim[si::metre / si::second];
+// auto s2 = 42 * isq::speed_dim[cgs::centimetre / si::second];
+// auto e1 = 42 * isq::energy_dim[si::joule];
+// auto e2 = 42 * isq::energy_dim[cgs::erg];
+// auto e2_bad = 42 * isq::energy_dim[cgs::erg / si::second];
+// auto p1 = 42 * isq::power_dim[si::watt];
+// auto p2 = 42 * isq::power_dim[cgs::erg / si::second];
+
+// type of Rep{1} * (mag<ratio(662'607'015, 100'000'000)> * mag_power<10, -34> * energy[joule] * time[second])
+// and inline constexpr auto planck_constant = Rep{1} * mag_planck * energy[joule] * time[second];
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 32a5e555..ba908f6f 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -38,13 +38,21 @@ if(${projectPrefix}AS_SYSTEM_HEADERS)
 endif()
 
 add_subdirectory(core)
-add_subdirectory(core-fmt)
-add_subdirectory(core-io)
+
+# add_subdirectory(core-fmt)
+# add_subdirectory(core-io)
 add_subdirectory(systems)
 
 # project-wide wrapper
 add_library(mp-units INTERFACE)
-target_link_libraries(mp-units INTERFACE mp-units::core mp-units::core-io mp-units::core-fmt mp-units::systems)
+target_link_libraries(
+    mp-units
+    INTERFACE
+        mp-units::core
+        # mp-units::core-io
+        # mp-units::core-fmt
+        mp-units::systems
+)
 add_library(mp-units::mp-units ALIAS mp-units)
 install(TARGETS mp-units EXPORT mp-unitsTargets)
 
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index e39c7bd9..f9a1e98b 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -37,26 +37,26 @@ check_libcxx_in_use(${projectPrefix}LIBCXX)
 add_library(
     mp-units-core
     INTERFACE
-    include/units/chrono.h
+    # include/units/chrono.h
     include/units/concepts.h
     include/units/customization_points.h
     include/units/dimension.h
-    include/units/generic/angle.h
-    include/units/generic/dimensionless.h
-    include/units/generic/solid_angle.h
-    include/units/kind.h
+    # include/units/generic/angle.h
+    # include/units/generic/dimensionless.h
+    # include/units/generic/solid_angle.h
+    # include/units/kind.h
     include/units/magnitude.h
-    include/units/math.h
-    include/units/point_origin.h
+    # include/units/math.h
+    # include/units/point_origin.h
     include/units/quantity.h
-    include/units/quantity_cast.h
-    include/units/quantity_kind.h
-    include/units/quantity_point.h
-    include/units/quantity_point_kind.h
-    include/units/random.h
+    # include/units/quantity_cast.h
+    # include/units/quantity_kind.h
+    # include/units/quantity_point.h
+    # include/units/quantity_point_kind.h
+    # include/units/random.h
     include/units/ratio.h
     include/units/reference.h
-    include/units/symbol_text.h
+    # include/units/symbol_text.h
     include/units/unit.h
 )
 target_compile_features(mp-units-core INTERFACE cxx_std_20)
diff --git a/src/core/include/units/bits/common_type.h b/src/core/include/units/bits/common_type.h
index 8955d5ab..05288572 100644
--- a/src/core/include/units/bits/common_type.h
+++ b/src/core/include/units/bits/common_type.h
@@ -22,58 +22,56 @@
 
 #pragma once
 
-#include <units/bits/dimension_op.h>
-#include <units/bits/equivalent.h>
-#include <units/quantity_cast.h>
+#include <units/concepts.h>
+#include <units/dimension.h>
+#include <units/unit.h>
+// #include <units/bits/equivalent.h>
+// #include <units/quantity_cast.h>
 
 namespace units {
 
-template<Dimension D, UnitOf<D> U>
-struct reference;
+// template<PointOrigin O, UnitOf<typename O::dimension> U, Representation Rep>
+// class quantity_point;
 
-template<Dimension D, UnitOf<D> U, Representation Rep>
-class quantity;
+// template<Kind K, UnitOf<typename K::dimension> U, Representation Rep>
+// class quantity_kind;
 
-template<PointOrigin O, UnitOf<typename O::dimension> U, Representation Rep>
-class quantity_point;
+// template<PointKind PK, UnitOf<typename PK::dimension> U, Representation Rep>
+// class quantity_point_kind;
 
-template<Kind K, UnitOf<typename K::dimension> U, Representation Rep>
-class quantity_kind;
+// TODO common_unit should use common_magnitude(U1::mag, U2::mag)
 
-template<PointKind PK, UnitOf<typename PK::dimension> U, Representation Rep>
-class quantity_point_kind;
+template<Dimension D1, Dimension D2>
+  requires(equivalent(D1{}, D2{}))
+using common_dimension = conditional<std::is_same_v<D1, D2>, D1, detail::dim_type<D1>>;
+
+template<Unit U1, Unit U2>
+// requires(equivalent<U1, U2>)
+using common_unit = U1;
 
 namespace detail {
 
 template<typename R1, typename R2>
 struct common_quantity_reference_impl;
 
-template<typename D, typename U>
-struct common_quantity_reference_impl<reference<D, U>, reference<D, U>> {
-  using type = reference<D, U>;
+template<typename R>
+struct common_quantity_reference_impl<R, R> {
+  using type = R;
 };
 
 template<typename D, typename U1, typename U2>
 struct common_quantity_reference_impl<reference<D, U1>, reference<D, U2>> {
-  using type = reference<D, downcast_unit<D, common_magnitude(U1::mag, U2::mag)>>;
+  using type = reference<D, common_unit<U1, U2>>;
 };
 
-template<typename D1, typename U1, typename D2, typename U2>
-  requires(same_unit_reference<dimension_unit<D1>, dimension_unit<D2>>::value)
-struct common_quantity_reference_impl<reference<D1, U1>, reference<D2, U2>> {
-  using type = reference<D1, downcast_unit<D1, common_magnitude(U1::mag, U2::mag)>>;
+template<typename R1, typename R2>
+  requires(equivalent(R1::dimension, R2::dimension))
+struct common_quantity_reference_impl<R1, R2> {
+  using type = reference<common_dimension<decltype(R1::dimension), decltype(R2::dimension)>,
+                         common_unit<decltype(R1::unit), decltype(R2::unit)>>;
 };
 
-template<typename D1, typename U1, typename D2, typename U2>
-struct common_quantity_reference_impl<reference<D1, U1>, reference<D2, U2>> {
-  static constexpr UNITS_MSVC_WORKAROUND(Magnitude) auto mag = common_magnitude(reference<D1, U1>::mag,
-                                                                                reference<D2, U2>::mag);
-  using dimension = conditional<is_specialization_of<D1, unknown_dimension>, D2, D1>;
-  using unit = downcast_unit<dimension, mag / dimension::mag>;
-  using type = reference<dimension, unit>;
-};
-
-template<Quantity Q1, QuantityEquivalentTo<Q1> Q2>
+template<Quantity Q1, quantity_equivalent_to<Q1> Q2>
 using common_quantity_reference =
   TYPENAME detail::common_quantity_reference_impl<std::remove_const_t<decltype(Q1::reference)>,
                                                   std::remove_const_t<decltype(Q2::reference)>>::type;
@@ -83,43 +81,42 @@ using common_quantity_reference =
 
 namespace std {
 
-template<units::Quantity Q1, units::QuantityEquivalentTo<Q1> Q2>
+template<units::Quantity Q1, units::quantity_equivalent_to<Q1> Q2>
   requires requires { typename common_type_t<typename Q1::rep, typename Q2::rep>; }
 struct common_type<Q1, Q2> {
 private:
   using ref = units::detail::common_quantity_reference<Q1, Q2>;
 public:
-  using type =
-    units::quantity<typename ref::dimension, typename ref::unit, common_type_t<typename Q1::rep, typename Q2::rep>>;
+  using type = units::quantity<ref{}, common_type_t<typename Q1::rep, typename Q2::rep>>;
 };
 
-template<units::QuantityPoint QP1, units::QuantityPointEquivalentTo<QP1> QP2>
-  requires requires { typename common_type_t<typename QP1::rep, typename QP2::rep>; }
-struct common_type<QP1, QP2> {
-  using type =
-    units::quantity_point<units::rebind_point_origin_dimension<
-                            typename QP1::origin, typename common_type_t<typename QP1::quantity_type,
-                                                                         typename QP2::quantity_type>::dimension>,
-                          typename common_type_t<typename QP1::quantity_type, typename QP2::quantity_type>::unit,
-                          typename common_type_t<typename QP1::quantity_type, typename QP2::quantity_type>::rep>;
-};
+// template<units::QuantityPoint QP1, units::QuantityPointEquivalentTo<QP1> QP2>
+//   requires requires { typename common_type_t<typename QP1::rep, typename QP2::rep>; }
+// struct common_type<QP1, QP2> {
+//   using type =
+//     units::quantity_point<units::rebind_point_origin_dimension<
+//                             typename QP1::origin, typename common_type_t<typename QP1::quantity_type,
+//                                                                          typename QP2::quantity_type>::dimension>,
+//                           typename common_type_t<typename QP1::quantity_type, typename QP2::quantity_type>::unit,
+//                           typename common_type_t<typename QP1::quantity_type, typename QP2::quantity_type>::rep>;
+// };
 
-template<units::QuantityKind QK1, units::QuantityKindEquivalentTo<QK1> QK2>
-  requires requires { typename common_type_t<typename QK1::rep, typename QK2::rep>; }
-struct common_type<QK1, QK2> {
-  using type =
-    units::quantity_kind<typename QK1::kind_type,
-                         typename common_type_t<typename QK1::quantity_type, typename QK2::quantity_type>::unit,
-                         typename common_type_t<typename QK1::quantity_type, typename QK2::quantity_type>::rep>;
-};
+// template<units::QuantityKind QK1, units::QuantityKindEquivalentTo<QK1> QK2>
+//   requires requires { typename common_type_t<typename QK1::rep, typename QK2::rep>; }
+// struct common_type<QK1, QK2> {
+//   using type =
+//     units::quantity_kind<typename QK1::kind_type,
+//                          typename common_type_t<typename QK1::quantity_type, typename QK2::quantity_type>::unit,
+//                          typename common_type_t<typename QK1::quantity_type, typename QK2::quantity_type>::rep>;
+// };
 
-template<units::QuantityPointKind QPK1, units::QuantityPointKindEquivalentTo<QPK1> QPK2>
-  requires requires { typename common_type_t<typename QPK1::rep, typename QPK2::rep>; }
-struct common_type<QPK1, QPK2> {
-  using type = units::quantity_point_kind<
-    typename QPK1::point_kind_type,
-    typename common_type_t<typename QPK1::quantity_kind_type, typename QPK2::quantity_kind_type>::unit,
-    typename common_type_t<typename QPK1::quantity_kind_type, typename QPK2::quantity_kind_type>::rep>;
-};
+// template<units::QuantityPointKind QPK1, units::QuantityPointKindEquivalentTo<QPK1> QPK2>
+//   requires requires { typename common_type_t<typename QPK1::rep, typename QPK2::rep>; }
+// struct common_type<QPK1, QPK2> {
+//   using type = units::quantity_point_kind<
+//     typename QPK1::point_kind_type,
+//     typename common_type_t<typename QPK1::quantity_kind_type, typename QPK2::quantity_kind_type>::unit,
+//     typename common_type_t<typename QPK1::quantity_kind_type, typename QPK2::quantity_kind_type>::rep>;
+// };
 
 }  // namespace std
diff --git a/src/core/include/units/bits/expression_template.h b/src/core/include/units/bits/expression_template.h
index 089cf147..e702b0bc 100644
--- a/src/core/include/units/bits/expression_template.h
+++ b/src/core/include/units/bits/expression_template.h
@@ -34,7 +34,39 @@ struct type_list {};
 template<typename T, typename... Ts>
 struct per {};
 
+namespace detail {
+
+template<int Num, int... Den>
+inline constexpr bool valid_ratio = true;
+
+template<int... Den>
+inline constexpr bool valid_ratio<0, Den...> = false;
+
+template<int Num>
+inline constexpr bool valid_ratio<Num, 0> = false;
+
+template<>
+inline constexpr bool valid_ratio<0, 0> = false;
+
+template<int Num, int... Den>
+inline constexpr bool positive_ratio = (Num > 0);
+
+template<int Num, int Den>
+inline constexpr bool positive_ratio<Num, Den> = (Num * Den > 0);
+
+template<int Num, int... Den>
+inline constexpr bool ratio_one = false;
+
+template<>
+inline constexpr bool ratio_one<1> = true;
+
+template<int N>
+inline constexpr bool ratio_one<N, N> = true;
+
+}  // namespace detail
+
 template<typename F, int Num, int... Den>
+  requires(detail::valid_ratio<Num, Den...> && detail::positive_ratio<Num, Den...> && !detail::ratio_one<Num, Den...>)
 struct power {
   using factor = F;
   static constexpr ratio exponent{Num, Den...};
@@ -146,9 +178,9 @@ using expr_consolidate = typename expr_consolidate_impl<List>::type;
 
 // expr_simplify
 
-template<typename T, typename powerNum, typename powerDen>
+template<typename T, ratio Num, ratio Den>
 struct expr_simplify_power {
-  static constexpr ratio r = powerNum::exponent - powerDen::exponent;
+  static constexpr ratio r = Num - Den;
   using type = power_or_T<T, ratio{abs(r.num), r.den}>;
   using num = conditional<(r > 0), type_list<type>, type_list<>>;
   using den = conditional<(r < 0), type_list<type>, type_list<>>;
@@ -179,7 +211,7 @@ struct expr_simplify<type_list<T, NRest...>, type_list<T, DRest...>, Pred> :
 template<typename T, typename... NRest, int... Ints, typename... DRest, template<typename, typename> typename Pred>
 struct expr_simplify<type_list<power<T, Ints...>, NRest...>, type_list<T, DRest...>, Pred> {
   using impl = expr_simplify<type_list<NRest...>, type_list<DRest...>, Pred>;
-  using type = expr_simplify_power<T, power<T, Ints...>, power<T, 1>>;
+  using type = expr_simplify_power<T, power<T, Ints...>::exponent, ratio{1}>;
   using num = type_list_join<typename type::num, typename impl::num>;
   using den = type_list_join<typename type::den, typename impl::den>;
 };
@@ -187,7 +219,7 @@ struct expr_simplify<type_list<power<T, Ints...>, NRest...>, type_list<T, DRest.
 template<typename T, typename... NRest, typename... DRest, int... Ints, template<typename, typename> typename Pred>
 struct expr_simplify<type_list<T, NRest...>, type_list<power<T, Ints...>, DRest...>, Pred> {
   using impl = expr_simplify<type_list<NRest...>, type_list<DRest...>, Pred>;
-  using type = expr_simplify_power<T, power<T, 1>, power<T, Ints...>>;
+  using type = expr_simplify_power<T, ratio{1}, power<T, Ints...>::exponent>;
   using num = type_list_join<typename impl::num, typename type::num>;
   using den = type_list_join<typename impl::den, typename type::den>;
 };
@@ -197,7 +229,7 @@ template<typename T, typename... NRest, int... Ints1, typename... DRest, int...
   requires(!std::same_as<power<T, Ints1...>, power<T, Ints2...>>)
 struct expr_simplify<type_list<power<T, Ints1...>, NRest...>, type_list<power<T, Ints2...>, DRest...>, Pred> {
   using impl = expr_simplify<type_list<NRest...>, type_list<DRest...>, Pred>;
-  using type = expr_simplify_power<T, power<T, Ints1...>, power<T, Ints2...>>;
+  using type = expr_simplify_power<T, power<T, Ints1...>::exponent, power<T, Ints2...>::exponent>;
   using num = type_list_join<typename impl::num, typename type::num>;
   using den = type_list_join<typename impl::den, typename type::den>;
 };
diff --git a/src/core/include/units/bits/external/type_name.h b/src/core/include/units/bits/external/type_name.h
index e65ec9d1..9a74759f 100644
--- a/src/core/include/units/bits/external/type_name.h
+++ b/src/core/include/units/bits/external/type_name.h
@@ -5,7 +5,7 @@
 #include <string_view>
 
 template<typename T>
-constexpr auto type_name()
+[[nodiscard]] consteval std::string_view type_name()
 {
   std::string_view name, prefix, suffix;
 #ifdef __clang__
diff --git a/src/core/include/units/bits/external/type_traits.h b/src/core/include/units/bits/external/type_traits.h
index 286a713e..6d9df5df 100644
--- a/src/core/include/units/bits/external/type_traits.h
+++ b/src/core/include/units/bits/external/type_traits.h
@@ -77,4 +77,7 @@ template<typename T, template<typename...> typename Type>
 // inline constexpr bool // TODO: Replace with concept when it works with MSVC
 concept is_derived_from_specialization_of = requires(T* t) { detail::to_base_specialization_of<Type>(t); };
 
+template<typename T, typename... Ts>
+concept one_of = (... || std::same_as<T, Ts>);
+
 }  // namespace units
diff --git a/src/core/include/units/bits/unit_text.h b/src/core/include/units/bits/unit_text.h
index db0cf31a..9421e5ef 100644
--- a/src/core/include/units/bits/unit_text.h
+++ b/src/core/include/units/bits/unit_text.h
@@ -37,7 +37,7 @@ constexpr auto magnitude_text()
 {
   constexpr auto exp10 = extract_power_of_10(M);
 
-  constexpr Magnitude auto base = M / pow<exp10>(mag<10>());
+  constexpr Magnitude auto base = M / mag_power<10, exp10>;
   constexpr Magnitude auto num = numerator(base);
   constexpr Magnitude auto den = denominator(base);
   static_assert(base == num / den, "Printing rational powers, or irrational bases, not yet supported");
diff --git a/src/core/include/units/concepts.h b/src/core/include/units/concepts.h
index edf5e4b0..c506c2ac 100644
--- a/src/core/include/units/concepts.h
+++ b/src/core/include/units/concepts.h
@@ -23,6 +23,94 @@
 #pragma once
 
 // IWYU pragma: begin_exports
-#include <units/bits/basic_concepts.h>
-#include <units/bits/quantity_of.h>
+// #include <units/bits/basic_concepts.h>
+// #include <units/bits/quantity_of.h>
 // IWYU pragma: end_exports
+#include <units/bits/external/type_traits.h>
+#include <units/dimension.h>
+#include <units/unit.h>
+
+namespace units {
+
+template<Dimension D, Unit U>
+struct reference;
+
+/**
+ * @brief A concept matching all references in the library.
+ *
+ * Satisfied by all specializations of @c reference.
+ */
+template<typename T>
+concept Reference = is_specialization_of<T, reference>;
+
+namespace detail {
+
+template<typename T>
+inline constexpr bool is_quantity = false;
+
+}
+
+template<typename T>
+concept Quantity = detail::is_quantity<T>;
+
+template<typename T, typename U>
+concept common_type_with_ =  // exposition only
+  (std::same_as<std::common_type_t<T, U>, std::common_type_t<U, T>>) &&
+  (std::constructible_from<std::common_type_t<T, U>, T>) && (std::constructible_from<std::common_type_t<T, U>, U>);
+
+template<typename T, typename U = T>
+concept scalable_number_ =  // exposition only
+  (std::regular_invocable<std::multiplies<>, T, U>) && (std::regular_invocable<std::divides<>, T, U>);
+
+template<typename T>
+concept castable_number_ =  // exposition only
+  common_type_with_<T, std::intmax_t> && scalable_number_<std::common_type_t<T, std::intmax_t>>;
+
+template<typename T>
+concept scalable_ =  // exposition only
+  castable_number_<T> || (requires { typename T::value_type; } && castable_number_<typename T::value_type> &&
+                          scalable_number_<T, std::common_type_t<typename T::value_type, std::intmax_t>>);
+
+template<typename T, typename U>
+concept scalable_with_ =  // exposition only
+  common_type_with_<T, U> && scalable_<std::common_type_t<T, U>>;
+
+template<typename T>
+concept Representation = (!Quantity<T>) &&
+                         // (!QuantityLike<T>) && (!wrapped_quantity_<T>) &&
+                         std::regular<T> && scalable_<T>;
+
+template<Reference auto R, Representation Rep>
+class quantity;
+
+namespace detail {
+
+template<auto R, typename Rep>
+inline constexpr bool is_quantity<quantity<R, Rep>> = true;
+
+// template<typename T>
+//   requires units::is_derived_from_specialization_of<T, units::quantity>
+// inline constexpr bool is_quantity<T> = true;
+
+}  // namespace detail
+
+/**
+ * @brief A concept matching all quantities with provided dimension
+ *
+ * Satisfied by all quantities with a dimension being the instantiation derived from
+ * the provided dimension type.
+ */
+template<typename Q, auto V>
+concept quantity_of = Quantity<Q> && ((Dimension<std::remove_const_t<decltype(V)>> && Q::dimension == V) ||
+                                      (Reference<std::remove_const_t<decltype(V)>> && Q::dimension == V.dimension));
+
+/**
+ * @brief A concept matching two equivalent quantities
+ *
+ * Satisfied by quantities having equivalent dimensions and units.
+ */
+template<typename Q1, typename Q2>
+concept quantity_equivalent_to = Quantity<Q1> && equivalent(Q1::dimension, Q2::dimension) &&
+                                 equivalent(Q1::unit, Q2::unit);
+
+}  // namespace units
diff --git a/src/core/include/units/dimension.h b/src/core/include/units/dimension.h
index 407088f1..fd3740a5 100644
--- a/src/core/include/units/dimension.h
+++ b/src/core/include/units/dimension.h
@@ -52,6 +52,12 @@ namespace detail {
 template<basic_fixed_string Symbol>
 void to_base_base_dimension(const volatile base_dimension<Symbol>*);
 
+template<typename T>
+inline constexpr bool is_specialization_of_base_dimension = false;
+
+template<basic_fixed_string Symbol>
+inline constexpr bool is_specialization_of_base_dimension<base_dimension<Symbol>> = true;
+
 }  // namespace detail
 
 /**
@@ -60,13 +66,18 @@ void to_base_base_dimension(const volatile base_dimension<Symbol>*);
  * Satisfied by all dimension types derived from an specialization of `base_dimension`.
  */
 template<typename T>
-concept BaseDimension = requires(T* t) { detail::to_base_base_dimension(t); };
+concept BaseDimension = requires(T* t) { detail::to_base_base_dimension(t); } &&
+                        (!detail::is_specialization_of_base_dimension<T>);
 
 template<BaseDimension D1, BaseDimension D2>
 struct base_dimension_less : std::bool_constant<(D1::symbol < D2::symbol)> {};
 
-// TODO Can we provide a smarter implementation?
-std::false_type is_derived_dimension(...);
+namespace detail {
+
+template<typename T>
+inline constexpr bool is_derived_dimension = false;
+
+}
 
 /**
  * @brief A concept matching all derived dimensions in the library.
@@ -74,7 +85,7 @@ std::false_type is_derived_dimension(...);
  * Satisfied by all dimension types derived from an specialization of `derived_dimension`.
  */
 template<typename T>
-concept DerivedDimension = decltype(is_derived_dimension(std::declval<T*>()))::value;
+concept DerivedDimension = detail::is_derived_dimension<T>;
 
 /**
  * @brief A concept matching all dimensions in the library.
@@ -107,8 +118,20 @@ struct derived_dimension : detail::expr_fractions<derived_dimension<>, Ds...> {
   using type = derived_dimension<Ds...>;
 };
 
-template<typename... Args>
-std::true_type is_derived_dimension(const volatile derived_dimension<Args...>*);
+namespace detail {
+
+template<typename... Ds>
+void to_base_specialization_of_derived_dimension(const volatile derived_dimension<Ds...>*);
+
+template<typename T>
+inline constexpr bool is_derived_from_specialization_of_derived_dimension =
+  requires(T * t) { to_base_specialization_of_derived_dimension(t); };
+
+template<typename T>
+  requires is_derived_from_specialization_of_derived_dimension<T>
+inline constexpr bool is_derived_dimension<T> = true;
+
+}  // namespace detail
 
 /**
  * @brief Dimension one
@@ -162,6 +185,12 @@ template<Dimension D>
 
 template<Dimension D1, Dimension D2>
 [[nodiscard]] consteval bool operator==(D1, D2)
+{
+  return is_same_v<D1, D2>;
+}
+
+template<Dimension D1, Dimension D2>
+[[nodiscard]] consteval bool equivalent(D1, D2)
 {
   return is_same_v<detail::dim_type<D1>, detail::dim_type<D2>>;
 }
diff --git a/src/core/include/units/magnitude.h b/src/core/include/units/magnitude.h
index 50dfc232..f81da0c5 100644
--- a/src/core/include/units/magnitude.h
+++ b/src/core/include/units/magnitude.h
@@ -22,7 +22,10 @@
 
 #pragma once
 
+#include <units/bits/expression_template.h>
 #include <units/bits/external/hacks.h>
+#include <units/bits/external/type_name.h>
+#include <units/bits/external/type_traits.h>
 #include <units/bits/prime.h>
 #include <units/ratio.h>
 #include <concepts>
@@ -40,31 +43,47 @@ using factorizer = wheel_factorizer<4>;
 
 }  // namespace detail
 
-/**
- * @brief  A type to represent a standalone constant value.
- */
-template<auto V>
-struct constant {
-  static constexpr auto value = V;
-};
-
-// is_derived_from_specialization_of_constant
 namespace detail {
 
-template<auto V>
-void to_base_specialization_of_constant(const volatile constant<V>*);
+template<typename T>
+inline constexpr bool is_magnitude = false;
 
 template<typename T>
-inline constexpr bool is_derived_from_specialization_of_constant =
-  requires(T * t) { to_base_specialization_of_constant(t); };
+inline constexpr bool is_specialization_of_magnitude = false;
 
 }  // namespace detail
 
-
+/**
+ * @brief  Concept to detect whether T is a valid Magnitude.
+ */
 template<typename T>
-concept Constant = detail::is_derived_from_specialization_of_constant<T>;
+concept Magnitude = detail::is_magnitude<T>;
 
-struct pi_v : constant<std::numbers::pi_v<long double>> {};
+/**
+ * @brief  A type to represent a standalone constant value.
+ */
+// template<auto V>
+// struct constant {
+//   static constexpr auto value = V;
+// };
+
+// // is_derived_from_specialization_of_constant
+// namespace detail {
+
+// template<auto V>
+// void to_base_specialization_of_constant(const volatile constant<V>*);
+
+// template<typename T>
+// inline constexpr bool is_derived_from_specialization_of_constant =
+//   requires(T * t) { to_base_specialization_of_constant(t); };
+
+// }  // namespace detail
+
+
+// template<typename T>
+// concept Constant = detail::is_derived_from_specialization_of_constant<T>;
+
+// struct pi_v : constant<std::numbers::pi_v<long double>> {};
 
 /**
  * @brief  Any type which can be used as a basis vector in a PowerV.
@@ -106,20 +125,26 @@ struct pi_v : constant<std::numbers::pi_v<long double>> {};
  * _existing_ bases, including both prime numbers and any other irrational bases.  For example, even though `sqrt(2)` is
  * irrational, we must not ever use it as a base; instead, we would use `base_power{2, ratio{1, 2}}`.
  */
-template<typename T>
-concept PowerVBase = Constant<T> || std::integral<T>;
-
-// TODO Unify with `power` if UTPs (P1985) are accepted by the Committee
-template<PowerVBase auto V, int Num, int... Den>
-  requires(Num != 0)
-struct power_v {
-  static constexpr auto base = V;
-  static constexpr ratio exponent{Num, Den...};
-  static_assert(exponent != 1);
-};
 
 namespace detail {
 
+template<typename T>
+inline constexpr bool is_named_magnitude = Magnitude<T> && !detail::is_specialization_of_magnitude<T>;
+
+}
+
+template<typename T>
+concept PowerVBase = one_of<T, int, std::intmax_t, long double> || detail::is_named_magnitude<T>;
+
+// TODO Unify with `power` if UTPs (P1985) are accepted by the Committee
+template<PowerVBase auto V, int Num, int... Den>
+  requires(detail::valid_ratio<Num, Den...> && !detail::ratio_one<Num, Den...>)
+struct power_v {
+  static constexpr auto base = V;
+  static constexpr ratio exponent{Num, Den...};
+};
+
+namespace detail {
 
 /**
  * @brief  Deduction guides for base_power: only permit deducing integral bases.
@@ -149,6 +174,8 @@ concept PowerV = detail::is_specialization_of_power_v<T>;
 
 namespace detail {
 
+// We do not want magnitude type to have the `l` literal after a value for a small integral number.
+// For example this modifies `magnitude<3l>` to be `magnitude<3>`
 template<auto V>
 [[nodiscard]] consteval auto shorten_T()
 {
@@ -156,8 +183,10 @@ template<auto V>
     if constexpr (V <= std::numeric_limits<int>::max()) {
       return static_cast<int>(V);
     } else {
-      return V;
+      return static_cast<std::intmax_t>(V);
     }
+  } else if constexpr (std::floating_point<decltype(V)>) {
+    return static_cast<long double>(V);
   } else {
     return V;
   }
@@ -178,7 +207,7 @@ template<PowerVBase auto V, ratio R>
   }
 };
 
-consteval auto inverse(PowerV auto bp) { return power_v_or_T<bp.base, bp.exponent * (-1)>(); }
+// consteval auto inverse(PowerV auto bp) { return power_v_or_T<bp.base, bp.exponent * (-1)>(); }
 
 // `widen_t` gives the widest arithmetic type in the same category, for intermediate computations.
 // template<typename T>
@@ -253,35 +282,35 @@ consteval auto inverse(PowerV auto bp) { return power_v_or_T<bp.base, bp.exponen
 //
 // The input is the desired result, but in a (wider) intermediate type.  The point of this function
 // is to cast to the desired type, but avoid overflow in doing so.
-// template<typename To, typename From>
-// // TODO(chogg): Migrate this to use `treat_as_floating_point`.
-//   requires(!std::is_integral_v<To> || std::is_integral_v<From>)
-// constexpr To checked_static_cast(From x)
-// {
-//   // This function should only ever be called at compile time.  The purpose of these exceptions is
-//   // to produce compiler errors, because we cannot `static_assert` on function arguments.
-//   if constexpr (std::is_integral_v<To>) {
-//     if (!std::in_range<To>(x)) {
-//       throw std::invalid_argument{"Cannot represent magnitude in this type"};
-//     }
-//   }
+template<typename To, typename From>
+// TODO(chogg): Migrate this to use `treat_as_floating_point`.
+  requires(!std::is_integral_v<To> || std::is_integral_v<From>)
+constexpr To checked_static_cast(From x)
+{
+  // This function should only ever be called at compile time.  The purpose of these exceptions is
+  // to produce compiler errors, because we cannot `static_assert` on function arguments.
+  if constexpr (std::is_integral_v<To>) {
+    if (!std::in_range<To>(x)) {
+      throw std::invalid_argument{"Cannot represent magnitude in this type"};
+    }
+  }
+
+  return static_cast<To>(x);
+}
 
-//   return static_cast<To>(x);
-// }
 }  // namespace detail
 
 /**
  * @brief  Equality detection for two base powers.
  */
-template<PowerV T, PowerV U>
-[[nodiscard]] consteval bool operator==(T, U)
-{
-  return std::is_same_v<T, U>;
-}
+// template<PowerV T, PowerV U>
+// [[nodiscard]] consteval bool operator==(T, U)
+// {
+//   return std::is_same_v<T, U>;
+// }
 
 template<typename T>
-concept MagnitudeSpec = std::integral<T> || Constant<T> || PowerV<T>;
-
+concept MagnitudeSpec = PowerVBase<T> || PowerV<T>;
 
 // A variety of implementation detail helpers.
 namespace detail {
@@ -295,17 +324,6 @@ template<MagnitudeSpec Element>
     return element;
 }
 
-template<MagnitudeSpec Element>
-[[nodiscard]] consteval auto get_base_value(Element element)
-{
-  const auto base = get_base(element);
-  using base_type = decltype(base);
-  if constexpr (std::integral<base_type>)
-    return base;
-  else
-    return base_type::value;
-}
-
 template<MagnitudeSpec Element>
 [[nodiscard]] consteval ratio get_exponent(Element)
 {
@@ -338,88 +356,92 @@ template<MagnitudeSpec Element>
 }
 
 // A way to check whether a number is prime at compile time.
-[[nodiscard]] consteval bool is_prime(std::intmax_t n)
-{
-  return (n >= 0) && factorizer::is_prime(static_cast<std::size_t>(n));
-}
+// [[nodiscard]] consteval bool is_prime(std::intmax_t n)
+// {
+//   return (n >= 0) && factorizer::is_prime(static_cast<std::size_t>(n));
+// }
 
-template<MagnitudeSpec Element>
-[[nodiscard]] consteval bool is_valid_element(Element element)
-{
-  if (get_exponent(element) == 0) {
-    return false;
-  }
-  if constexpr (std::integral<decltype(get_base(element))>) {
-    // Some prime numbers are so big, that we can't check their primality without exhausting limits on constexpr steps
-    // and/or iterations.  We can still _perform_ the factorization for these by using the `known_first_factor`
-    // workaround.  However, we can't _check_ that they are prime, because this workaround depends on the input being
-    // usable in a constexpr expression.  This is true for `prime_factorization` (below), where the input `N` is a
-    // template parameter, but is not true for our case, where the input `bp.get_base()` is a function parameter.  (See
-    // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1045r1.html for some background reading on this
-    // distinction.)
-    //
-    // In our case: we simply give up on excluding every possible ill-formed base power, and settle for catching the
-    // most likely and common mistakes.
-    if (const bool too_big_to_check = (get_base_value(element) > 1'000'000'000)) {
-      return true;
-    }
+// template<MagnitudeSpec Element>
+// [[nodiscard]] consteval bool is_valid_element(Element element)
+// {
+//   if (get_exponent(element) == 0) {
+//     return false;
+//   }
+//   if constexpr (std::integral<decltype(get_base(element))>) {
+//     // Some prime numbers are so big, that we can't check their primality without exhausting limits on constexpr
+//     steps
+//     // and/or iterations.  We can still _perform_ the factorization for these by using the `known_first_factor`
+//     // workaround.  However, we can't _check_ that they are prime, because this workaround depends on the input being
+//     // usable in a constexpr expression.  This is true for `prime_factorization` (below), where the input `N` is a
+//     // template parameter, but is not true for our case, where the input `bp.get_base()` is a function parameter.
+//     (See
+//     // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1045r1.html for some background reading on this
+//     // distinction.)
+//     //
+//     // In our case: we simply give up on excluding every possible ill-formed base power, and settle for catching the
+//     // most likely and common mistakes.
+//     if (const bool too_big_to_check = (get_base_value(element) > 1'000'000'000)) {
+//       return true;
+//     }
 
-    return is_prime(get_base_value(element));
-  } else {
-    return get_base_value(element) > 0;
-  }
-}
+//     return is_prime(get_base_value(element));
+//   } else {
+//     return get_base_value(element) > 0;
+//   }
+// }
 
 // A function object to apply a predicate to all consecutive pairs of values in a sequence.
-template<typename Predicate>
-struct pairwise_all {
-  Predicate predicate;
+// template<typename Predicate>
+// struct pairwise_all {
+//   Predicate predicate;
 
-  template<typename... Ts>
-  [[nodiscard]] consteval bool operator()(Ts&&... ts) const
-  {
-    // Carefully handle different sizes, avoiding unsigned integer underflow.
-    constexpr auto num_comparisons = [](auto num_elements) {
-      return (num_elements > 1) ? (num_elements - 1) : 0;
-    }(sizeof...(Ts));
+//   template<typename... Ts>
+//   [[nodiscard]] consteval bool operator()(Ts&&... ts) const
+//   {
+//     // Carefully handle different sizes, avoiding unsigned integer underflow.
+//     constexpr auto num_comparisons = [](auto num_elements) {
+//       return (num_elements > 1) ? (num_elements - 1) : 0;
+//     }(sizeof...(Ts));
 
-    // Compare zero or more pairs of neighbours as needed.
-    return [this]<std::size_t... Is>(std::tuple<Ts...> && t, std::index_sequence<Is...>)
-    {
-      return (predicate(std::get<Is>(t), std::get<Is + 1>(t)) && ...);
-    }
-    (std::make_tuple(std::forward<Ts>(ts)...), std::make_index_sequence<num_comparisons>());
-  }
-};
+//     // Compare zero or more pairs of neighbours as needed.
+//     return [this]<std::size_t... Is>(std::tuple<Ts...> && t, std::index_sequence<Is...>)
+//     {
+//       return (predicate(std::get<Is>(t), std::get<Is + 1>(t)) && ...);
+//     }
+//     (std::make_tuple(std::forward<Ts>(ts)...), std::make_index_sequence<num_comparisons>());
+//   }
+// };
 
 // Deduction guide: permit constructions such as `pairwise_all{std::less{}}`.
 // template<typename T>
 // pairwise_all(T) -> pairwise_all<T>;
 
 // Check whether a sequence of (possibly heterogeneously typed) values are strictly increasing.
-template<typename... Ts>
-  requires(std::is_signed_v<Ts> && ...)
-[[nodiscard]] consteval bool strictly_increasing(Ts&&... ts)
-{
-  return pairwise_all{std::less{}}(std::forward<Ts>(ts)...);
-}
+// template<typename... Ts>
+//   requires(std::is_signed_v<Ts> && ...)
+// [[nodiscard]] consteval bool strictly_increasing(Ts&&... ts)
+// {
+//   return pairwise_all{std::less{}}(std::forward<Ts>(ts)...);
+// }
 
-template<MagnitudeSpec auto... Elements>
-inline constexpr bool all_elements_valid = (is_valid_element(Elements) && ...);
+// template<MagnitudeSpec auto... Elements>
+// inline constexpr bool all_elements_valid = (is_valid_element(Elements) && ...);
 
-template<MagnitudeSpec auto... Elements>
-inline constexpr bool all_elements_in_order = strictly_increasing(get_base_value(Elements)...);
+// template<MagnitudeSpec auto... Elements>
+// inline constexpr bool all_elements_in_order = strictly_increasing(get_base_value(Elements)...);
 
-template<MagnitudeSpec auto... Elements>
-inline constexpr bool is_element_pack_valid = all_elements_valid<Elements...> && all_elements_in_order<Elements...>;
+// template<MagnitudeSpec auto... Elements>
+// inline constexpr bool is_element_pack_valid = all_elements_valid<Elements...> && all_elements_in_order<Elements...>;
 
 [[nodiscard]] consteval bool is_rational(MagnitudeSpec auto element)
 {
-  return std::is_integral_v<decltype(get_base_value(element))> && (get_exponent(element).den == 1);
+  static_assert(!Magnitude<decltype(element)>);  // magnitudes are handles by another overload
+  return std::is_integral_v<decltype(get_base(element))> && (get_exponent(element).den == 1);
 }
 
 [[nodiscard]] consteval bool is_integral(MagnitudeSpec auto element)
 {
+  static_assert(!Magnitude<decltype(element)>);  // magnitudes are handles by another overload
   return is_rational(element) && get_exponent(element).num > 0;
 }
 
@@ -433,29 +455,40 @@ inline constexpr bool is_element_pack_valid = all_elements_valid<Elements...> &&
  * rational powers, and compare for equality.
  */
 template<MagnitudeSpec auto... Ms>
-  requires detail::is_element_pack_valid<Ms...>
+// requires detail::is_element_pack_valid<Ms...>
 struct magnitude {
-  // Whether this magnitude represents an integer.
-  [[nodiscard]] friend consteval bool is_integral(const magnitude&) { return (detail::is_integral(Ms) && ...); }
+  [[nodiscard]] friend consteval bool is_integral(const magnitude&)
+  {
+    using namespace detail;  // needed for recursive case when magnitudes are in the MagnitudeSpec
+    return (is_integral(Ms) && ...);
+  }
 
-  // Whether this magnitude represents a rational number.
-  [[nodiscard]] friend consteval bool is_rational(const magnitude&) { return (detail::is_rational(Ms) && ...); }
+  [[nodiscard]] friend consteval bool is_rational(const magnitude&)
+  {
+    using namespace detail;  // needed for recursive case when magnitudes are in the MagnitudeSpec
+    return (is_rational(Ms) && ...);
+  }
 };
 
+
 namespace detail {
 
-// Implementation for Magnitude concept (below).
+template<auto... Ms>
+void to_base_specialization_of_magnitude(const volatile magnitude<Ms...>*);
+
 template<typename T>
-inline constexpr bool is_magnitude = false;
-template<auto... BPs>
-inline constexpr bool is_magnitude<magnitude<BPs...>> = true;
+inline constexpr bool is_derived_from_specialization_of_magnitude =
+  requires(T * t) { to_base_specialization_of_magnitude(t); };
+
+template<typename T>
+  requires is_derived_from_specialization_of_magnitude<T>
+inline constexpr bool is_magnitude<T> = true;
+
+template<auto... Ms>
+inline constexpr bool is_specialization_of_magnitude<magnitude<Ms...>> = true;
+
 }  // namespace detail
 
-/**
- * @brief  Concept to detect whether T is a valid Magnitude.
- */
-template<typename T>
-concept Magnitude = detail::is_magnitude<T>;
 
 /**
  * @brief  The value of a Magnitude in a desired type T.
@@ -471,23 +504,25 @@ concept Magnitude = detail::is_magnitude<T>;
 //   return result;
 // }
 
+
 /**
  * @brief  A convenient Magnitude constant for pi, which we can manipulate like a regular number.
  */
-inline constexpr Magnitude auto mag_pi = magnitude<pi_v{}>{};
+inline constexpr struct mag_pi : magnitude<std::numbers::pi_v<long double>> {
+} mag_pi;
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // Magnitude equality implementation.
 
-template<auto... LeftBPs, auto... RightBPs>
-constexpr bool operator==(magnitude<LeftBPs...>, magnitude<RightBPs...>)
-{
-  if constexpr (sizeof...(LeftBPs) == sizeof...(RightBPs)) {
-    return ((LeftBPs == RightBPs) && ...);
-  } else {
-    return false;
-  }
-}
+// template<auto... LeftBPs, auto... RightBPs>
+// constexpr bool operator==(magnitude<LeftBPs...>, magnitude<RightBPs...>)
+// {
+//   if constexpr (sizeof...(LeftBPs) == sizeof...(RightBPs)) {
+//     return ((LeftBPs == RightBPs) && ...);
+//   } else {
+//     return false;
+//   }
+// }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // Magnitude rational powers implementation.
@@ -517,6 +552,21 @@ constexpr auto cbrt(magnitude<Ms...> m)
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // Magnitude product implementation.
 
+namespace detail {
+
+consteval bool less(MagnitudeSpec auto lhs, MagnitudeSpec auto rhs)
+{
+  if constexpr (is_named_magnitude<decltype(lhs)> && is_named_magnitude<decltype(rhs)>)
+    return type_name(lhs) < type_name(rhs);
+  else if constexpr (!is_named_magnitude<decltype(lhs)> && !is_named_magnitude<decltype(rhs)>)
+    return get_base(lhs) < get_base(rhs);
+  else
+    return is_named_magnitude<decltype(lhs)>;
+}
+
+}  // namespace detail
+
+
 // Base cases, for when either (or both) inputs are the identity.
 constexpr Magnitude auto operator*(magnitude<>, magnitude<>) { return magnitude<>{}; }
 constexpr Magnitude auto operator*(magnitude<>, Magnitude auto m) { return m; }
@@ -528,32 +578,31 @@ constexpr Magnitude auto operator*(magnitude<H1, T1...>, magnitude<H2, T2...>)
 {
   using namespace detail;
 
-  // Case for when H1 has the smaller base.
-  if constexpr (get_base_value(H1) < get_base_value(H2)) {
+  if constexpr (less(H1, H2)) {
     if constexpr (sizeof...(T1) == 0) {
       // Shortcut for the "pure prepend" case, which makes it easier to implement some of the other cases.
       return magnitude<H1, H2, T2...>{};
     } else {
       return magnitude<H1>{} * (magnitude<T1...>{} * magnitude<H2, T2...>{});
     }
-  }
-
-  // Case for when H2 has the smaller base.
-  if constexpr (get_base_value(H1) > get_base_value(H2)) {
+  } else if constexpr (less(H2, H1)) {
     return magnitude<H2>{} * (magnitude<H1, T1...>{} * magnitude<T2...>{});
-  }
-
-  // "Same leading base" case.
-  if constexpr (get_base(H1) == get_base(H2)) {
+  } else {
     constexpr auto partial_product = magnitude<T1...>{} * magnitude<T2...>{};
 
-    // Make a new power_v with the common base of H1 and H2, whose power is their powers' sum.
-    constexpr auto new_head = power_v_or_T<get_base(H1), get_exponent(H1) + get_exponent(H2)>();
+    if constexpr (is_same_v<decltype(get_base(H1)), decltype(get_base(H2))>) {
+      // Make a new power_v with the common base of H1 and H2, whose power is their powers' sum.
+      constexpr auto new_head = power_v_or_T<get_base(H1), get_exponent(H1) + get_exponent(H2)>();
 
-    if constexpr (get_exponent(new_head) == 0) {
-      return partial_product;
+      if constexpr (get_exponent(new_head) == 0) {
+        return partial_product;
+      } else {
+        return magnitude<new_head>{} * partial_product;
+      }
+    } else if constexpr (is_named_magnitude<decltype(get_base(H1))>) {
+      return magnitude<H1>{} * (magnitude<T1...>{} * magnitude<H2, T2...>{});
     } else {
-      return magnitude<new_head>{} * partial_product;
+      return magnitude<H2>{} * (magnitude<H1, T1...>{} * magnitude<T2...>{});
     }
   }
 }
diff --git a/src/core/include/units/quantity.h b/src/core/include/units/quantity.h
index 84c6042e..7507359e 100644
--- a/src/core/include/units/quantity.h
+++ b/src/core/include/units/quantity.h
@@ -23,33 +23,37 @@
 
 #pragma once
 
-#include <units/bits/common_type.h>
-#include <units/generic/dimensionless.h>
+// #include <units/bits/common_type.h>
+// #include <units/generic/dimensionless.h>
 
 // IWYU pragma: begin_exports
-#include <units/quantity_cast.h>
-#include <units/ratio.h>
+// #include <units/quantity_cast.h>
+// #include <units/ratio.h>
+#include <units/bits/common_type.h>
+#include <units/concepts.h>
+#include <units/customization_points.h>
+#include <units/dimension.h>
+#include <units/reference.h>
+#include <units/unit.h>
 #include <compare>
 // IWYU pragma: end_exports
 
-#include <units/reference.h>
-#include <utility>
+// #include <units/reference.h>
+// #include <utility>
 
 namespace units {
 
 namespace detail {
 
-template<Reference auto R>  // TODO: Replace with `v * R` pending https://github.com/BobSteagall/wg21/issues/58.
-inline constexpr auto make_quantity = [](auto&& v) {
+// TODO: Replace with `v * R` pending https://github.com/BobSteagall/wg21/issues/58.
+template<Reference auto R>
+inline constexpr auto make_quantity = [](Representation auto&& v) {
   using Rep = std::remove_cvref_t<decltype(v)>;
-  return quantity<typename decltype(R)::dimension, typename decltype(R)::unit, Rep>(std::forward<decltype(v)>(v));
+  return quantity<R, Rep>(std::forward<decltype(v)>(v));
 };
 
 template<typename T>
-concept quantity_one =
-  Quantity<T> &&
-  (std::same_as<typename T::dimension, dim_one> || std::same_as<typename T::dimension, unknown_dimension<>>) &&
-  detail::equivalent_unit<typename T::unit, typename T::dimension, ::units::one, typename T::dimension>::value;
+concept quantity_one = Quantity<T> && (T::dimension == one_dim) && (T::unit == one);
 
 }  // namespace detail
 
@@ -65,12 +69,12 @@ concept safe_convertible_to_ =  // exposition only
 // QFrom ratio is an exact multiple of QTo
 template<typename QFrom, typename QTo>
 concept harmonic_ =  // exposition only
-  Quantity<QFrom> && Quantity<QTo> && is_integral(detail::quantity_magnitude<QFrom> / detail::quantity_magnitude<QTo>);
+  true;              // TODO fix it when magnitudes are ready
+// Quantity<QFrom> && Quantity<QTo> && is_integral(detail::quantity_magnitude<QFrom> / detail::quantity_magnitude<QTo>);
 
 template<typename QFrom, typename QTo>
 concept safe_castable_to_ =  // exposition only
-  Quantity<QFrom> && QuantityOf<QTo, typename QFrom::dimension> &&
-  scalable_with_<typename QFrom::rep, typename QTo::rep> &&
+  Quantity<QFrom> && quantity_of<QTo, QFrom::dimension> && scalable_with_<typename QFrom::rep, typename QTo::rep> &&
   (floating_point_<QTo> || (!floating_point_<QFrom> && harmonic_<QFrom, QTo>));
 
 template<typename Func, typename T, typename U>
@@ -83,9 +87,23 @@ concept invoke_result_convertible_to_ =
 template<typename Func, typename Q, typename V>
 concept have_quantity_for_ = Quantity<Q> && (!Quantity<V>) && quantity_value_for_<Func, typename Q::rep, V>;
 
+template<typename T>
+concept QuantityLike = requires(T q) {
+                         typename quantity_like_traits<T>::dimension;
+                         typename quantity_like_traits<T>::unit;
+                         typename quantity_like_traits<T>::rep;
+                         requires Dimension<typename quantity_like_traits<T>::dimension>;
+                         requires Unit<typename quantity_like_traits<T>::unit>;
+                         requires Representation<typename quantity_like_traits<T>::rep>;
+                         {
+                           quantity_like_traits<T>::number(q)
+                           } -> std::convertible_to<typename quantity_like_traits<T>::rep>;
+                       };
+
 template<QuantityLike Q>
-using quantity_like_type = quantity<typename quantity_like_traits<Q>::dimension, typename quantity_like_traits<Q>::unit,
-                                    typename quantity_like_traits<Q>::rep>;
+using quantity_like_type =
+  quantity<reference<typename quantity_like_traits<Q>::dimension, typename quantity_like_traits<Q>::unit>{},
+           typename quantity_like_traits<Q>::rep>;
 
 /**
  * @brief A quantity
@@ -97,15 +115,15 @@ using quantity_like_type = quantity<typename quantity_like_traits<Q>::dimension,
  * @tparam U a measurement unit of the quantity
  * @tparam Rep a type to be used to represent values of a quantity
  */
-template<Dimension D, UnitOf<D> U, Representation Rep = double>
+template<Reference auto R, Representation Rep = double>
 class quantity {
   Rep number_;
 public:
   // member types and values
-  using dimension = D;
-  using unit = U;
   using rep = Rep;
-  static constexpr units::reference<dimension, unit> reference{};
+  static constexpr auto reference = R;
+  static constexpr auto dimension = R.dimension;
+  static constexpr auto unit = R.unit;
 
   // static member functions
   [[nodiscard]] static constexpr quantity zero() noexcept
@@ -171,14 +189,14 @@ public:
                  } -> std::common_with<rep>;
              }
   {
-    using ret = quantity<D, U, decltype(+number())>;
+    using ret = quantity<R, decltype(+number())>;
     return ret(+number());
   }
 
   [[nodiscard]] constexpr Quantity auto operator-() const
     requires(std::regular_invocable<std::negate<>, rep>)
   {
-    using ret = quantity<D, U, decltype(-number())>;
+    using ret = quantity<R, decltype(-number())>;
     return ret(-number());
   }
 
@@ -380,7 +398,7 @@ public:
     requires(invoke_result_convertible_to_<rep, std::multiplies<>, rep, const Value&>)
   [[nodiscard]] friend constexpr Quantity auto operator*(const quantity& q, const Value& v)
   {
-    using ret = quantity<D, U, std::invoke_result_t<std::multiplies<>, rep, Value>>;
+    using ret = quantity<R, std::invoke_result_t<std::multiplies<>, rep, Value>>;
     return ret(q.number() * v);
   }
 
@@ -388,7 +406,7 @@ public:
     requires(invoke_result_convertible_to_<rep, std::multiplies<>, const Value&, rep>)
   [[nodiscard]] friend constexpr Quantity auto operator*(const Value& v, const quantity& q)
   {
-    using ret = quantity<D, U, std::invoke_result_t<std::multiplies<>, Value, rep>>;
+    using ret = quantity<R, std::invoke_result_t<std::multiplies<>, Value, rep>>;
     return ret(v * q.number());
   }
 
@@ -397,7 +415,7 @@ public:
   [[nodiscard]] friend constexpr Quantity auto operator/(const quantity& q, const Value& v)
   {
     gsl_ExpectsAudit(v != quantity_values<Value>::zero());
-    using ret = quantity<D, U, std::invoke_result_t<std::divides<>, rep, Value>>;
+    using ret = quantity<R, std::invoke_result_t<std::divides<>, rep, Value>>;
     return ret(q.number() / v);
   }
 
@@ -405,7 +423,7 @@ public:
     requires(!Quantity<Value>) && (invoke_result_convertible_to_<rep, std::divides<>, const Value&, rep>)
   [[nodiscard]] friend constexpr Quantity auto operator/(const Value& v, const quantity& q)
   {
-    return detail::make_quantity<::units::reference<dim_one, ::units::one>{} / reference>(v / q.number());
+    return detail::make_quantity<dimensionless[one] / reference>(v / q.number());
   }
 
   template<typename Value>
@@ -414,7 +432,7 @@ public:
   [[nodiscard]] friend constexpr Quantity auto operator%(const quantity& q, const Value& v)
   {
     gsl_ExpectsAudit(v != quantity_values<Value>::zero());
-    using ret = quantity<D, U, std::invoke_result_t<std::modulus<>, rep, Value>>;
+    using ret = quantity<R, std::invoke_result_t<std::modulus<>, rep, Value>>;
     return ret(q.number() % v);
   }
 
@@ -422,7 +440,7 @@ public:
     requires(!floating_point_<rep>) && (invoke_result_convertible_to_<rep, std::modulus<>, rep, rep>)
   {
     gsl_ExpectsAudit(rhs.number() != quantity_values<rep>::zero());
-    using ret = quantity<D, U, std::invoke_result_t<std::modulus<>, rep, rep>>;
+    using ret = quantity<R, std::invoke_result_t<std::modulus<>, rep, rep>>;
     return ret(lhs.number() % rhs.number());
   }
 
@@ -441,36 +459,37 @@ public:
 
 // CTAD
 #if !UNITS_COMP_CLANG || UNITS_COMP_CLANG > 16
-template<typename D, typename U, typename Rep>
-explicit(false) quantity(Rep&&)->quantity<D, U, Rep>;
+template<auto R, typename Rep>
+explicit(false) quantity(Rep&&) -> quantity<R, Rep>;
 #endif
 
-template<typename D, typename U, typename Rep>
-explicit(false) quantity(quantity<D, U, Rep>)->quantity<D, U, Rep>;
+template<auto R, typename Rep>
+explicit(false) quantity(quantity<R, Rep>) -> quantity<R, Rep>;
 
 template<Representation Rep>
-explicit(false) quantity(Rep)->quantity<dim_one, one, Rep>;
+explicit(false) quantity(Rep)->quantity<dimensionless[one], Rep>;
 
 template<QuantityLike Q>
-explicit quantity(Q) -> quantity<typename quantity_like_traits<Q>::dimension, typename quantity_like_traits<Q>::unit,
-                                 typename quantity_like_traits<Q>::rep>;
+explicit quantity(Q)
+  -> quantity<reference<typename quantity_like_traits<Q>::dimension, typename quantity_like_traits<Q>::unit>{},
+              typename quantity_like_traits<Q>::rep>;
 
 // non-member binary operators
-template<Quantity Q1, QuantityEquivalentTo<Q1> Q2>
+template<Quantity Q1, quantity_equivalent_to<Q1> Q2>
   requires(quantity_value_for_<std::plus<>, typename Q1::rep, typename Q2::rep>)
 [[nodiscard]] constexpr Quantity auto operator+(const Q1& lhs, const Q2& rhs)
 {
   using ref = detail::common_quantity_reference<Q1, Q2>;
-  using ret = quantity<typename ref::dimension, typename ref::unit, decltype(lhs.number() + rhs.number())>;
+  using ret = quantity<ref{}, decltype(lhs.number() + rhs.number())>;
   return ret(ret(lhs).number() + ret(rhs).number());
 }
 
-template<Quantity Q1, QuantityEquivalentTo<Q1> Q2>
+template<Quantity Q1, quantity_equivalent_to<Q1> Q2>
   requires(quantity_value_for_<std::minus<>, typename Q1::rep, typename Q2::rep>)
 [[nodiscard]] constexpr Quantity auto operator-(const Q1& lhs, const Q2& rhs)
 {
   using ref = detail::common_quantity_reference<Q1, Q2>;
-  using ret = quantity<typename ref::dimension, typename ref::unit, decltype(lhs.number() - rhs.number())>;
+  using ret = quantity<ref{}, decltype(lhs.number() - rhs.number())>;
   return ret(ret(lhs).number() - ret(rhs).number());
 }
 
@@ -491,17 +510,17 @@ template<Quantity Q1, Quantity Q2>
 
 template<Quantity Q1, Quantity Q2>
   requires(!floating_point_<typename Q1::rep>) && (!floating_point_<typename Q2::rep>) &&
-          (QuantityEquivalentTo<Q2, Q1> || Dimensionless<Q2>) &&
+          (quantity_equivalent_to<Q2, Q1> || quantity_of<Q2, one_dim>) &&
           (quantity_value_for_<std::modulus<>, typename Q1::rep, typename Q2::rep>)
 [[nodiscard]] constexpr Quantity auto operator%(const Q1& lhs, const Q2& rhs)
 {
   gsl_ExpectsAudit(rhs.number() != quantity_values<typename Q2::rep>::zero());
-  using ret = quantity<typename Q1::dimension, typename Q1::unit,
+  using ret = quantity<reference<typename Q1::dimension, typename Q1::unit>{},
                        std::invoke_result_t<std::modulus<>, typename Q1::rep, typename Q2::rep>>;
   return ret(lhs.number() % rhs.number());
 }
 
-template<Quantity Q1, QuantityEquivalentTo<Q1> Q2>
+template<Quantity Q1, quantity_equivalent_to<Q1> Q2>
   requires std::three_way_comparable_with<typename Q1::rep, typename Q2::rep>
 [[nodiscard]] constexpr auto operator<=>(const Q1& lhs, const Q2& rhs)
 {
@@ -509,7 +528,7 @@ template<Quantity Q1, QuantityEquivalentTo<Q1> Q2>
   return cq(lhs).number() <=> cq(rhs).number();
 }
 
-template<Quantity Q1, QuantityEquivalentTo<Q1> Q2>
+template<Quantity Q1, quantity_equivalent_to<Q1> Q2>
   requires std::equality_comparable_with<typename Q1::rep, typename Q2::rep>
 [[nodiscard]] constexpr bool operator==(const Q1& lhs, const Q2& rhs)
 {
@@ -517,16 +536,4 @@ template<Quantity Q1, QuantityEquivalentTo<Q1> Q2>
   return cq(lhs).number() == cq(rhs).number();
 }
 
-// type traits
-namespace detail {
-
-template<typename D, typename U, typename Rep>
-inline constexpr bool is_quantity<quantity<D, U, Rep>> = true;
-
-template<typename T>
-  requires units::is_derived_from_specialization_of<T, units::quantity>
-inline constexpr bool is_quantity<T> = true;
-
-}  // namespace detail
-
 }  // namespace units
diff --git a/src/core/include/units/reference.h b/src/core/include/units/reference.h
index 291a7fab..62e151de 100644
--- a/src/core/include/units/reference.h
+++ b/src/core/include/units/reference.h
@@ -22,36 +22,27 @@
 
 #pragma once
 
+#include <units/concepts.h>
 #include <units/dimension.h>
 #include <units/unit.h>
 
 namespace units {
 
-// TODO Concept for system reference
-template<auto R, typename Rep = double>
-class quantity {
-public:
-  using reference = decltype(R);
-  static constexpr auto dimension = reference::dimension;
-  static constexpr auto unit = reference::unit;
-
-  quantity(Rep) {}
-};
-
-template<typename Child, Dimension auto Dim, Unit auto CoU>
+template<Dimension auto Dim, Unit auto CoU>
 struct system_reference;
 
-namespace detail {
+// namespace detail {
 
-template<typename Child, auto Dim, auto CoU>
-void to_base_specialization_of_system_reference(const volatile system_reference<Child, Dim, CoU>*);
+// template<typename Child, auto Dim, auto CoU>
+// void to_base_specialization_of_inline constexpr struct const volatile system_reference<Child : system_reference<Dim,
+// CoU>*> {} const volatile system_reference<Child;
 
-template<typename T>
-// inline constexpr bool // TODO: Replace with concept when it works with MSVC
-concept is_derived_from_specialization_of_system_reference =
-  requires(T* t) { detail::to_base_specialization_of_system_reference(t); };
+// template<typename T>
+// // inline constexpr bool // TODO: Replace with concept when it works with MSVC
+// concept is_derived_from_specialization_of_system_reference =
+//   requires(T* t) { detail::to_base_specialization_of_system_reference(t); };
 
-}  // namespace detail
+// }  // namespace detail
 
 /**
  * @brief The type for quantity references
@@ -92,33 +83,36 @@ concept is_derived_from_specialization_of_system_reference =
  * The following syntaxes are not allowed:
  * `2 / s`, `km * 3`, `s / 4`, `70 * km / h`.
  */
-template<typename T, Unit U>
-struct reference;
+// template<typename R, Unit U>
+//   requires detail::is_derived_from_specialization_of_system_reference<R>
+// struct reference<R, U> {
+//   using system_reference = R;
+//   static constexpr auto dimension = R::dimension;
+//   static constexpr U unit{};
+//   // static constexpr UNITS_MSVC_WORKAROUND(Magnitude) auto mag = dimension::mag * unit::mag;
+// };
 
-template<typename R, Unit U>
-  requires detail::is_derived_from_specialization_of_system_reference<R>
-struct reference<R, U> {
-  using system_reference = R;
-  static constexpr auto dimension = R::dimension;
-  static constexpr U unit{};
-  // static constexpr UNITS_MSVC_WORKAROUND(Magnitude) auto mag = dimension::mag * unit::mag;
-};
-
-template<DerivedDimension D, Unit U>
-struct reference<D, U> {
+template<Dimension D, Unit U>
+struct reference {
   static constexpr D dimension{};
   static constexpr U unit{};
   // static constexpr UNITS_MSVC_WORKAROUND(Magnitude) auto mag = dimension::mag * unit::mag;
 };
 
 // Reference
-/**
- * @brief A concept matching all references in the library.
- *
- * Satisfied by all specializations of @c reference.
- */
-template<typename T>
-concept Reference = is_specialization_of<T, reference>;
+
+template<Magnitude M, Reference R>
+[[nodiscard]] consteval reference<decltype(R::dimension), decltype(M{} * R::unit)> operator*(M, R)
+{
+  return {};
+}
+
+// template<Magnitude M, Reference R>
+//   requires requires { typename R::system_reference; }
+// [[nodiscard]] consteval reference<typename R::system_reference, decltype(M{} * R::unit)> operator*(M, R)
+// {
+//   return {};
+// }
 
 template<Reference R1, Reference R2>
 [[nodiscard]] consteval reference<decltype(R1::dimension * R2::dimension), decltype(R1::unit * R2::unit)> operator*(R1,
@@ -134,29 +128,28 @@ template<Reference R1, Reference R2>
   return {};
 }
 
-// TODO Update when quantity is done
-// template<Representation Rep>
-// [[nodiscard]] friend constexpr Quantity auto operator*(const Rep& lhs, reference)
-template<typename Rep, Reference R>
+template<Representation Rep, Reference R>
 [[nodiscard]] constexpr quantity<R{}, Rep> operator*(const Rep& lhs, R)
 {
   return quantity<R{}, Rep>(lhs);
 }
 
-// friend void /*Use `q * (1 * r)` rather than `q * r`.*/ operator*(Quantity auto, reference) = delete;
+void /*Use `q * (1 * r)` rather than `q * r`.*/ operator*(Quantity auto, Reference auto) = delete;
 
-// TODO will use deducing this
-template<typename Child, Dimension auto Dim, Unit auto CoU>
+template<Dimension auto Dim, Unit auto CoU>
 struct system_reference {
   static constexpr auto dimension = Dim;
   static constexpr auto coherent_unit = CoU;
 
   template<Unit U>
-  // requires same_unit_reference<CoU, U>
-  [[nodiscard]] consteval reference<Child, U> operator[](U) const
+  //  requires same_unit_reference<CoU, U>
+  [[nodiscard]] constexpr reference<std::remove_const_t<decltype(dimension)>, U> operator[](U) const
   {
     return {};
   }
 };
 
+inline constexpr struct dimensionless : system_reference<one_dim, one> {
+} dimensionless;
+
 }  // namespace units
diff --git a/src/core/include/units/unit.h b/src/core/include/units/unit.h
index d3c5b068..0646e2fd 100644
--- a/src/core/include/units/unit.h
+++ b/src/core/include/units/unit.h
@@ -75,6 +75,12 @@ namespace detail {
 template<Magnitude auto M, typename U>
 void to_base_scaled_unit(const volatile scaled_unit<M, U>*);
 
+template<typename T>
+inline constexpr bool is_specialization_of_scaled_unit = false;
+
+template<Magnitude auto M, typename U>
+inline constexpr bool is_specialization_of_scaled_unit<scaled_unit<M, U>> = true;
+
 }  // namespace detail
 
 /**
@@ -98,14 +104,106 @@ concept NamedUnit = Unit<T> && detail::is_named<T>;
 template<Unit auto U1, Unit auto U2>
 struct same_unit_reference : is_same<typename decltype(U1)::reference, typename decltype(U2)::reference> {};
 
+namespace detail {
+
+template<Unit U1, Unit U2>
+struct unit_less : std::bool_constant<type_name<U1>() < type_name<U2>()> {};
+
+template<typename T1, typename T2>
+using type_list_of_unit_less = expr_less<T1, T2, unit_less>;
+
+/**
+ * @brief Unpacks the list of potentially derived dimensions to a list containing only base dimensions
+ *
+ * @tparam Es Exponents of potentially derived dimensions
+ */
+// template<typename NumList, typename DenList>
+// struct unit_extract;
+
+// template<>
+// struct unit_extract<type_list<>, type_list<>> {
+//   using num = type_list<>;
+//   using den = type_list<>;
+// };
+
+// template<typename T, typename... NRest, typename... Dens>
+//   requires BaseUnit<T> || BaseUnit<typename T::factor>
+// struct unit_extract<type_list<T, NRest...>, type_list<Dens...>> {
+//   using impl = unit_extract<type_list<NRest...>, type_list<Dens...>>;
+//   using num = type_list_push_front<typename impl::num, T>;
+//   using den = TYPENAME impl::den;
+// };
+
+// template<typename T, typename... DRest>
+//   requires BaseUnit<T> || BaseUnit<typename T::factor>
+// struct unit_extract<type_list<>, type_list<T, DRest...>> {
+//   using impl = unit_extract<type_list<>, type_list<DRest...>>;
+//   using num = TYPENAME impl::num;
+//   using den = type_list_push_front<typename impl::den, T>;
+// };
+
+// template<DerivedUnit T, typename... NRest, typename... Dens>
+// struct unit_extract<type_list<T, NRest...>, type_list<Dens...>> :
+//     unit_extract<type_list_push_back<typename T::normalized_num, NRest...>,
+//                  type_list_push_back<typename T::normalized_den, Dens...>> {};
+
+// template<DerivedUnit T, int... Ints, typename... NRest, typename... Dens>
+// struct unit_extract<type_list<power<T, Ints...>, NRest...>, type_list<Dens...>> :
+//     unit_extract<type_list_push_back<typename expr_power<typename T::normalized_num, power<T, Ints...>::num,
+//                                                          power<T, Ints...>::den>::type,
+//                                      NRest...>,
+//                  type_list_push_back<typename expr_power<typename T::normalized_den, power<T, Ints...>::num,
+//                                                          power<T, Ints...>::den>::type,
+//                                      Dens...>> {};
+
+
+// template<DerivedUnit T, typename... DRest>
+// struct unit_extract<type_list<>, type_list<T, DRest...>> :
+//     unit_extract<typename T::normalized_den, type_list_push_back<typename T::normalized_num, DRest...>> {};
+
+// template<DerivedUnit T, int... Ints, typename... DRest>
+// struct unit_extract<type_list<>, type_list<power<T, Ints...>, DRest...>> :
+//     unit_extract<typename expr_power<typename T::normalized_den, power<T, Ints...>::num, power<T,
+//     Ints...>::den>::type,
+//                  type_list_push_back<typename expr_power<typename T::normalized_num, power<T, Ints...>::num,
+//                                                          power<T, Ints...>::den>::type,
+//                                      DRest...>> {};
+
+/**
+ * @brief Converts user provided derived dimension specification into a valid units::normalized_dimension definition
+ *
+ * User provided definition of a derived dimension may contain the same base dimension repeated more than once on the
+ * list possibly hidden in other derived units provided by the user. The process here should:
+ * 1. Extract derived dimensions into exponents of base dimensions.
+ * 2. Sort the exponents so the same dimensions are placed next to each other.
+ * 3. Consolidate contiguous range of exponents of the same base dimensions to a one (or possibly zero) exponent for
+ *    this base dimension.
+ */
+template<typename OneTypeBase, typename... Us>
+struct normalized_unit : detail::expr_fractions<OneTypeBase, Us...> {
+  // private:
+  //   using base = detail::expr_fractions<OneTypeBase, Us...>;
+  //   using extracted = unit_extract<typename base::num, typename base::den>;
+  //   using num_list = expr_consolidate<type_list_sort<typename extracted::num, type_list_of_unit_less>>;
+  //   using den_list = expr_consolidate<type_list_sort<typename extracted::den, type_list_of_unit_less>>;
+  //   using simple = expr_simplify<num_list, den_list, type_list_of_unit_less>;
+  // public:
+  //   using normalized_num = TYPENAME simple::num;
+  //   using normalized_den = TYPENAME simple::den;
+};
+
+}  // namespace detail
+
 // TODO add checking for `per` and power elements as well
 template<typename T>
 concept UnitSpec = Unit<T> || is_specialization_of<T, per> || detail::is_specialization_of_power<T>;
 
+// User should not instantiate this type!!!
+// It should not be exported from the module
 template<UnitSpec... Us>
-struct derived_unit : detail::expr_fractions<derived_unit<>, Us...>, scaled_unit<mag<1>, derived_unit<Us...>> {};
-
-// : detail::normalized_dimension<derived_dimension<>, Ds...> {};
+struct derived_unit : detail::normalized_unit<derived_unit<>, Us...>, scaled_unit<mag<1>, derived_unit<Us...>> {
+  static constexpr bool is_base = false;
+};
 
 /**
  * @brief Unit one
@@ -129,28 +227,13 @@ struct named_unit;
 template<basic_symbol_text Symbol>
 struct named_unit<Symbol> : scaled_unit<mag<1>, named_unit<Symbol>> {
   static constexpr auto symbol = Symbol;
+  static constexpr bool is_base = true;
 };
 
-template<basic_symbol_text Symbol, auto U>
-  requires is_specialization_of<std::remove_const_t<decltype(U)>, derived_unit>
+template<basic_symbol_text Symbol, Unit auto U>
 struct named_unit<Symbol, U> : decltype(U) {
   static constexpr auto symbol = Symbol;
-};
-
-
-/**
- * @brief A named scaled unit
- *
- * Defines a new named unit that is a scaled version of another unit.
- * A named unit may be composed with a prefix to create a prefixed_unit.
- *
- * @tparam Symbol a short text representation of the unit
- * @tparam M the Magnitude by which to scale U
- * @tparam U a reference unit to scale
- */
-template<basic_symbol_text Symbol, Magnitude auto M, Unit auto U>
-struct named_scaled_unit : scaled_unit<M* decltype(U)::mag, typename decltype(U)::reference> {
-  static constexpr auto symbol = Symbol;
+  static constexpr bool is_base = decltype(U)::is_base;
 };
 
 /**
@@ -164,15 +247,12 @@ struct named_scaled_unit : scaled_unit<M* decltype(U)::mag, typename decltype(U)
  * @tparam P prefix to be appied to the reference unit
  * @tparam U reference unit
  */
-// template<typename Child, Prefix P, NamedUnit U>
-//   requires detail::can_be_prefixed<U>
-// struct prefixed_unit : downcast_dispatch<Child, scaled_unit<P::mag * U::mag, typename U::reference>> {
-//   static constexpr auto symbol = P::symbol + U::symbol;
-// };
-
-
 template<basic_symbol_text Symbol, Magnitude auto M, NamedUnit auto U>
-struct prefixed_unit : scaled_unit<M* decltype(U)::mag, typename decltype(U)::reference> {};
+//   requires detail::can_be_prefixed<U>
+struct prefixed_unit : scaled_unit<M* decltype(U)::mag, typename decltype(U)::reference> {
+  // static constexpr auto symbol = symbol + decltype(U)::symbol;
+  static constexpr bool is_base = decltype(U)::is_base;
+};
 
 /**
  * @brief A coherent unit of a derived quantity
@@ -187,11 +267,11 @@ struct prefixed_unit : scaled_unit<M* decltype(U)::mag, typename decltype(U)::re
 
 namespace detail {
 
-template<basic_symbol_text Symbol>
-void is_named_impl(const volatile named_unit<Symbol>*);
+template<basic_symbol_text Symbol, auto... Args>
+void is_named_impl(const volatile named_unit<Symbol, Args...>*);
 
-template<basic_symbol_text Symbol, Magnitude auto M, auto U>
-void is_named_impl(const volatile named_scaled_unit<Symbol, M, U>*);
+template<basic_symbol_text Symbol, Magnitude auto M, NamedUnit auto U>
+void is_named_impl(const volatile prefixed_unit<Symbol, M, U>*);
 
 template<Unit U>
 inline constexpr bool is_named<U> = requires(U * u) { is_named_impl(u); };
@@ -211,15 +291,20 @@ inline constexpr bool is_named<U> = requires(U * u) { is_named_impl(u); };
 // template<Magnitude auto M, typename U>
 // inline constexpr bool can_be_prefixed<scaled_unit<M, U>> = can_be_prefixed<typename U::reference>;
 
-
-template<Unit U1, Unit U2>
-struct unit_less : std::bool_constant<type_name<U1>() < type_name<U2>()> {};
-
-template<typename T1, typename T2>
-using type_list_of_unit_less = expr_less<T1, T2, unit_less>;
-
 }  // namespace detail
 
+template<Magnitude M, Unit U>
+[[nodiscard]] consteval Unit auto operator*(M mag, U)
+{
+  return scaled_unit<mag, U>{};
+}
+
+template<Magnitude M1, Magnitude auto M2, typename U>
+[[nodiscard]] consteval Unit auto operator*(M1 mag, scaled_unit<M2, U>)
+{
+  return scaled_unit<mag * M2, U>{};
+}
+
 template<Unit U1, Unit U2>
 [[nodiscard]] consteval Unit auto operator*(U1, U2)
 {
@@ -242,9 +327,16 @@ template<Unit U>
 template<Unit U1, Unit U2>
 [[nodiscard]] consteval bool operator==(U1, U2)
 {
-  return false;
+  return is_same_v<U1, U2>;
 }
 
+template<Unit U1, Unit U2>
+[[nodiscard]] consteval bool equivalent(U1, U2)
+{
+  return true;  // TODO implement this
+}
+
+
 // template<BaseDimension D1, BaseDimension D2>
 // constexpr bool operator==(D1, D2)
 // {
@@ -274,4 +366,16 @@ template<Unit U1, Unit U2>
 //          std::is_same_v<typename D1::normalized_den, typename D2::normalized_den>;
 // }
 
+template<Unit U>
+struct square_ : decltype(U{} * U{}) {};
+
+template<Unit auto U>
+inline constexpr square_<std::remove_const_t<decltype(U)>> square;
+
+template<Unit U>
+struct cubic_ : decltype(U{} * U{} * U{}) {};
+
+template<Unit auto U>
+inline constexpr cubic_<std::remove_const_t<decltype(U)>> cubic;
+
 }  // namespace units
diff --git a/src/systems/CMakeLists.txt b/src/systems/CMakeLists.txt
index 06a3169d..d313f744 100644
--- a/src/systems/CMakeLists.txt
+++ b/src/systems/CMakeLists.txt
@@ -24,17 +24,19 @@ cmake_minimum_required(VERSION 3.19)
 
 # systems
 add_subdirectory(isq)
-add_subdirectory(isq-iec80000)
-add_subdirectory(isq-natural)
+
+# add_subdirectory(isq-iec80000)
+# add_subdirectory(isq-natural)
 add_subdirectory(si)
 add_subdirectory(si-cgs)
-add_subdirectory(si-fps)
-add_subdirectory(si-hep)
-add_subdirectory(si-iau)
-add_subdirectory(si-imperial)
-add_subdirectory(si-international)
-add_subdirectory(si-typographic)
-add_subdirectory(si-uscs)
+
+# add_subdirectory(si-fps)
+# add_subdirectory(si-hep)
+# add_subdirectory(si-iau)
+# add_subdirectory(si-imperial)
+# add_subdirectory(si-international)
+# add_subdirectory(si-typographic)
+# add_subdirectory(si-uscs)
 
 # wrapper for all the systems
 add_library(mp-units-systems INTERFACE)
@@ -42,17 +44,17 @@ target_link_libraries(
     mp-units-systems
     INTERFACE
         mp-units::isq
-        mp-units::isq-iec80000
-        mp-units::isq-natural
+        # mp-units::isq-iec80000
+        # mp-units::isq-natural
         mp-units::si
         mp-units::si-cgs
-        mp-units::si-fps
-        mp-units::si-hep
-        mp-units::si-iau
-        mp-units::si-imperial
-        mp-units::si-international
-        mp-units::si-typographic
-        mp-units::si-uscs
+        # mp-units::si-fps
+        # mp-units::si-hep
+        # mp-units::si-iau
+        # mp-units::si-imperial
+        # mp-units::si-international
+        # mp-units::si-typographic
+        # mp-units::si-uscs
 )
 add_library(mp-units::systems ALIAS mp-units-systems)
 set_target_properties(mp-units-systems PROPERTIES EXPORT_NAME systems)
diff --git a/src/systems/isq/CMakeLists.txt b/src/systems/isq/CMakeLists.txt
index 029ebfe2..8824cf29 100644
--- a/src/systems/isq/CMakeLists.txt
+++ b/src/systems/isq/CMakeLists.txt
@@ -23,53 +23,6 @@
 cmake_minimum_required(VERSION 3.19)
 
 add_units_module(
-    isq
-    DEPENDENCIES mp-units::core
-    HEADERS include/units/isq/dimensions/absorbed_dose.h
-            include/units/isq/dimensions/acceleration.h
-            include/units/isq/dimensions/amount_of_substance.h
-            include/units/isq/dimensions/angular_acceleration.h
-            include/units/isq/dimensions/angular_velocity.h
-            include/units/isq/dimensions/area.h
-            include/units/isq/dimensions/capacitance.h
-            include/units/isq/dimensions/catalytic_activity.h
-            include/units/isq/dimensions/charge_density.h
-            include/units/isq/dimensions/concentration.h
-            include/units/isq/dimensions/conductance.h
-            include/units/isq/dimensions/current_density.h
-            include/units/isq/dimensions/density.h
-            include/units/isq/dimensions/dynamic_viscosity.h
-            include/units/isq/dimensions/electric_charge.h
-            include/units/isq/dimensions/electric_current.h
-            include/units/isq/dimensions/electric_field_strength.h
-            include/units/isq/dimensions/energy.h
-            include/units/isq/dimensions/energy_density.h
-            include/units/isq/dimensions/force.h
-            include/units/isq/dimensions/frequency.h
-            include/units/isq/dimensions/heat_capacity.h
-            include/units/isq/dimensions/inductance.h
-            include/units/isq/dimensions/length.h
-            include/units/isq/dimensions/luminance.h
-            include/units/isq/dimensions/luminous_flux.h
-            include/units/isq/dimensions/luminous_intensity.h
-            include/units/isq/dimensions/magnetic_flux.h
-            include/units/isq/dimensions/magnetic_induction.h
-            include/units/isq/dimensions/mass.h
-            include/units/isq/dimensions/molar_energy.h
-            include/units/isq/dimensions/momentum.h
-            include/units/isq/dimensions/permeability.h
-            include/units/isq/dimensions/permittivity.h
-            include/units/isq/dimensions/power.h
-            include/units/isq/dimensions/pressure.h
-            include/units/isq/dimensions/radioactivity.h
-            include/units/isq/dimensions/resistance.h
-            include/units/isq/dimensions/speed.h
-            include/units/isq/dimensions/surface_tension.h
-            include/units/isq/dimensions/thermal_conductivity.h
-            include/units/isq/dimensions/thermodynamic_temperature.h
-            include/units/isq/dimensions/time.h
-            include/units/isq/dimensions/torque.h
-            include/units/isq/dimensions/voltage.h
-            include/units/isq/dimensions/volume.h
-            include/units/isq/dimensions.h
+    isq DEPENDENCIES mp-units::core HEADERS include/units/isq/base_dimensions.h include/units/isq/isq.h
+                                            include/units/isq/mechanics.h include/units/isq/space_and_time.h
 )
diff --git a/src/systems/isq/include/units/isq/dimensions/angular_acceleration.h b/src/systems/isq/include/units/isq/base_dimensions.h
similarity index 61%
rename from src/systems/isq/include/units/isq/dimensions/angular_acceleration.h
rename to src/systems/isq/include/units/isq/base_dimensions.h
index a5d38a23..cabf9b61 100644
--- a/src/systems/isq/include/units/isq/dimensions/angular_acceleration.h
+++ b/src/systems/isq/include/units/isq/base_dimensions.h
@@ -22,19 +22,19 @@
 
 #pragma once
 
-#include <units/concepts.h>
-#include <units/generic/angle.h>
-#include <units/isq/dimensions/time.h>
+#include <units/dimension.h>
 
 namespace units::isq {
 
-template<typename Child, Unit U, typename...>
-struct dim_angular_acceleration;
-
-template<typename Child, Unit U, DimensionOfT<dim_angle> A, DimensionOfT<dim_time> T>
-struct dim_angular_acceleration<Child, U, A, T> : derived_dimension<Child, U, exponent<A, 1>, exponent<T, -2>> {};
-
-template<typename T>
-concept AngularAcceleration = QuantityOfT<T, dim_angular_acceleration>;
+// clang-format off
+inline constexpr struct length_dim : base_dimension<"L"> {} length_dim;
+inline constexpr struct mass_dim : base_dimension<"M"> {} mass_dim;
+inline constexpr struct time_dim : base_dimension<"T"> {} time_dim;
+inline constexpr struct electric_current_dim : base_dimension<"I"> {} electric_current_dim;
+// TODO Should the below use basic_symbol_text? How to name it for ASCII?
+inline constexpr struct thermodynamic_temperature_dim : base_dimension<"Θ"> {} thermodynamic_temperature_dim;
+inline constexpr struct amount_of_substance_dim : base_dimension<"N"> {} amount_of_substance_dim;
+inline constexpr struct luminous_intensity_dim : base_dimension<"J"> {} luminous_intensity_dim;
+// clang-format on
 
 }  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions.h b/src/systems/isq/include/units/isq/dimensions.h
deleted file mode 100644
index 5d226fcb..00000000
--- a/src/systems/isq/include/units/isq/dimensions.h
+++ /dev/null
@@ -1,74 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/absorbed_dose.h>
-#include <units/isq/dimensions/acceleration.h>
-#include <units/isq/dimensions/amount_of_substance.h>
-#include <units/isq/dimensions/angular_acceleration.h>
-#include <units/isq/dimensions/angular_velocity.h>
-#include <units/isq/dimensions/area.h>
-#include <units/isq/dimensions/capacitance.h>
-#include <units/isq/dimensions/catalytic_activity.h>
-#include <units/isq/dimensions/charge_density.h>
-#include <units/isq/dimensions/concentration.h>
-#include <units/isq/dimensions/conductance.h>
-#include <units/isq/dimensions/current_density.h>
-#include <units/isq/dimensions/density.h>
-#include <units/isq/dimensions/dynamic_viscosity.h>
-#include <units/isq/dimensions/electric_charge.h>
-#include <units/isq/dimensions/electric_current.h>
-#include <units/isq/dimensions/electric_field_strength.h>
-#include <units/isq/dimensions/energy.h>
-// TODO Add when downcasting issue is solved (collides with pressure)
-// #include <units/isq/dimensions/energy_density.h>
-#include <units/isq/dimensions/force.h>
-#include <units/isq/dimensions/frequency.h>
-#include <units/isq/dimensions/heat_capacity.h>
-#include <units/isq/dimensions/inductance.h>
-#include <units/isq/dimensions/length.h>
-#include <units/isq/dimensions/luminance.h>
-#include <units/isq/dimensions/luminous_flux.h>
-#include <units/isq/dimensions/luminous_intensity.h>
-#include <units/isq/dimensions/magnetic_flux.h>
-#include <units/isq/dimensions/magnetic_induction.h>
-#include <units/isq/dimensions/mass.h>
-#include <units/isq/dimensions/molar_energy.h>
-#include <units/isq/dimensions/momentum.h>
-#include <units/isq/dimensions/permeability.h>
-#include <units/isq/dimensions/permittivity.h>
-#include <units/isq/dimensions/power.h>
-#include <units/isq/dimensions/pressure.h>
-// TODO Add when downcasting issue is solved (collides with frequency)
-// #include <units/isq/dimensions/radioactivity.h>
-#include <units/isq/dimensions/resistance.h>
-#include <units/isq/dimensions/speed.h>
-#include <units/isq/dimensions/surface_tension.h>
-#include <units/isq/dimensions/thermal_conductivity.h>
-#include <units/isq/dimensions/thermodynamic_temperature.h>
-#include <units/isq/dimensions/time.h>
-#include <units/isq/dimensions/torque.h>
-#include <units/isq/dimensions/voltage.h>
-#include <units/isq/dimensions/volume.h>
-// IWYU pragma: end_exports
diff --git a/src/systems/isq/include/units/isq/dimensions/absorbed_dose.h b/src/systems/isq/include/units/isq/dimensions/absorbed_dose.h
deleted file mode 100644
index 633af9a7..00000000
--- a/src/systems/isq/include/units/isq/dimensions/absorbed_dose.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-#include <units/isq/dimensions/energy.h>
-#include <units/isq/dimensions/mass.h>
-
-namespace units::isq {
-
-template<typename Child, Unit U, typename...>
-struct dim_absorbed_dose;
-
-template<typename Child, Unit U, DimensionOfT<dim_energy> E, DimensionOfT<dim_mass> M>
-struct dim_absorbed_dose<Child, U, E, M> : derived_dimension<Child, U, exponent<E, 1>, exponent<M, -1>> {};
-
-template<typename T>
-concept AbsorbedDose = QuantityOfT<T, dim_absorbed_dose>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/acceleration.h b/src/systems/isq/include/units/isq/dimensions/acceleration.h
deleted file mode 100644
index a122ec6d..00000000
--- a/src/systems/isq/include/units/isq/dimensions/acceleration.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-#include <units/isq/dimensions/length.h>
-#include <units/isq/dimensions/time.h>
-
-namespace units::isq {
-
-template<typename Child, Unit U, typename...>
-struct dim_acceleration;
-
-template<typename Child, Unit U, DimensionOfT<dim_length> L, DimensionOfT<dim_time> T>
-struct dim_acceleration<Child, U, L, T> : derived_dimension<Child, U, exponent<L, 1>, exponent<T, -2>> {};
-
-template<typename T>
-concept Acceleration = QuantityOfT<T, dim_acceleration>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/amount_of_substance.h b/src/systems/isq/include/units/isq/dimensions/amount_of_substance.h
deleted file mode 100644
index 099e516f..00000000
--- a/src/systems/isq/include/units/isq/dimensions/amount_of_substance.h
+++ /dev/null
@@ -1,35 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-
-namespace units::isq {
-
-template<Unit U>
-struct dim_amount_of_substance : base_dimension<"N", U> {};
-
-template<typename T>
-concept AmountOfSubstance = QuantityOfT<T, dim_amount_of_substance>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/angular_velocity.h b/src/systems/isq/include/units/isq/dimensions/angular_velocity.h
deleted file mode 100644
index e2ae4b69..00000000
--- a/src/systems/isq/include/units/isq/dimensions/angular_velocity.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-#include <units/generic/angle.h>
-#include <units/isq/dimensions/time.h>
-
-namespace units::isq {
-
-template<typename Child, Unit U, typename...>
-struct dim_angular_velocity;
-
-template<typename Child, Unit U, DimensionOfT<dim_angle> A, DimensionOfT<dim_time> T>
-struct dim_angular_velocity<Child, U, A, T> : derived_dimension<Child, U, exponent<A, 1>, exponent<T, -1>> {};
-
-template<typename T>
-concept AngularVelocity = QuantityOfT<T, dim_angular_velocity>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/capacitance.h b/src/systems/isq/include/units/isq/dimensions/capacitance.h
deleted file mode 100644
index 8f474587..00000000
--- a/src/systems/isq/include/units/isq/dimensions/capacitance.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-#include <units/isq/dimensions/electric_charge.h>
-#include <units/isq/dimensions/voltage.h>
-
-namespace units::isq {
-
-template<typename Child, Unit U, typename...>
-struct dim_capacitance;
-
-template<typename Child, Unit U, DimensionOfT<dim_electric_charge> C, DimensionOfT<dim_voltage> V>
-struct dim_capacitance<Child, U, C, V> : derived_dimension<Child, U, exponent<C, 1>, exponent<V, -1>> {};
-
-template<typename T>
-concept Capacitance = QuantityOfT<T, dim_capacitance>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/catalytic_activity.h b/src/systems/isq/include/units/isq/dimensions/catalytic_activity.h
deleted file mode 100644
index f0d67250..00000000
--- a/src/systems/isq/include/units/isq/dimensions/catalytic_activity.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-#include <units/isq/dimensions/amount_of_substance.h>
-#include <units/isq/dimensions/time.h>
-
-namespace units::isq {
-
-template<typename Child, Unit U, typename...>
-struct dim_catalytic_activity;
-
-template<typename Child, Unit U, DimensionOfT<dim_time> T, DimensionOfT<dim_amount_of_substance> M>
-struct dim_catalytic_activity<Child, U, T, M> : derived_dimension<Child, U, exponent<T, -1>, exponent<M, 1>> {};
-
-template<typename T>
-concept CatalyticActivity = QuantityOfT<T, dim_catalytic_activity>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/charge_density.h b/src/systems/isq/include/units/isq/dimensions/charge_density.h
deleted file mode 100644
index 8625665a..00000000
--- a/src/systems/isq/include/units/isq/dimensions/charge_density.h
+++ /dev/null
@@ -1,49 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-#include <units/isq/dimensions/electric_charge.h>
-#include <units/isq/dimensions/length.h>
-
-namespace units::isq {
-
-template<typename Child, Unit U, typename...>
-struct dim_charge_density;
-
-template<typename Child, Unit U, DimensionOfT<dim_electric_charge> Q, DimensionOfT<dim_length> L>
-struct dim_charge_density<Child, U, Q, L> : derived_dimension<Child, U, exponent<Q, 1>, exponent<L, -3>> {};
-
-template<typename Child, Unit U, typename...>
-struct dim_surface_charge_density;
-
-template<typename Child, Unit U, DimensionOfT<dim_electric_charge> Q, DimensionOfT<dim_length> L>
-struct dim_surface_charge_density<Child, U, Q, L> : derived_dimension<Child, U, exponent<Q, 1>, exponent<L, -2>> {};
-
-template<typename T>
-concept ChargeDensity = QuantityOfT<T, dim_charge_density>;
-
-template<typename T>
-concept SurfaceChargeDensity = QuantityOfT<T, dim_surface_charge_density>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/concentration.h b/src/systems/isq/include/units/isq/dimensions/concentration.h
deleted file mode 100644
index c5181d44..00000000
--- a/src/systems/isq/include/units/isq/dimensions/concentration.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-#include <units/isq/dimensions/amount_of_substance.h>
-#include <units/isq/dimensions/length.h>
-
-namespace units::isq {
-
-template<typename Child, Unit U, typename...>
-struct dim_concentration;
-
-template<typename Child, Unit U, DimensionOfT<dim_amount_of_substance> M, DimensionOfT<dim_length> L>
-struct dim_concentration<Child, U, M, L> : derived_dimension<Child, U, exponent<M, 1>, exponent<L, -3>> {};
-
-template<typename T>
-concept Concentration = QuantityOfT<T, dim_concentration>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/current_density.h b/src/systems/isq/include/units/isq/dimensions/current_density.h
deleted file mode 100644
index f097de77..00000000
--- a/src/systems/isq/include/units/isq/dimensions/current_density.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-#include <units/isq/dimensions/electric_current.h>
-#include <units/isq/dimensions/length.h>
-
-namespace units::isq {
-
-template<typename Child, Unit U, typename...>
-struct dim_current_density;
-
-template<typename Child, Unit U, DimensionOfT<dim_electric_current> I, DimensionOfT<dim_length> L>
-struct dim_current_density<Child, U, I, L> : derived_dimension<Child, U, exponent<I, 1>, exponent<L, -2>> {};
-
-template<typename T>
-concept CurrentDensity = QuantityOfT<T, dim_current_density>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/density.h b/src/systems/isq/include/units/isq/dimensions/density.h
deleted file mode 100644
index cb5196d9..00000000
--- a/src/systems/isq/include/units/isq/dimensions/density.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-#include <units/isq/dimensions/length.h>
-#include <units/isq/dimensions/mass.h>
-
-namespace units::isq {
-
-template<typename Child, Unit U, typename...>
-struct dim_density;
-
-template<typename Child, Unit U, DimensionOfT<dim_mass> M, DimensionOfT<dim_length> L>
-struct dim_density<Child, U, M, L> : derived_dimension<Child, U, exponent<M, 1>, exponent<L, -3>> {};
-
-template<typename T>
-concept Density = QuantityOfT<T, dim_density>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/dynamic_viscosity.h b/src/systems/isq/include/units/isq/dimensions/dynamic_viscosity.h
deleted file mode 100644
index ceac79e5..00000000
--- a/src/systems/isq/include/units/isq/dimensions/dynamic_viscosity.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-#include <units/isq/dimensions/pressure.h>
-#include <units/isq/dimensions/time.h>
-
-namespace units::isq {
-
-template<typename Child, Unit U, typename...>
-struct dim_dynamic_viscosity;
-
-template<typename Child, Unit U, DimensionOfT<dim_pressure> P, DimensionOfT<dim_time> T>
-struct dim_dynamic_viscosity<Child, U, P, T> : derived_dimension<Child, U, exponent<P, 1>, exponent<T, 1>> {};
-
-template<typename T>
-concept DynamicViscosity = QuantityOfT<T, dim_dynamic_viscosity>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/electric_charge.h b/src/systems/isq/include/units/isq/dimensions/electric_charge.h
deleted file mode 100644
index 2c7db791..00000000
--- a/src/systems/isq/include/units/isq/dimensions/electric_charge.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-#include <units/isq/dimensions/electric_current.h>
-#include <units/isq/dimensions/time.h>
-
-namespace units::isq {
-
-template<typename Child, Unit U, typename...>
-struct dim_electric_charge;
-
-template<typename Child, Unit U, DimensionOfT<dim_time> T, DimensionOfT<dim_electric_current> C>
-struct dim_electric_charge<Child, U, T, C> : derived_dimension<Child, U, exponent<T, 1>, exponent<C, 1>> {};
-
-template<typename T>
-concept ElectricCharge = QuantityOfT<T, dim_electric_charge>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/electric_current.h b/src/systems/isq/include/units/isq/dimensions/electric_current.h
deleted file mode 100644
index 52a3a4a1..00000000
--- a/src/systems/isq/include/units/isq/dimensions/electric_current.h
+++ /dev/null
@@ -1,35 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-
-namespace units::isq {
-
-template<Unit U>
-struct dim_electric_current : base_dimension<"I", U> {};
-
-template<typename T>
-concept ElectricCurrent = QuantityOfT<T, dim_electric_current>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/electric_field_strength.h b/src/systems/isq/include/units/isq/dimensions/electric_field_strength.h
deleted file mode 100644
index 4bcd78f6..00000000
--- a/src/systems/isq/include/units/isq/dimensions/electric_field_strength.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-#include <units/isq/dimensions/length.h>
-#include <units/isq/dimensions/voltage.h>
-
-namespace units::isq {
-
-template<typename Child, Unit U, typename...>
-struct dim_electric_field_strength;
-
-template<typename Child, Unit U, DimensionOfT<dim_voltage> V, DimensionOfT<dim_length> L>
-struct dim_electric_field_strength<Child, U, V, L> : derived_dimension<Child, U, exponent<V, 1>, exponent<L, -1>> {};
-
-template<typename T>
-concept ElectricFieldStrength = QuantityOfT<T, dim_electric_field_strength>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/energy.h b/src/systems/isq/include/units/isq/dimensions/energy.h
deleted file mode 100644
index db090615..00000000
--- a/src/systems/isq/include/units/isq/dimensions/energy.h
+++ /dev/null
@@ -1,43 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-#include <units/isq/dimensions/force.h>
-#include <units/isq/dimensions/length.h>
-
-namespace units::isq {
-
-template<typename Child, Unit U, typename...>
-struct dim_energy;
-
-template<typename Child, Unit U, DimensionOfT<dim_force> F, DimensionOfT<dim_length> L>
-struct dim_energy<Child, U, F, L> : derived_dimension<Child, U, exponent<F, 1>, exponent<L, 1>> {};
-
-template<typename Child, Unit U, DimensionOfT<dim_length> L, DimensionOfT<dim_force> F>
-struct dim_energy<Child, U, L, F> : derived_dimension<Child, U, exponent<L, 1>, exponent<F, 1>> {};
-
-template<typename T>
-concept Energy = QuantityOfT<T, dim_energy>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/energy_density.h b/src/systems/isq/include/units/isq/dimensions/energy_density.h
deleted file mode 100644
index aa63cbca..00000000
--- a/src/systems/isq/include/units/isq/dimensions/energy_density.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-#include <units/isq/dimensions/energy.h>
-#include <units/isq/dimensions/volume.h>
-
-namespace units::isq {
-
-template<typename Child, Unit U, typename...>
-struct dim_energy_density;
-
-template<typename Child, Unit U, DimensionOfT<dim_energy> E, DimensionOfT<dim_volume> V>
-struct dim_energy_density<Child, U, E, V> : derived_dimension<Child, U, exponent<E, 1>, exponent<V, -1>> {};
-
-template<typename T>
-concept EnergyDensity = QuantityOfT<T, dim_energy_density>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/force.h b/src/systems/isq/include/units/isq/dimensions/force.h
deleted file mode 100644
index 20dc9540..00000000
--- a/src/systems/isq/include/units/isq/dimensions/force.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-#include <units/isq/dimensions/acceleration.h>
-#include <units/isq/dimensions/mass.h>
-
-namespace units::isq {
-
-template<typename Child, Unit U, typename...>
-struct dim_force;
-
-template<typename Child, Unit U, DimensionOfT<dim_mass> M, DimensionOfT<dim_acceleration> A>
-struct dim_force<Child, U, M, A> : derived_dimension<Child, U, exponent<M, 1>, exponent<A, 1>> {};
-
-template<typename T>
-concept Force = QuantityOfT<T, dim_force>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/frequency.h b/src/systems/isq/include/units/isq/dimensions/frequency.h
deleted file mode 100644
index 4b3dc285..00000000
--- a/src/systems/isq/include/units/isq/dimensions/frequency.h
+++ /dev/null
@@ -1,39 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-#include <units/isq/dimensions/time.h>
-
-namespace units::isq {
-
-template<typename Child, Unit U, typename...>
-struct dim_frequency;
-
-template<typename Child, Unit U, DimensionOfT<dim_time> T>
-struct dim_frequency<Child, U, T> : derived_dimension<Child, U, exponent<T, -1>> {};
-
-template<typename T>
-concept Frequency = QuantityOfT<T, dim_frequency>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/heat_capacity.h b/src/systems/isq/include/units/isq/dimensions/heat_capacity.h
deleted file mode 100644
index d4c3e0d4..00000000
--- a/src/systems/isq/include/units/isq/dimensions/heat_capacity.h
+++ /dev/null
@@ -1,60 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-#include <units/isq/dimensions/amount_of_substance.h>
-#include <units/isq/dimensions/energy.h>
-#include <units/isq/dimensions/mass.h>
-#include <units/isq/dimensions/thermodynamic_temperature.h>
-
-namespace units::isq {
-
-template<typename Child, Unit U, typename...>
-struct dim_heat_capacity;
-
-template<typename Child, Unit U, DimensionOfT<dim_energy> E, DimensionOfT<dim_thermodynamic_temperature> T>
-struct dim_heat_capacity<Child, U, E, T> : derived_dimension<Child, U, exponent<E, 1>, exponent<T, -1>> {};
-
-template<typename Child, Unit U, typename...>
-struct dim_specific_heat_capacity;
-
-template<typename Child, Unit U, DimensionOfT<dim_heat_capacity> C, DimensionOfT<dim_mass> M>
-struct dim_specific_heat_capacity<Child, U, C, M> : derived_dimension<Child, U, exponent<C, 1>, exponent<M, -1>> {};
-
-template<typename Child, Unit U, typename...>
-struct dim_molar_heat_capacity;
-
-template<typename Child, Unit U, DimensionOfT<dim_heat_capacity> C, DimensionOfT<dim_amount_of_substance> M>
-struct dim_molar_heat_capacity<Child, U, C, M> : derived_dimension<Child, U, exponent<C, 1>, exponent<M, -1>> {};
-
-template<typename T>
-concept HeatCapacity = QuantityOfT<T, dim_heat_capacity>;
-
-template<typename T>
-concept SpecificHeatCapacity = QuantityOfT<T, dim_specific_heat_capacity>;
-
-template<typename T>
-concept MolarHeatCapacity = QuantityOfT<T, dim_molar_heat_capacity>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/inductance.h b/src/systems/isq/include/units/isq/dimensions/inductance.h
deleted file mode 100644
index 90ae21cd..00000000
--- a/src/systems/isq/include/units/isq/dimensions/inductance.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-#include <units/isq/dimensions/electric_current.h>
-#include <units/isq/dimensions/magnetic_flux.h>
-
-namespace units::isq {
-
-template<typename Child, Unit U, typename...>
-struct dim_inductance;
-
-template<typename Child, Unit U, DimensionOfT<dim_magnetic_flux> F, DimensionOfT<dim_electric_current> I>
-struct dim_inductance<Child, U, F, I> : derived_dimension<Child, U, exponent<F, 1>, exponent<I, -1>> {};
-
-template<typename T>
-concept Inductance = QuantityOfT<T, dim_inductance>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/length.h b/src/systems/isq/include/units/isq/dimensions/length.h
deleted file mode 100644
index 39170399..00000000
--- a/src/systems/isq/include/units/isq/dimensions/length.h
+++ /dev/null
@@ -1,35 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-
-namespace units::isq {
-
-template<Unit U>
-struct dim_length : base_dimension<"L", U> {};
-
-template<typename T>
-concept Length = QuantityOfT<T, dim_length>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/luminance.h b/src/systems/isq/include/units/isq/dimensions/luminance.h
deleted file mode 100644
index c5215828..00000000
--- a/src/systems/isq/include/units/isq/dimensions/luminance.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-#include <units/isq/dimensions/length.h>
-#include <units/isq/dimensions/luminous_intensity.h>
-
-namespace units::isq {
-
-template<typename Child, Unit U, typename...>
-struct dim_luminance;
-
-template<typename Child, Unit U, DimensionOfT<dim_luminous_intensity> I, DimensionOfT<dim_length> L>
-struct dim_luminance<Child, U, I, L> : derived_dimension<Child, U, exponent<I, 1>, exponent<L, -2>> {};
-
-template<typename T>
-concept Luminance = QuantityOfT<T, dim_luminance>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/luminous_flux.h b/src/systems/isq/include/units/isq/dimensions/luminous_flux.h
deleted file mode 100644
index ffa81053..00000000
--- a/src/systems/isq/include/units/isq/dimensions/luminous_flux.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-#include <units/generic/solid_angle.h>
-#include <units/isq/dimensions/luminous_intensity.h>
-
-namespace units::isq {
-
-template<typename Child, Unit U, typename...>
-struct dim_luminous_flux;
-
-template<typename Child, Unit U, DimensionOfT<dim_luminous_intensity> I, DimensionOfT<dim_solid_angle> A>
-struct dim_luminous_flux<Child, U, I, A> : derived_dimension<Child, U, exponent<I, 1>, exponent<A, 1>> {};
-
-template<typename T>
-concept LuminousFlux = QuantityOfT<T, dim_luminous_flux>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/magnetic_flux.h b/src/systems/isq/include/units/isq/dimensions/magnetic_flux.h
deleted file mode 100644
index d0f2dab5..00000000
--- a/src/systems/isq/include/units/isq/dimensions/magnetic_flux.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-#include <units/isq/dimensions/area.h>
-#include <units/isq/dimensions/magnetic_induction.h>
-
-namespace units::isq {
-
-template<typename Child, Unit U, typename...>
-struct dim_magnetic_flux;
-
-template<typename Child, Unit U, DimensionOfT<dim_magnetic_induction> B, DimensionOfT<dim_area> A>
-struct dim_magnetic_flux<Child, U, B, A> : derived_dimension<Child, U, exponent<B, 1>, exponent<A, 1>> {};
-
-template<typename T>
-concept MagneticFlux = QuantityOfT<T, dim_magnetic_flux>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/magnetic_induction.h b/src/systems/isq/include/units/isq/dimensions/magnetic_induction.h
deleted file mode 100644
index b7b54c0b..00000000
--- a/src/systems/isq/include/units/isq/dimensions/magnetic_induction.h
+++ /dev/null
@@ -1,42 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-#include <units/isq/dimensions/length.h>
-#include <units/isq/dimensions/time.h>
-#include <units/isq/dimensions/voltage.h>
-
-namespace units::isq {
-
-template<typename Child, Unit U, typename...>
-struct dim_magnetic_induction;
-
-template<typename Child, Unit U, DimensionOfT<dim_voltage> V, DimensionOfT<dim_time> T, DimensionOfT<dim_length> L>
-struct dim_magnetic_induction<Child, U, V, T, L> :
-    derived_dimension<Child, U, exponent<V, 1>, exponent<T, 1>, exponent<L, -2>> {};
-
-template<typename T>
-concept MagneticInduction = QuantityOfT<T, dim_magnetic_induction>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/mass.h b/src/systems/isq/include/units/isq/dimensions/mass.h
deleted file mode 100644
index a2706b61..00000000
--- a/src/systems/isq/include/units/isq/dimensions/mass.h
+++ /dev/null
@@ -1,35 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-
-namespace units::isq {
-
-template<Unit U>
-struct dim_mass : base_dimension<"M", U> {};
-
-template<typename T>
-concept Mass = QuantityOfT<T, dim_mass>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/molar_energy.h b/src/systems/isq/include/units/isq/dimensions/molar_energy.h
deleted file mode 100644
index a8b152b0..00000000
--- a/src/systems/isq/include/units/isq/dimensions/molar_energy.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-#include <units/isq/dimensions/amount_of_substance.h>
-#include <units/isq/dimensions/energy.h>
-
-namespace units::isq {
-
-template<typename Child, Unit U, typename...>
-struct dim_molar_energy;
-
-template<typename Child, Unit U, DimensionOfT<dim_energy> E, DimensionOfT<dim_amount_of_substance> M>
-struct dim_molar_energy<Child, U, E, M> : derived_dimension<Child, U, exponent<E, 1>, exponent<M, -1>> {};
-
-template<typename T>
-concept MolarEnergy = QuantityOfT<T, dim_molar_energy>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/momentum.h b/src/systems/isq/include/units/isq/dimensions/momentum.h
deleted file mode 100644
index 8508fb0a..00000000
--- a/src/systems/isq/include/units/isq/dimensions/momentum.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-#include <units/isq/dimensions/mass.h>
-#include <units/isq/dimensions/speed.h>
-
-namespace units::isq {
-
-template<typename Child, Unit U, typename...>
-struct dim_momentum;
-
-template<typename Child, Unit U, DimensionOfT<dim_mass> M, DimensionOfT<dim_speed> V>
-struct dim_momentum<Child, U, M, V> : derived_dimension<Child, U, exponent<M, 1>, exponent<V, 1>> {};
-
-template<typename T>
-concept Momentum = QuantityOfT<T, dim_momentum>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/permeability.h b/src/systems/isq/include/units/isq/dimensions/permeability.h
deleted file mode 100644
index 01543a57..00000000
--- a/src/systems/isq/include/units/isq/dimensions/permeability.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-#include <units/isq/dimensions/inductance.h>
-#include <units/isq/dimensions/length.h>
-
-namespace units::isq {
-
-template<typename Child, Unit U, typename...>
-struct dim_permeability;
-
-template<typename Child, Unit U, DimensionOfT<dim_inductance> H, DimensionOfT<dim_length> L>
-struct dim_permeability<Child, U, H, L> : derived_dimension<Child, U, exponent<H, 1>, exponent<L, -1>> {};
-
-template<typename T>
-concept Permeability = QuantityOfT<T, dim_permeability>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/permittivity.h b/src/systems/isq/include/units/isq/dimensions/permittivity.h
deleted file mode 100644
index 70601e6d..00000000
--- a/src/systems/isq/include/units/isq/dimensions/permittivity.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-#include <units/isq/dimensions/capacitance.h>
-#include <units/isq/dimensions/length.h>
-
-namespace units::isq {
-
-template<typename Child, Unit U, typename...>
-struct dim_permittivity;
-
-template<typename Child, Unit U, DimensionOfT<dim_capacitance> C, DimensionOfT<dim_length> L>
-struct dim_permittivity<Child, U, C, L> : derived_dimension<Child, U, exponent<C, 1>, exponent<L, -1>> {};
-
-template<typename T>
-concept Permittivity = QuantityOfT<T, dim_permittivity>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/power.h b/src/systems/isq/include/units/isq/dimensions/power.h
deleted file mode 100644
index 5a0b24ca..00000000
--- a/src/systems/isq/include/units/isq/dimensions/power.h
+++ /dev/null
@@ -1,43 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-#include <units/isq/dimensions/energy.h>
-#include <units/isq/dimensions/time.h>
-
-namespace units::isq {
-
-template<typename Child, Unit U, typename...>
-struct dim_power;
-
-template<typename Child, Unit U, DimensionOfT<dim_energy> E, DimensionOfT<dim_time> T>
-struct dim_power<Child, U, E, T> : derived_dimension<Child, U, exponent<E, 1>, exponent<T, -1>> {};
-
-template<typename Child, Unit U, DimensionOfT<dim_length> L, DimensionOfT<dim_force> F, DimensionOfT<dim_time> T>
-struct dim_power<Child, U, L, F, T> : derived_dimension<Child, U, exponent<L, 1>, exponent<F, 1>, exponent<T, -1>> {};
-
-template<typename T>
-concept Power = QuantityOfT<T, dim_power>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/pressure.h b/src/systems/isq/include/units/isq/dimensions/pressure.h
deleted file mode 100644
index 47578401..00000000
--- a/src/systems/isq/include/units/isq/dimensions/pressure.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-#include <units/isq/dimensions/area.h>
-#include <units/isq/dimensions/force.h>
-
-namespace units::isq {
-
-template<typename Child, Unit U, typename...>
-struct dim_pressure;
-
-template<typename Child, Unit U, DimensionOfT<dim_force> F, DimensionOfT<dim_area> A>
-struct dim_pressure<Child, U, F, A> : derived_dimension<Child, U, exponent<F, 1>, exponent<A, -1>> {};
-
-template<typename T>
-concept Pressure = QuantityOfT<T, dim_pressure>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/radioactivity.h b/src/systems/isq/include/units/isq/dimensions/radioactivity.h
deleted file mode 100644
index 591a1da9..00000000
--- a/src/systems/isq/include/units/isq/dimensions/radioactivity.h
+++ /dev/null
@@ -1,39 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-#include <units/isq/dimensions/time.h>
-
-namespace units::isq {
-
-template<typename Child, Unit U, typename...>
-struct dim_radioactivity;
-
-template<typename Child, Unit U, DimensionOfT<dim_time> T>
-struct dim_radioactivity<Child, U, T> : derived_dimension<Child, U, exponent<T, -1>> {};
-
-template<typename T>
-concept Radioactivity = QuantityOfT<T, dim_radioactivity>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/resistance.h b/src/systems/isq/include/units/isq/dimensions/resistance.h
deleted file mode 100644
index e9d8f9b5..00000000
--- a/src/systems/isq/include/units/isq/dimensions/resistance.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-#include <units/isq/dimensions/electric_current.h>
-#include <units/isq/dimensions/voltage.h>
-
-namespace units::isq {
-
-template<typename Child, Unit U, typename...>
-struct dim_resistance;
-
-template<typename Child, Unit U, DimensionOfT<dim_voltage> V, DimensionOfT<dim_electric_current> C>
-struct dim_resistance<Child, U, V, C> : derived_dimension<Child, U, exponent<V, 1>, exponent<C, -1>> {};
-
-template<typename T>
-concept Resistance = QuantityOfT<T, dim_resistance>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/speed.h b/src/systems/isq/include/units/isq/dimensions/speed.h
deleted file mode 100644
index d681420a..00000000
--- a/src/systems/isq/include/units/isq/dimensions/speed.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-#include <units/isq/dimensions/length.h>
-#include <units/isq/dimensions/time.h>
-
-namespace units::isq {
-
-template<typename Child, Unit U, typename...>
-struct dim_speed;
-
-template<typename Child, Unit U, DimensionOfT<dim_length> L, DimensionOfT<dim_time> T>
-struct dim_speed<Child, U, L, T> : derived_dimension<Child, U, exponent<L, 1>, exponent<T, -1>> {};
-
-template<typename T>
-concept Speed = QuantityOfT<T, dim_speed>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/surface_tension.h b/src/systems/isq/include/units/isq/dimensions/surface_tension.h
deleted file mode 100644
index 52cdd3f3..00000000
--- a/src/systems/isq/include/units/isq/dimensions/surface_tension.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-#include <units/isq/dimensions/force.h>
-#include <units/isq/dimensions/length.h>
-
-namespace units::isq {
-
-template<typename Child, Unit U, typename...>
-struct dim_surface_tension;
-
-template<typename Child, Unit U, DimensionOfT<dim_force> F, DimensionOfT<dim_length> L>
-struct dim_surface_tension<Child, U, F, L> : derived_dimension<Child, U, exponent<F, 1>, exponent<L, -1>> {};
-
-template<typename T>
-concept SurfaceTension = QuantityOfT<T, dim_surface_tension>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/thermal_conductivity.h b/src/systems/isq/include/units/isq/dimensions/thermal_conductivity.h
deleted file mode 100644
index 1fe804d5..00000000
--- a/src/systems/isq/include/units/isq/dimensions/thermal_conductivity.h
+++ /dev/null
@@ -1,43 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-#include <units/isq/dimensions/length.h>
-#include <units/isq/dimensions/power.h>
-#include <units/isq/dimensions/thermodynamic_temperature.h>
-
-namespace units::isq {
-
-template<typename Child, Unit U, typename...>
-struct dim_thermal_conductivity;
-
-template<typename Child, Unit U, DimensionOfT<dim_power> P, DimensionOfT<dim_length> L,
-         DimensionOfT<dim_thermodynamic_temperature> T>
-struct dim_thermal_conductivity<Child, U, P, L, T> :
-    derived_dimension<Child, U, exponent<P, 1>, exponent<L, -1>, exponent<T, -1>> {};
-
-template<typename T>
-concept ThermalConductivity = QuantityOfT<T, dim_thermal_conductivity>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/thermodynamic_temperature.h b/src/systems/isq/include/units/isq/dimensions/thermodynamic_temperature.h
deleted file mode 100644
index 8db16a23..00000000
--- a/src/systems/isq/include/units/isq/dimensions/thermodynamic_temperature.h
+++ /dev/null
@@ -1,35 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-
-namespace units::isq {
-
-template<Unit U>
-struct dim_thermodynamic_temperature : base_dimension<"Θ", U> {};
-
-template<typename T>
-concept ThermodynamicTemperature = QuantityOfT<T, dim_thermodynamic_temperature>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/torque.h b/src/systems/isq/include/units/isq/dimensions/torque.h
deleted file mode 100644
index e134318e..00000000
--- a/src/systems/isq/include/units/isq/dimensions/torque.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-#include <units/generic/angle.h>
-#include <units/isq/dimensions/energy.h>
-
-namespace units::isq {
-
-template<typename Child, Unit U, typename...>
-struct dim_torque;
-
-template<typename Child, Unit U, DimensionOfT<dim_force> F, DimensionOfT<dim_length> L, DimensionOfT<dim_angle> A>
-struct dim_torque<Child, U, F, L, A> : derived_dimension<Child, U, exponent<F, 1>, exponent<L, 1>, exponent<A, -1>> {};
-
-template<typename T>
-concept Torque = QuantityOfT<T, dim_torque>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/voltage.h b/src/systems/isq/include/units/isq/dimensions/voltage.h
deleted file mode 100644
index 187d5808..00000000
--- a/src/systems/isq/include/units/isq/dimensions/voltage.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-#include <units/isq/dimensions/electric_current.h>
-#include <units/isq/dimensions/power.h>
-
-namespace units::isq {
-
-template<typename Child, Unit U, typename...>
-struct dim_voltage;
-
-template<typename Child, Unit U, DimensionOfT<dim_power> P, DimensionOfT<dim_electric_current> C>
-struct dim_voltage<Child, U, P, C> : derived_dimension<Child, U, exponent<P, 1>, exponent<C, -1>> {};
-
-template<typename T>
-concept Voltage = QuantityOfT<T, dim_voltage>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/volume.h b/src/systems/isq/include/units/isq/dimensions/volume.h
deleted file mode 100644
index e8c3149d..00000000
--- a/src/systems/isq/include/units/isq/dimensions/volume.h
+++ /dev/null
@@ -1,39 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/concepts.h>
-#include <units/isq/dimensions/length.h>
-
-namespace units::isq {
-
-template<typename Child, Unit U, typename...>
-struct dim_volume;
-
-template<typename Child, Unit U, DimensionOfT<dim_length> L>
-struct dim_volume<Child, U, L> : derived_dimension<Child, U, exponent<L, 3>> {};
-
-template<typename T>
-concept Volume = QuantityOfT<T, dim_volume>;
-
-}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/dimensions/time.h b/src/systems/isq/include/units/isq/isq.h
similarity index 84%
rename from src/systems/isq/include/units/isq/dimensions/time.h
rename to src/systems/isq/include/units/isq/isq.h
index f07b82d9..b32b820c 100644
--- a/src/systems/isq/include/units/isq/dimensions/time.h
+++ b/src/systems/isq/include/units/isq/isq.h
@@ -22,14 +22,7 @@
 
 #pragma once
 
-#include <units/concepts.h>
-
-namespace units::isq {
-
-template<Unit U>
-struct dim_time : base_dimension<"T", U> {};
-
-template<typename T>
-concept Time = QuantityOfT<T, dim_time>;
-
-}  // namespace units::isq
+// IWYU pragma: begin_exports
+#include <units/isq/base_dimensions.h>
+#include <units/isq/space_and_time.h>
+// IWYU pragma: end_exports
diff --git a/src/systems/isq/include/units/isq/mechanics.h b/src/systems/isq/include/units/isq/mechanics.h
new file mode 100644
index 00000000..3f4271d9
--- /dev/null
+++ b/src/systems/isq/include/units/isq/mechanics.h
@@ -0,0 +1,72 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2018 Mateusz Pusz
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#pragma once
+
+#include <units/dimension.h>
+#include <units/isq/base_dimensions.h>
+#include <units/isq/space_and_time.h>
+
+namespace units::isq {
+
+// clang-format off
+// inline constexpr struct mass_dim : base_dimension<"M"> {} mass_dim;
+inline constexpr struct mass_density_dim : decltype(mass_dim / volume_dim) {} mass_density_dim;
+inline constexpr struct specific_volume_dim : decltype(1 / mass_density_dim) {} specific_volume_dim;
+inline constexpr struct relative_mass_density_dim : decltype(mass_density_dim / mass_density_dim) {} relative_mass_density_dim;
+inline constexpr struct surface_mass_density_dim : decltype(mass_dim / area_dim) {} surface_mass_density_dim;
+inline constexpr struct linear_mass_density_dim : decltype(mass_dim / length_dim) {} linear_mass_density_dim;
+inline constexpr struct momentum_dim : decltype(mass_dim * speed_dim) {} momentum_dim;  // TODO velocity_dim?
+inline constexpr struct force_dim : decltype(mass_dim * acceleration_dim) {} force_dim;  // TODO what is a correct equation here?
+// inline constexpr struct weight_dim : decltype(mass_dim * acceleration_dim) {} weight_dim;  // TODO should we add it as a quantity or should it be a quantity_kind?
+// TODO Should we add other forces as well: static_friction_force, kinematic_friction_force, rolling_resistance, drag_force
+inline constexpr struct impulse_dim : decltype(force_dim / time_dim) {} impulse_dim;
+inline constexpr struct angular_momentum_dim : decltype(length_dim * momentum_dim) {} angular_momentum_dim; // TODO position_vector
+inline constexpr struct moment_of_inertia_dim : decltype(angular_momentum_dim * angular_velocity_dim) {} moment_of_inertia_dim;
+inline constexpr struct moment_of_force_dim : decltype(length_dim * force_dim) {} moment_of_force_dim; // TODO position_vector
+inline constexpr struct torque_dim : decltype(moment_of_force_dim) {} torque_dim; // TODO angle?
+inline constexpr struct angular_impulse_dim : decltype(moment_of_force_dim * time_dim) {} angular_impulse_dim;
+inline constexpr struct pressure_dim : decltype(force_dim / area_dim) {} pressure_dim;
+inline constexpr struct stress_dim : decltype(pressure_dim) {} stress_dim; // TODO tensor?
+inline constexpr struct normal_stress_dim : decltype(force_dim / area_dim) {} normal_stress_dim;
+inline constexpr struct strain_dim : decltype(stress_dim / stress_dim) {} strain_dim; // TODO what is a correct equation here?
+inline constexpr struct poisson_number_dim : decltype(length_dim / length_dim) {} poisson_number_dim; // TODO width?
+// TODO modulus quantities
+inline constexpr struct compressibility_dim : decltype(volume_dim / pressure_dim) {} compressibility_dim;
+inline constexpr struct second_axial_moment_of_area_dim : decltype(area_dim * area_dim) {} second_axial_moment_of_area_dim;  // TODO what is a correct equation here?
+inline constexpr struct section_modulus_dim : decltype(second_axial_moment_of_area_dim / length_dim) {} section_modulus_dim;  // TODO radial distance
+// TODO friction coefficients?
+inline constexpr struct dynamic_viscosity_dim : decltype(stress_dim * length_dim / speed_dim) {} dynamic_viscosity_dim;  // TODO shear stress, velocity
+inline constexpr struct kinematic_viscosity_dim : decltype(dynamic_viscosity_dim / mass_density_dim) {} kinematic_viscosity_dim;
+inline constexpr struct surface_tension_dim : decltype(force_dim / length_dim) {} surface_tension_dim;  // TODO what is a correct equation here?
+inline constexpr struct power_dim : decltype(force_dim * speed_dim) {} power_dim;
+// TODO what about energy (potential and kinetic as separate quantities will prevent an equation for mechanical one, is it expected?)
+inline constexpr struct efficiency_dim : decltype(power_dim / power_dim) {} efficiency_dim;
+inline constexpr struct mass_flow_dim : decltype(mass_density_dim * speed_dim) {} mass_flow_dim; // TODO velocity
+inline constexpr struct mass_flow_rate_dim : decltype(mass_flow_dim * area_dim) {} mass_flow_rate_dim;
+inline constexpr struct mass_change_rate_dim : decltype(mass_dim / time_dim) {} mass_change_rate_dim;
+inline constexpr struct volume_flow_rate_dim : decltype(speed_dim * area_dim) {} volume_flow_rate_dim;  // TODO velocity
+// inline constexpr struct action_dim : decltype(energy_dim * time_dim) {} action_dim;  // TODO make it compile
+
+// clang-format on
+
+}  // namespace units::isq
diff --git a/src/systems/isq/include/units/isq/space_and_time.h b/src/systems/isq/include/units/isq/space_and_time.h
new file mode 100644
index 00000000..4357b630
--- /dev/null
+++ b/src/systems/isq/include/units/isq/space_and_time.h
@@ -0,0 +1,68 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2018 Mateusz Pusz
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#pragma once
+
+#include <units/dimension.h>
+#include <units/isq/base_dimensions.h>
+
+namespace units::isq {
+
+// clang-format off
+// inline constexpr struct length_dim : base_dimension<"L"> {} length_dim;
+inline constexpr struct curvature_dim : decltype(1 / length_dim) {} curvature_dim;
+inline constexpr struct area_dim : decltype(length_dim * length_dim) {} area_dim;
+inline constexpr struct volume_dim : decltype(length_dim * length_dim * length_dim) {} volume_dim;
+inline constexpr struct angular_measure_dim : decltype(length_dim / length_dim) {} angular_measure_dim;
+inline constexpr struct angular_displacement_dim : decltype(length_dim / length_dim) {} angular_displacement_dim;
+inline constexpr struct phase_angle_dim : decltype(length_dim / length_dim) {} phase_angle_dim;
+inline constexpr struct solid_angular_measure_dim : decltype(area_dim / (length_dim * length_dim)) {} solid_angular_measure_dim;
+// inline constexpr struct time_dim : base_dimension<"T"> {} time_dim;  // TODO called duration in ISO 80000
+// TODO there is also a velocity in ISO 80000
+inline constexpr struct speed_dim : decltype(length_dim / time_dim) {} speed_dim;
+inline constexpr struct acceleration_dim : decltype(speed_dim / time_dim) {} acceleration_dim;
+inline constexpr struct angular_velocity_dim : decltype(angular_displacement_dim / time_dim) {} angular_velocity_dim;
+inline constexpr struct angular_acceleration_dim : decltype(angular_velocity_dim / time_dim) {} angular_acceleration_dim;
+inline constexpr struct period_duration_dim : time_dim {} period_duration_dim;
+inline constexpr struct time_constant_dim : time_dim {} time_constant_dim;
+inline constexpr struct rotation_dim : angular_displacement_dim {} rotation_dim;
+inline constexpr struct frequency_dim : decltype(1 / time_dim) {} frequency_dim;
+inline constexpr struct rotational_frequency_dim : decltype(rotation_dim / time_dim) {} rotational_frequency_dim;
+inline constexpr struct angular_frequency_dim : decltype(angular_measure_dim / time_dim) {} angular_frequency_dim;
+inline constexpr struct wavelength_dim : length_dim {} wavelength_dim;
+inline constexpr struct repetency_dim : decltype(1 / wavelength_dim) {} repetency_dim;
+inline constexpr struct wave_vector_dim : decltype(1 / length_dim) {} wave_vector_dim;
+inline constexpr struct angular_repetency_dim : decltype(1 / wavelength_dim) {} angular_repetency_dim;
+inline constexpr struct phase_velocity_dim : decltype(angular_frequency_dim / angular_repetency_dim) {} phase_velocity_dim;
+inline constexpr struct damping_coefficient_dim : decltype(1 / time_constant_dim) {} damping_coefficient_dim;
+inline constexpr struct logarithmic_decrement_dim : decltype(damping_coefficient_dim * period_duration_dim) {} logarithmic_decrement_dim;
+inline constexpr struct attenuation_dim : decltype(1 / length_dim) {} attenuation_dim;
+inline constexpr struct phase_coefficient_dim : decltype(phase_angle_dim / length_dim) {} phase_coefficient_dim;
+inline constexpr struct propagation_coefficient_dim : decltype(1 / length_dim) {} propagation_coefficient_dim;
+// clang-format on
+
+}  // namespace units::isq
+
+
+// inline constexpr struct force_dim : decltype(mass_dim * acceleration_dim) {} force_dim;
+// inline constexpr struct energy_dim : decltype(force_dim * length_dim) {} energy_dim;
+// inline constexpr struct power_dim : decltype(force_dim * speed_dim) {} power_dim;
diff --git a/src/systems/isq/include/units/isq/dimensions/conductance.h b/src/systems/isq/include/units/isq/thermodynamics.h
similarity index 71%
rename from src/systems/isq/include/units/isq/dimensions/conductance.h
rename to src/systems/isq/include/units/isq/thermodynamics.h
index 6d7a71fd..afe0bd39 100644
--- a/src/systems/isq/include/units/isq/dimensions/conductance.h
+++ b/src/systems/isq/include/units/isq/thermodynamics.h
@@ -22,18 +22,21 @@
 
 #pragma once
 
-#include <units/concepts.h>
-#include <units/isq/dimensions/resistance.h>
+#include <units/dimension.h>
+#include <units/isq/base_dimensions.h>
+#include <units/isq/space_and_time.h>
 
 namespace units::isq {
 
-template<typename Child, Unit U, typename...>
-struct dim_conductance;
+// clang-format off
+// inline constexpr struct thermodynamic_temperature_dim : base_dimension<"Θ"> {} thermodynamic_temperature_dim;
+// TODO Celsius temperature???
 
-template<typename Child, Unit U, DimensionOfT<dim_resistance> R>
-struct dim_conductance<Child, U, R> : derived_dimension<Child, U, exponent<R, -1>> {};
+// inline constexpr struct mass_density_dim : decltype(mass_dim / volume_dim) {} mass_density_dim;
 
-template<typename T>
-concept Conductance = QuantityOfT<T, dim_conductance>;
+
+inline constexpr struct energy_dim : decltype(force_dim * length_dim) {} energy_dim;
+
+// clang-format on
 
 }  // namespace units::isq
diff --git a/src/systems/si-cgs/CMakeLists.txt b/src/systems/si-cgs/CMakeLists.txt
index 08316c20..802ab5df 100644
--- a/src/systems/si-cgs/CMakeLists.txt
+++ b/src/systems/si-cgs/CMakeLists.txt
@@ -22,18 +22,4 @@
 
 cmake_minimum_required(VERSION 3.19)
 
-add_units_module(
-    si-cgs
-    DEPENDENCIES mp-units::si
-    HEADERS include/units/isq/si/cgs/acceleration.h
-            include/units/isq/si/cgs/area.h
-            include/units/isq/si/cgs/cgs.h
-            include/units/isq/si/cgs/energy.h
-            include/units/isq/si/cgs/force.h
-            include/units/isq/si/cgs/length.h
-            include/units/isq/si/cgs/mass.h
-            include/units/isq/si/cgs/power.h
-            include/units/isq/si/cgs/pressure.h
-            include/units/isq/si/cgs/speed.h
-            include/units/isq/si/cgs/time.h
-)
+add_units_module(si-cgs DEPENDENCIES mp-units::si HEADERS include/units/si/cgs/cgs.h)
diff --git a/src/systems/si-cgs/include/units/isq/si/cgs/acceleration.h b/src/systems/si-cgs/include/units/isq/si/cgs/acceleration.h
deleted file mode 100644
index fc983980..00000000
--- a/src/systems/si-cgs/include/units/isq/si/cgs/acceleration.h
+++ /dev/null
@@ -1,86 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/acceleration.h>
-#include <units/quantity.h>
-#include <units/reference.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/cgs/speed.h>
-#include <units/unit.h>
-
-namespace units::isq::si::cgs {
-
-struct gal : named_unit<gal, "Gal"> {};
-struct dim_acceleration : isq::dim_acceleration<dim_acceleration, gal, dim_length, dim_time> {};
-
-template<UnitOf<dim_acceleration> U, Representation Rep = double>
-using acceleration = quantity<dim_acceleration, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// Gal
-constexpr auto operator"" _q_Gal(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return acceleration<gal, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Gal(long double l) { return acceleration<gal, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-#ifndef UNITS_NO_REFERENCES
-
-namespace acceleration_references {
-
-inline constexpr auto Gal = reference<dim_acceleration, gal>{};
-
-}  // namespace acceleration_references
-
-namespace references {
-
-using namespace acceleration_references;
-
-}  // namespace references
-
-#endif  // UNITS_NO_REFERENCES
-
-}  // namespace units::isq::si::cgs
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::cgs::inline acceleration {
-
-template<Representation Rep = double>
-using Gal = units::isq::si::cgs::acceleration<units::isq::si::cgs::gal, Rep>;
-
-}  // namespace units::aliases::isq::si::cgs::inline acceleration
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si-cgs/include/units/isq/si/cgs/area.h b/src/systems/si-cgs/include/units/isq/si/cgs/area.h
deleted file mode 100644
index ca3e14da..00000000
--- a/src/systems/si-cgs/include/units/isq/si/cgs/area.h
+++ /dev/null
@@ -1,88 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/area.h>
-#include <units/isq/si/area.h>
-#include <units/quantity.h>
-#include <units/reference.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/cgs/length.h>
-#include <units/unit.h>
-
-namespace units::isq::si::cgs {
-
-using si::square_centimetre;
-
-struct dim_area : isq::dim_area<dim_area, square_centimetre, dim_length> {};
-
-template<UnitOf<dim_area> U, Representation Rep = double>
-using area = quantity<dim_area, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// 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(long double l) { return area<square_centimetre, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-#ifndef UNITS_NO_REFERENCES
-
-namespace area_references {
-
-inline constexpr auto cm2 = reference<dim_area, square_centimetre>{};
-
-}  // namespace area_references
-
-namespace references {
-
-using namespace area_references;
-
-}  // namespace references
-
-#endif  // UNITS_NO_REFERENCES
-
-}  // namespace units::isq::si::cgs
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::cgs::inline area {
-
-template<Representation Rep = double>
-using cm2 = units::isq::si::cgs::area<units::isq::si::cgs::square_centimetre, Rep>;
-
-}  // namespace units::aliases::isq::si::cgs::inline area
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si-cgs/include/units/isq/si/cgs/cgs.h b/src/systems/si-cgs/include/units/isq/si/cgs/cgs.h
deleted file mode 100644
index 26453d23..00000000
--- a/src/systems/si-cgs/include/units/isq/si/cgs/cgs.h
+++ /dev/null
@@ -1,36 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/si/cgs/acceleration.h>
-#include <units/isq/si/cgs/area.h>
-#include <units/isq/si/cgs/energy.h>
-#include <units/isq/si/cgs/force.h>
-#include <units/isq/si/cgs/length.h>
-#include <units/isq/si/cgs/mass.h>
-#include <units/isq/si/cgs/power.h>
-#include <units/isq/si/cgs/pressure.h>
-#include <units/isq/si/cgs/speed.h>
-#include <units/isq/si/cgs/time.h>
-// IWYU pragma: end_exports
diff --git a/src/systems/si-cgs/include/units/isq/si/cgs/energy.h b/src/systems/si-cgs/include/units/isq/si/cgs/energy.h
deleted file mode 100644
index 7ca8af7f..00000000
--- a/src/systems/si-cgs/include/units/isq/si/cgs/energy.h
+++ /dev/null
@@ -1,88 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/energy.h>
-#include <units/quantity.h>
-#include <units/reference.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/cgs/force.h>
-#include <units/isq/si/prefixes.h>
-#include <units/unit.h>
-
-namespace units::isq::si::cgs {
-
-struct erg : named_unit<erg, "erg"> {};
-
-struct dim_energy : isq::dim_energy<dim_energy, erg, dim_force, dim_length> {};
-
-template<UnitOf<dim_energy> U, Representation Rep = double>
-using energy = quantity<dim_energy, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// erg
-constexpr auto operator"" _q_erg(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return energy<erg, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_erg(long double l) { return energy<erg, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-#ifndef UNITS_NO_REFERENCES
-
-namespace energy_references {
-
-inline constexpr auto erg = reference<dim_energy, cgs::erg>{};
-
-}  // namespace energy_references
-
-namespace references {
-
-using namespace energy_references;
-
-}  // namespace references
-
-#endif  // UNITS_NO_REFERENCES
-
-}  // namespace units::isq::si::cgs
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::cgs::inline energy {
-
-template<Representation Rep = double>
-using erg = units::isq::si::cgs::energy<units::isq::si::cgs::erg, Rep>;
-
-}  // namespace units::aliases::isq::si::cgs::inline energy
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si-cgs/include/units/isq/si/cgs/force.h b/src/systems/si-cgs/include/units/isq/si/cgs/force.h
deleted file mode 100644
index f6f7bca3..00000000
--- a/src/systems/si-cgs/include/units/isq/si/cgs/force.h
+++ /dev/null
@@ -1,89 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/force.h>
-#include <units/quantity.h>
-#include <units/reference.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/cgs/acceleration.h>
-#include <units/isq/si/cgs/mass.h>
-#include <units/isq/si/prefixes.h>
-#include <units/unit.h>
-
-namespace units::isq::si::cgs {
-
-struct dyne : named_unit<dyne, "dyn"> {};
-
-struct dim_force : isq::dim_force<dim_force, dyne, dim_mass, dim_acceleration> {};
-
-template<UnitOf<dim_force> U, Representation Rep = double>
-using force = quantity<dim_force, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// dyn
-constexpr auto operator"" _q_dyn(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return force<dyne, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_dyn(long double l) { return force<dyne, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-#ifndef UNITS_NO_REFERENCES
-
-namespace force_references {
-
-inline constexpr auto dyn = reference<dim_force, dyne>{};
-
-}  // namespace force_references
-
-namespace references {
-
-using namespace force_references;
-
-}  // namespace references
-
-#endif  // UNITS_NO_REFERENCES
-
-}  // namespace units::isq::si::cgs
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::cgs::inline force {
-
-template<Representation Rep = double>
-using dyn = units::isq::si::cgs::force<units::isq::si::cgs::dyne, Rep>;
-
-}  // namespace units::aliases::isq::si::cgs::inline force
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si-cgs/include/units/isq/si/cgs/length.h b/src/systems/si-cgs/include/units/isq/si/cgs/length.h
deleted file mode 100644
index 52e8dc96..00000000
--- a/src/systems/si-cgs/include/units/isq/si/cgs/length.h
+++ /dev/null
@@ -1,87 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/length.h>
-#include <units/isq/si/length.h>
-#include <units/quantity.h>
-#include <units/reference.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/unit.h>
-
-namespace units::isq::si::cgs {
-
-using si::centimetre;
-
-struct dim_length : isq::dim_length<centimetre> {};
-
-template<UnitOf<dim_length> U, Representation Rep = double>
-using length = quantity<dim_length, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// cm
-constexpr auto operator"" _q_cm(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return length<centimetre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_cm(long double l) { return length<centimetre, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-#ifndef UNITS_NO_REFERENCES
-
-namespace length_references {
-
-inline constexpr auto cm = reference<dim_length, centimetre>{};
-
-}  // namespace length_references
-
-namespace references {
-
-using namespace length_references;
-
-}  // namespace references
-
-#endif  // UNITS_NO_REFERENCES
-
-}  // namespace units::isq::si::cgs
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::cgs::inline length {
-
-template<Representation Rep = double>
-using cm = units::isq::si::cgs::length<units::isq::si::cgs::centimetre, Rep>;
-
-}  // namespace units::aliases::isq::si::cgs::inline length
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si-cgs/include/units/isq/si/cgs/mass.h b/src/systems/si-cgs/include/units/isq/si/cgs/mass.h
deleted file mode 100644
index 725447a0..00000000
--- a/src/systems/si-cgs/include/units/isq/si/cgs/mass.h
+++ /dev/null
@@ -1,87 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/mass.h>
-#include <units/quantity.h>
-#include <units/reference.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/mass.h>
-#include <units/unit.h>
-
-namespace units::isq::si::cgs {
-
-using si::gram;
-
-struct dim_mass : isq::dim_mass<gram> {};
-
-template<UnitOf<dim_mass> U, Representation Rep = double>
-using mass = quantity<dim_mass, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// g
-constexpr auto operator"" _q_g(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<gram, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_g(long double l) { return mass<gram, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-#ifndef UNITS_NO_REFERENCES
-
-namespace mass_references {
-
-inline constexpr auto g = reference<dim_mass, gram>{};
-
-}  // namespace mass_references
-
-namespace references {
-
-using namespace mass_references;
-
-}  // namespace references
-
-#endif  // UNITS_NO_REFERENCES
-
-}  // namespace units::isq::si::cgs
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::cgs::inline mass {
-
-template<Representation Rep = double>
-using g = units::isq::si::cgs::mass<units::isq::si::cgs::gram, Rep>;
-
-}  // namespace units::aliases::isq::si::cgs::inline mass
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si-cgs/include/units/isq/si/cgs/power.h b/src/systems/si-cgs/include/units/isq/si/cgs/power.h
deleted file mode 100644
index 5d2b0483..00000000
--- a/src/systems/si-cgs/include/units/isq/si/cgs/power.h
+++ /dev/null
@@ -1,71 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/power.h>
-#include <units/quantity.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/cgs/energy.h>
-#include <units/isq/si/prefixes.h>
-#include <units/unit.h>
-
-namespace units::isq::si::cgs {
-
-struct erg_per_second : derived_unit<erg_per_second> {};
-
-struct dim_power : isq::dim_power<dim_power, erg_per_second, dim_energy, dim_time> {};
-
-template<UnitOf<dim_power> U, Representation Rep = double>
-using power = quantity<dim_power, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// erg/s
-constexpr auto operator"" _q_erg_per_s(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return power<erg_per_second, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_erg_per_s(long double l) { return power<erg_per_second, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-}  // namespace units::isq::si::cgs
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::cgs::inline power {
-
-template<Representation Rep = double>
-using erg_per_s = units::isq::si::cgs::power<units::isq::si::cgs::erg_per_second, Rep>;
-
-}  // namespace units::aliases::isq::si::cgs::inline power
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si-cgs/include/units/isq/si/cgs/pressure.h b/src/systems/si-cgs/include/units/isq/si/cgs/pressure.h
deleted file mode 100644
index e3b1a36a..00000000
--- a/src/systems/si-cgs/include/units/isq/si/cgs/pressure.h
+++ /dev/null
@@ -1,89 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/pressure.h>
-#include <units/quantity.h>
-#include <units/reference.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/cgs/area.h>
-#include <units/isq/si/cgs/force.h>
-#include <units/isq/si/prefixes.h>
-#include <units/unit.h>
-
-namespace units::isq::si::cgs {
-
-struct barye : named_unit<barye, "Ba"> {};
-
-struct dim_pressure : isq::dim_pressure<dim_pressure, barye, dim_force, dim_area> {};
-
-template<UnitOf<dim_pressure> U, Representation Rep = double>
-using pressure = quantity<dim_pressure, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// Ba
-constexpr auto operator"" _q_Ba(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return pressure<barye, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Ba(long double l) { return pressure<barye, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-#ifndef UNITS_NO_REFERENCES
-
-namespace pressure_references {
-
-inline constexpr auto Ba = reference<dim_pressure, barye>{};
-
-}  // namespace pressure_references
-
-namespace references {
-
-using namespace pressure_references;
-
-}  // namespace references
-
-#endif  // UNITS_NO_REFERENCES
-
-}  // namespace units::isq::si::cgs
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::cgs::inline pressure {
-
-template<Representation Rep = double>
-using Ba = units::isq::si::cgs::pressure<units::isq::si::cgs::barye, Rep>;
-
-}  // namespace units::aliases::isq::si::cgs::inline pressure
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si-cgs/include/units/isq/si/cgs/speed.h b/src/systems/si-cgs/include/units/isq/si/cgs/speed.h
deleted file mode 100644
index c70ee197..00000000
--- a/src/systems/si-cgs/include/units/isq/si/cgs/speed.h
+++ /dev/null
@@ -1,70 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/speed.h>
-#include <units/quantity.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/cgs/length.h>
-#include <units/isq/si/cgs/time.h>
-#include <units/unit.h>
-
-namespace units::isq::si::cgs {
-
-struct centimetre_per_second : derived_unit<centimetre_per_second> {};
-struct dim_speed : isq::dim_speed<dim_speed, centimetre_per_second, dim_length, dim_time> {};
-
-template<UnitOf<dim_speed> U, Representation Rep = double>
-using speed = quantity<dim_speed, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// cm/s
-constexpr auto operator"" _q_cm_per_s(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return speed<centimetre_per_second, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_cm_per_s(long double l) { return speed<centimetre_per_second, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-}  // namespace units::isq::si::cgs
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::cgs::inline speed {
-
-template<Representation Rep = double>
-using cm_per_s = units::isq::si::cgs::speed<units::isq::si::cgs::centimetre_per_second, Rep>;
-
-}  // namespace units::aliases::isq::si::cgs::inline speed
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si-cgs/include/units/si/cgs/cgs.h b/src/systems/si-cgs/include/units/si/cgs/cgs.h
new file mode 100644
index 00000000..4c68f3b6
--- /dev/null
+++ b/src/systems/si-cgs/include/units/si/cgs/cgs.h
@@ -0,0 +1,57 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2018 Mateusz Pusz
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#pragma once
+
+#include <units/isq/mechanics.h>
+#include <units/isq/space_and_time.h>
+#include <units/isq/thermodynamics.h>
+#include <units/reference.h>
+#include <units/si/units.h>
+
+namespace units::si::cgs {
+
+// clang-format off
+inline constexpr struct centimetre : si::centi_<si::metre> {} centimetre;
+inline constexpr struct gram : si::gram {} gram;
+inline constexpr struct second : si::second {} second;
+inline constexpr struct gal : named_unit<"Gal", centimetre / square<second>> {} gal;
+inline constexpr struct dyne : named_unit<"dyn", gram * centimetre / square<second>> {} dyne;
+inline constexpr struct erg : named_unit<"erg", dyne / centimetre> {} erg;
+inline constexpr struct barye : named_unit<"Ba", gram / (centimetre * square<second>)> {} barye;
+inline constexpr struct poise : named_unit<"P", gram / (centimetre * second)> {} poise;
+inline constexpr struct stokes : named_unit<"St", square<centimetre> / second> {} stokes;
+inline constexpr struct kayser : decltype(1 / centimetre) {} kayser;
+
+inline constexpr struct length : system_reference<isq::length_dim, centimetre> {} length;
+inline constexpr struct mass : system_reference<isq::mass_dim, gram> {} mass;
+inline constexpr struct time : system_reference<isq::time_dim, second> {} time;
+inline constexpr struct speed : system_reference<isq::speed_dim, centimetre / second> {} speed;
+inline constexpr struct acceleration : system_reference<isq::acceleration_dim, gal> {} acceleration;
+inline constexpr struct force : system_reference<isq::force_dim, dyne> {} force;inline constexpr struct energy : system_reference<isq::energy_dim, erg> {} energy;
+inline constexpr struct power : system_reference<isq::power_dim, erg / second> {} power;
+inline constexpr struct dynamic_viscosity : system_reference<isq::dynamic_viscosity_dim, poise> {} dynamic_viscosity;
+inline constexpr struct kinematic_viscosity : system_reference<isq::kinematic_viscosity_dim, stokes> {} kinematic_viscosity;
+// inline constexpr struct wavenumber : system_reference<isq::wavenumber_dim, dyne> {} wavenumber;
+// clang-format on
+
+}  // namespace units::si::cgs
diff --git a/src/systems/si/CMakeLists.txt b/src/systems/si/CMakeLists.txt
index f4a59f96..eb54a1c4 100644
--- a/src/systems/si/CMakeLists.txt
+++ b/src/systems/si/CMakeLists.txt
@@ -25,53 +25,13 @@ cmake_minimum_required(VERSION 3.19)
 add_units_module(
     si
     DEPENDENCIES mp-units::isq
-    HEADERS include/units/isq/si/absorbed_dose.h
-            include/units/isq/si/acceleration.h
-            include/units/isq/si/amount_of_substance.h
-            include/units/isq/si/angular_acceleration.h
-            include/units/isq/si/angular_velocity.h
-            include/units/isq/si/area.h
-            include/units/isq/si/capacitance.h
-            include/units/isq/si/catalytic_activity.h
-            include/units/isq/si/charge_density.h
-            include/units/isq/si/concentration.h
-            include/units/isq/si/conductance.h
-            include/units/isq/si/constants.h
-            include/units/isq/si/current_density.h
-            include/units/isq/si/density.h
-            include/units/isq/si/dynamic_viscosity.h
-            include/units/isq/si/electric_charge.h
-            include/units/isq/si/electric_current.h
-            include/units/isq/si/electric_field_strength.h
-            include/units/isq/si/energy.h
-            include/units/isq/si/energy_density.h
-            include/units/isq/si/force.h
-            include/units/isq/si/frequency.h
-            include/units/isq/si/heat_capacity.h
-            include/units/isq/si/inductance.h
-            include/units/isq/si/length.h
-            include/units/isq/si/luminance.h
-            include/units/isq/si/luminous_flux.h
-            include/units/isq/si/luminous_intensity.h
-            include/units/isq/si/magnetic_flux.h
-            include/units/isq/si/magnetic_induction.h
-            include/units/isq/si/mass.h
-            include/units/isq/si/molar_energy.h
-            include/units/isq/si/momentum.h
-            include/units/isq/si/permeability.h
-            include/units/isq/si/permittivity.h
-            include/units/isq/si/power.h
-            include/units/isq/si/prefixes.h
-            include/units/isq/si/pressure.h
-            include/units/isq/si/radioactivity.h
-            include/units/isq/si/resistance.h
-            include/units/isq/si/si.h
-            include/units/isq/si/speed.h
-            include/units/isq/si/surface_tension.h
-            include/units/isq/si/thermal_conductivity.h
-            include/units/isq/si/thermodynamic_temperature.h
-            include/units/isq/si/time.h
-            include/units/isq/si/torque.h
-            include/units/isq/si/voltage.h
-            include/units/isq/si/volume.h
+    HEADERS include/units/si/base_quantities.h
+            include/units/si/constants.h
+            include/units/si/mechanics.h
+            include/units/si/prefixes.h
+            include/units/si/si.h
+            include/units/si/space_and_time.h
+            include/units/si/thermodynamics.h
+            include/units/si/unit_symbols.h
+            include/units/si/units.h
 )
diff --git a/src/systems/si/include/units/isq/si/absorbed_dose.h b/src/systems/si/include/units/isq/si/absorbed_dose.h
deleted file mode 100644
index 40159573..00000000
--- a/src/systems/si/include/units/isq/si/absorbed_dose.h
+++ /dev/null
@@ -1,328 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/absorbed_dose.h>
-#include <units/quantity.h>
-#include <units/reference.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/energy.h>
-#include <units/isq/si/prefixes.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct gray : named_unit<gray, "Gy"> {};
-struct yoctogray : prefixed_unit<yoctogray, yocto, gray> {};
-struct zeptogray : prefixed_unit<zeptogray, zepto, gray> {};
-struct attogray : prefixed_unit<attogray, atto, gray> {};
-struct femtogray : prefixed_unit<femtogray, femto, gray> {};
-struct picogray : prefixed_unit<picogray, pico, gray> {};
-struct nanogray : prefixed_unit<nanogray, nano, gray> {};
-struct microgray : prefixed_unit<microgray, micro, gray> {};
-struct milligray : prefixed_unit<milligray, milli, gray> {};
-struct centigray : prefixed_unit<centigray, centi, gray> {};
-struct decigray : prefixed_unit<decigray, deci, gray> {};
-struct decagray : prefixed_unit<decagray, deca, gray> {};
-struct hectogray : prefixed_unit<hectogray, hecto, gray> {};
-struct kilogray : prefixed_unit<kilogray, kilo, gray> {};
-struct megagray : prefixed_unit<megagray, mega, gray> {};
-struct gigagray : prefixed_unit<gigagray, giga, gray> {};
-struct teragray : prefixed_unit<teragray, tera, gray> {};
-struct petagray : prefixed_unit<petagray, peta, gray> {};
-struct exagray : prefixed_unit<exagray, exa, gray> {};
-struct zettagray : prefixed_unit<zettagray, zetta, gray> {};
-struct yottagray : prefixed_unit<yottagray, yotta, gray> {};
-
-struct dim_absorbed_dose : isq::dim_absorbed_dose<dim_absorbed_dose, gray, dim_energy, dim_mass> {};
-
-template<UnitOf<dim_absorbed_dose> U, Representation Rep = double>
-using absorbed_dose = quantity<dim_absorbed_dose, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(long double l) { return absorbed_dose<yottagray, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-#ifndef UNITS_NO_REFERENCES
-
-namespace absorbed_dose_references {
-
-inline constexpr auto Gy = reference<dim_absorbed_dose, gray>{};
-inline constexpr auto yGy = reference<dim_absorbed_dose, yoctogray>{};
-inline constexpr auto zGy = reference<dim_absorbed_dose, zeptogray>{};
-inline constexpr auto aGy = reference<dim_absorbed_dose, attogray>{};
-inline constexpr auto fGy = reference<dim_absorbed_dose, femtogray>{};
-inline constexpr auto pGy = reference<dim_absorbed_dose, picogray>{};
-inline constexpr auto nGy = reference<dim_absorbed_dose, nanogray>{};
-inline constexpr auto uGy = reference<dim_absorbed_dose, microgray>{};
-inline constexpr auto mGy = reference<dim_absorbed_dose, milligray>{};
-inline constexpr auto cGy = reference<dim_absorbed_dose, centigray>{};
-inline constexpr auto dGy = reference<dim_absorbed_dose, decigray>{};
-inline constexpr auto daGy = reference<dim_absorbed_dose, decagray>{};
-inline constexpr auto hGy = reference<dim_absorbed_dose, hectogray>{};
-inline constexpr auto kGy = reference<dim_absorbed_dose, kilogray>{};
-inline constexpr auto MGy = reference<dim_absorbed_dose, megagray>{};
-inline constexpr auto GGy = reference<dim_absorbed_dose, gigagray>{};
-inline constexpr auto TGy = reference<dim_absorbed_dose, teragray>{};
-inline constexpr auto PGy = reference<dim_absorbed_dose, petagray>{};
-inline constexpr auto EGy = reference<dim_absorbed_dose, exagray>{};
-inline constexpr auto ZGy = reference<dim_absorbed_dose, zettagray>{};
-inline constexpr auto YGy = reference<dim_absorbed_dose, yottagray>{};
-
-}  // namespace absorbed_dose_references
-
-namespace references {
-
-using namespace absorbed_dose_references;
-
-}  // namespace references
-
-#endif  // UNITS_NO_REFERENCES
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-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>;
-
-}  // namespace units::aliases::isq::si::inline absorbed_dose
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/acceleration.h b/src/systems/si/include/units/isq/si/acceleration.h
deleted file mode 100644
index 90f0168a..00000000
--- a/src/systems/si/include/units/isq/si/acceleration.h
+++ /dev/null
@@ -1,69 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/acceleration.h>
-#include <units/quantity.h>
-#include <units/symbol_text.h>
-#include <units/unit.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/speed.h>
-
-namespace units::isq::si {
-
-struct metre_per_second_sq : derived_unit<metre_per_second_sq> {};
-struct dim_acceleration : isq::dim_acceleration<dim_acceleration, metre_per_second_sq, dim_length, dim_time> {};
-
-template<UnitOf<dim_acceleration> U, Representation Rep = double>
-using acceleration = quantity<dim_acceleration, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-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(long double l) { return acceleration<metre_per_second_sq, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-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>;
-
-}  // namespace units::aliases::isq::si::inline acceleration
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/amount_of_substance.h b/src/systems/si/include/units/isq/si/amount_of_substance.h
deleted file mode 100644
index ba7578d8..00000000
--- a/src/systems/si/include/units/isq/si/amount_of_substance.h
+++ /dev/null
@@ -1,87 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/amount_of_substance.h>
-#include <units/quantity.h>
-#include <units/reference.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/prefixes.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct mole : named_unit<mole, "mol"> {};
-
-struct dim_amount_of_substance : isq::dim_amount_of_substance<mole> {};
-
-template<UnitOf<dim_amount_of_substance> U, Representation Rep = double>
-using amount_of_substance = quantity<dim_amount_of_substance, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-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(long double l) { return amount_of_substance<mole, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-#ifndef UNITS_NO_REFERENCES
-
-namespace amount_of_substance_references {
-
-inline constexpr auto mol = reference<dim_amount_of_substance, mole>{};
-
-}  // namespace amount_of_substance_references
-
-namespace references {
-
-using namespace amount_of_substance_references;
-
-}  // namespace references
-
-#endif  // UNITS_NO_REFERENCES
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-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>;
-
-}  // namespace units::aliases::isq::si::inline amount_of_substance
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/angular_acceleration.h b/src/systems/si/include/units/isq/si/angular_acceleration.h
deleted file mode 100644
index 4899448b..00000000
--- a/src/systems/si/include/units/isq/si/angular_acceleration.h
+++ /dev/null
@@ -1,76 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/angular_acceleration.h>
-#include <units/quantity.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/generic/angle.h>
-#include <units/isq/si/prefixes.h>
-#include <units/isq/si/time.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct radian_per_second_sq : derived_unit<radian_per_second_sq> {};
-
-struct dim_angular_acceleration :
-    isq::dim_angular_acceleration<dim_angular_acceleration, radian_per_second_sq, dim_angle<>, dim_time> {};
-
-template<UnitOf<dim_angular_acceleration> U, Representation Rep = double>
-using angular_acceleration = quantity<dim_angular_acceleration, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// rad/s2
-constexpr auto operator"" _q_rad_per_s2(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return angular_acceleration<radian_per_second_sq, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_rad_per_s2(long double l)
-{
-  return angular_acceleration<radian_per_second_sq, long double>(l);
-}
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::inline angular_acceleration {
-
-template<Representation Rep = double>
-using rad_per_s2 = units::isq::si::angular_acceleration<units::isq::si::radian_per_second_sq, Rep>;
-
-}  // namespace units::aliases::isq::si::inline angular_acceleration
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/angular_velocity.h b/src/systems/si/include/units/isq/si/angular_velocity.h
deleted file mode 100644
index 81bdc296..00000000
--- a/src/systems/si/include/units/isq/si/angular_velocity.h
+++ /dev/null
@@ -1,73 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/angular_velocity.h>
-#include <units/quantity.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/generic/angle.h>
-#include <units/isq/si/prefixes.h>
-#include <units/isq/si/time.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct radian_per_second : derived_unit<radian_per_second> {};
-
-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>;
-
-#ifndef UNITS_NO_LITERALS
-
-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(long double l) { return angular_velocity<radian_per_second, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-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>;
-
-}  // namespace units::aliases::isq::si::inline angular_velocity
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/area.h b/src/systems/si/include/units/isq/si/area.h
deleted file mode 100644
index d430a38c..00000000
--- a/src/systems/si/include/units/isq/si/area.h
+++ /dev/null
@@ -1,382 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/area.h>
-#include <units/quantity.h>
-#include <units/reference.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/length.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct square_metre : derived_unit<square_metre> {};
-struct dim_area : isq::dim_area<dim_area, square_metre, dim_length> {};
-
-struct square_yoctometre : derived_scaled_unit<square_yoctometre, dim_area, yoctometre> {};
-struct square_zeptometre : derived_scaled_unit<square_zeptometre, dim_area, zeptometre> {};
-struct square_attometre : derived_scaled_unit<square_attometre, dim_area, attometre> {};
-struct square_femtometre : derived_scaled_unit<square_femtometre, dim_area, femtometre> {};
-struct square_picometre : derived_scaled_unit<square_picometre, dim_area, picometre> {};
-struct square_nanometre : derived_scaled_unit<square_nanometre, dim_area, nanometre> {};
-struct square_micrometre : derived_scaled_unit<square_micrometre, dim_area, micrometre> {};
-struct square_millimetre : derived_scaled_unit<square_millimetre, dim_area, millimetre> {};
-struct square_centimetre : derived_scaled_unit<square_centimetre, dim_area, centimetre> {};
-struct square_decimetre : derived_scaled_unit<square_decimetre, dim_area, decimetre> {};
-struct square_decametre : derived_scaled_unit<square_decametre, dim_area, decametre> {};
-struct square_hectometre : derived_scaled_unit<square_hectometre, dim_area, hectometre> {};
-struct square_kilometre : derived_scaled_unit<square_kilometre, dim_area, kilometre> {};
-struct square_megametre : derived_scaled_unit<square_megametre, dim_area, megametre> {};
-struct square_gigametre : derived_scaled_unit<square_gigametre, dim_area, gigametre> {};
-struct square_terametre : derived_scaled_unit<square_terametre, dim_area, terametre> {};
-struct square_petametre : derived_scaled_unit<square_petametre, dim_area, petametre> {};
-struct square_exametre : derived_scaled_unit<square_exametre, dim_area, exametre> {};
-struct square_zettametre : derived_scaled_unit<square_zettametre, dim_area, zettametre> {};
-struct square_yottametre : derived_scaled_unit<square_yottametre, dim_area, yottametre> {};
-
-struct are : alias_unit<square_decametre, "a"> {};
-struct centiare : prefixed_alias_unit<square_metre, centi, are> {};
-struct deciare : prefixed_unit<deciare, deci, are> {};
-struct decare : prefixed_unit<decare, deca, are> {};
-struct hectare : prefixed_alias_unit<square_hectometre, hecto, are> {};
-
-template<UnitOf<dim_area> U, Representation Rep = double>
-using area = quantity<dim_area, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(long double l) { return area<square_yottametre, long double>(l); }
-
-// a
-constexpr auto operator"" _q_a(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return area<are, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_a(long double l) { return area<are, long double>(l); }
-
-// ca
-constexpr auto operator"" _q_ca(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return area<centiare, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_ca(long double l) { return area<centiare, long double>(l); }
-
-// da
-constexpr auto operator"" _q_da(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return area<deciare, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_da(long double l) { return area<deciare, long double>(l); }
-
-// daa
-constexpr auto operator"" _q_daa(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return area<decare, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_daa(long double l) { return area<decare, 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(long double l) { return area<hectare, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-#ifndef UNITS_NO_REFERENCES
-
-namespace area_references {
-
-inline constexpr auto m2 = reference<dim_area, square_metre>{};
-inline constexpr auto ym2 = reference<dim_area, square_yoctometre>{};
-inline constexpr auto zm2 = reference<dim_area, square_zeptometre>{};
-inline constexpr auto am2 = reference<dim_area, square_attometre>{};
-inline constexpr auto fm2 = reference<dim_area, square_femtometre>{};
-inline constexpr auto pm2 = reference<dim_area, square_picometre>{};
-inline constexpr auto nm2 = reference<dim_area, square_nanometre>{};
-inline constexpr auto um2 = reference<dim_area, square_micrometre>{};
-inline constexpr auto mm2 = reference<dim_area, square_millimetre>{};
-inline constexpr auto cm2 = reference<dim_area, square_centimetre>{};
-inline constexpr auto dm2 = reference<dim_area, square_decimetre>{};
-inline constexpr auto dam2 = reference<dim_area, square_decametre>{};
-inline constexpr auto hm2 = reference<dim_area, square_hectometre>{};
-inline constexpr auto km2 = reference<dim_area, square_kilometre>{};
-inline constexpr auto Mm2 = reference<dim_area, square_megametre>{};
-inline constexpr auto Gm2 = reference<dim_area, square_gigametre>{};
-inline constexpr auto Tm2 = reference<dim_area, square_terametre>{};
-inline constexpr auto Pm2 = reference<dim_area, square_petametre>{};
-inline constexpr auto Em2 = reference<dim_area, square_exametre>{};
-inline constexpr auto Zm2 = reference<dim_area, square_zettametre>{};
-inline constexpr auto Ym2 = reference<dim_area, square_yottametre>{};
-
-inline constexpr auto a = reference<dim_area, are>{};
-inline constexpr auto ca = reference<dim_area, centiare>{};
-inline constexpr auto da = reference<dim_area, deciare>{};
-inline constexpr auto daa = reference<dim_area, decare>{};
-inline constexpr auto ha = reference<dim_area, hectare>{};
-
-}  // namespace area_references
-
-namespace references {
-
-using namespace area_references;
-
-}  // namespace references
-
-#endif  // UNITS_NO_REFERENCES
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-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 ha = units::isq::si::area<units::isq::si::hectare, Rep>;
-
-}  // namespace units::aliases::isq::si::inline area
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/capacitance.h b/src/systems/si/include/units/isq/si/capacitance.h
deleted file mode 100644
index 31a477f9..00000000
--- a/src/systems/si/include/units/isq/si/capacitance.h
+++ /dev/null
@@ -1,329 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/capacitance.h>
-#include <units/quantity.h>
-#include <units/reference.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/electric_charge.h>
-#include <units/isq/si/prefixes.h>
-#include <units/isq/si/voltage.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct farad : named_unit<farad, "F"> {};
-struct yoctofarad : prefixed_unit<yoctofarad, yocto, farad> {};
-struct zeptofarad : prefixed_unit<zeptofarad, zepto, farad> {};
-struct attofarad : prefixed_unit<attofarad, atto, farad> {};
-struct femtofarad : prefixed_unit<femtofarad, femto, farad> {};
-struct picofarad : prefixed_unit<picofarad, pico, farad> {};
-struct nanofarad : prefixed_unit<nanofarad, nano, farad> {};
-struct microfarad : prefixed_unit<microfarad, micro, farad> {};
-struct millifarad : prefixed_unit<millifarad, milli, farad> {};
-struct centifarad : prefixed_unit<centifarad, centi, farad> {};
-struct decifarad : prefixed_unit<decifarad, deci, farad> {};
-struct decafarad : prefixed_unit<decafarad, deca, farad> {};
-struct hectofarad : prefixed_unit<hectofarad, hecto, farad> {};
-struct kilofarad : prefixed_unit<kilofarad, kilo, farad> {};
-struct megafarad : prefixed_unit<megafarad, mega, farad> {};
-struct gigafarad : prefixed_unit<gigafarad, giga, farad> {};
-struct terafarad : prefixed_unit<terafarad, tera, farad> {};
-struct petafarad : prefixed_unit<petafarad, peta, farad> {};
-struct exafarad : prefixed_unit<exafarad, exa, farad> {};
-struct zettafarad : prefixed_unit<zettafarad, zetta, farad> {};
-struct yottafarad : prefixed_unit<yottafarad, yotta, farad> {};
-
-struct dim_capacitance : isq::dim_capacitance<dim_capacitance, farad, dim_electric_charge, dim_voltage> {};
-
-template<UnitOf<dim_capacitance> U, Representation Rep = double>
-using capacitance = quantity<dim_capacitance, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(long double l) { return capacitance<yottafarad, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-#ifndef UNITS_NO_REFERENCES
-
-namespace capacitance_references {
-
-inline constexpr auto F = reference<dim_capacitance, farad>{};
-inline constexpr auto yF = reference<dim_capacitance, yoctofarad>{};
-inline constexpr auto zF = reference<dim_capacitance, zeptofarad>{};
-inline constexpr auto aF = reference<dim_capacitance, attofarad>{};
-inline constexpr auto fF = reference<dim_capacitance, femtofarad>{};
-inline constexpr auto pF = reference<dim_capacitance, picofarad>{};
-inline constexpr auto nF = reference<dim_capacitance, nanofarad>{};
-inline constexpr auto uF = reference<dim_capacitance, microfarad>{};
-inline constexpr auto mF = reference<dim_capacitance, millifarad>{};
-inline constexpr auto cF = reference<dim_capacitance, centifarad>{};
-inline constexpr auto dF = reference<dim_capacitance, decifarad>{};
-inline constexpr auto daF = reference<dim_capacitance, decafarad>{};
-inline constexpr auto hF = reference<dim_capacitance, hectofarad>{};
-inline constexpr auto kF = reference<dim_capacitance, kilofarad>{};
-inline constexpr auto MF = reference<dim_capacitance, megafarad>{};
-inline constexpr auto GF = reference<dim_capacitance, gigafarad>{};
-inline constexpr auto TF = reference<dim_capacitance, terafarad>{};
-inline constexpr auto PF = reference<dim_capacitance, petafarad>{};
-inline constexpr auto EF = reference<dim_capacitance, exafarad>{};
-inline constexpr auto ZF = reference<dim_capacitance, zettafarad>{};
-inline constexpr auto YF = reference<dim_capacitance, yottafarad>{};
-
-}  // namespace capacitance_references
-
-namespace references {
-
-using namespace capacitance_references;
-
-}  // namespace references
-
-#endif  // UNITS_NO_REFERENCES
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-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>;
-
-}  // namespace units::aliases::isq::si::inline capacitance
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/catalytic_activity.h b/src/systems/si/include/units/isq/si/catalytic_activity.h
deleted file mode 100644
index 926705d6..00000000
--- a/src/systems/si/include/units/isq/si/catalytic_activity.h
+++ /dev/null
@@ -1,343 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/catalytic_activity.h>
-#include <units/quantity.h>
-#include <units/reference.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/amount_of_substance.h>
-#include <units/isq/si/prefixes.h>
-#include <units/isq/si/time.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct katal : named_unit<katal, "kat"> {};
-struct yoctokatal : prefixed_unit<yoctokatal, yocto, katal> {};
-struct zeptokatal : prefixed_unit<zeptokatal, zepto, katal> {};
-struct attokatal : prefixed_unit<attokatal, atto, katal> {};
-struct femtokatal : prefixed_unit<femtokatal, femto, katal> {};
-struct picokatal : prefixed_unit<picokatal, pico, katal> {};
-struct nanokatal : prefixed_unit<nanokatal, nano, katal> {};
-struct microkatal : prefixed_unit<microkatal, micro, katal> {};
-struct millikatal : prefixed_unit<millikatal, milli, katal> {};
-struct centikatal : prefixed_unit<centikatal, centi, katal> {};
-struct decikatal : prefixed_unit<decikatal, deci, katal> {};
-struct decakatal : prefixed_unit<decakatal, deca, katal> {};
-struct hectokatal : prefixed_unit<hectokatal, hecto, katal> {};
-struct kilokatal : prefixed_unit<kilokatal, kilo, katal> {};
-struct megakatal : prefixed_unit<megakatal, mega, katal> {};
-struct gigakatal : prefixed_unit<gigakatal, giga, katal> {};
-struct terakatal : prefixed_unit<terakatal, tera, katal> {};
-struct petakatal : prefixed_unit<petakatal, peta, katal> {};
-struct exakatal : prefixed_unit<exakatal, exa, katal> {};
-struct zettakatal : prefixed_unit<zettakatal, zetta, katal> {};
-struct yottakatal : prefixed_unit<yottakatal, yotta, katal> {};
-
-struct enzyme_unit : named_scaled_unit<enzyme_unit, "U", mag<ratio(1, 60)>() * mag_power<10, -6>(), katal> {};
-
-struct dim_catalytic_activity :
-    isq::dim_catalytic_activity<dim_catalytic_activity, katal, dim_time, dim_amount_of_substance> {};
-
-template<UnitOf<dim_catalytic_activity> U, Representation Rep = double>
-using catalytic_activity = quantity<dim_catalytic_activity, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// kat
-constexpr auto operator"" _q_kat(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return catalytic_activity<katal, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_kat(long double l) { return catalytic_activity<katal, long double>(l); }
-
-// ykat
-constexpr auto operator"" _q_ykat(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return catalytic_activity<yoctokatal, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_ykat(long double l) { return catalytic_activity<yoctokatal, long double>(l); }
-
-// zkat
-constexpr auto operator"" _q_zkat(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return catalytic_activity<zeptokatal, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_zkat(long double l) { return catalytic_activity<zeptokatal, long double>(l); }
-
-// akat
-constexpr auto operator"" _q_akat(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return catalytic_activity<attokatal, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_akat(long double l) { return catalytic_activity<attokatal, long double>(l); }
-
-// fkat
-constexpr auto operator"" _q_fkat(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return catalytic_activity<femtokatal, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_fkat(long double l) { return catalytic_activity<femtokatal, long double>(l); }
-
-// pkat
-constexpr auto operator"" _q_pkat(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return catalytic_activity<picokatal, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_pkat(long double l) { return catalytic_activity<picokatal, long double>(l); }
-
-// nkat
-constexpr auto operator"" _q_nkat(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return catalytic_activity<nanokatal, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_nkat(long double l) { return catalytic_activity<nanokatal, long double>(l); }
-
-// ukat
-constexpr auto operator"" _q_ukat(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return catalytic_activity<microkatal, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_ukat(long double l) { return catalytic_activity<microkatal, long double>(l); }
-
-// mkat
-constexpr auto operator"" _q_mkat(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return catalytic_activity<millikatal, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_mkat(long double l) { return catalytic_activity<millikatal, long double>(l); }
-
-// ckat
-constexpr auto operator"" _q_ckat(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return catalytic_activity<centikatal, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_ckat(long double l) { return catalytic_activity<centikatal, long double>(l); }
-
-// dkat
-constexpr auto operator"" _q_dkat(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return catalytic_activity<decikatal, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_dkat(long double l) { return catalytic_activity<decikatal, long double>(l); }
-
-// dakat
-constexpr auto operator"" _q_dakat(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return catalytic_activity<decakatal, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_dakat(long double l) { return catalytic_activity<decakatal, long double>(l); }
-
-// hkat
-constexpr auto operator"" _q_hkat(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return catalytic_activity<hectokatal, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_hkat(long double l) { return catalytic_activity<hectokatal, long double>(l); }
-
-// kkat
-constexpr auto operator"" _q_kkat(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return catalytic_activity<kilokatal, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_kkat(long double l) { return catalytic_activity<kilokatal, long double>(l); }
-
-// Mkat
-constexpr auto operator"" _q_Mkat(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return catalytic_activity<megakatal, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Mkat(long double l) { return catalytic_activity<megakatal, long double>(l); }
-
-// Gkat
-constexpr auto operator"" _q_Gkat(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return catalytic_activity<gigakatal, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Gkat(long double l) { return catalytic_activity<gigakatal, long double>(l); }
-
-// Tkat
-constexpr auto operator"" _q_Tkat(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return catalytic_activity<terakatal, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Tkat(long double l) { return catalytic_activity<terakatal, long double>(l); }
-
-// Pkat
-constexpr auto operator"" _q_Pkat(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return catalytic_activity<petakatal, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Pkat(long double l) { return catalytic_activity<petakatal, long double>(l); }
-
-// Ekat
-constexpr auto operator"" _q_Ekat(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return catalytic_activity<exakatal, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Ekat(long double l) { return catalytic_activity<exakatal, long double>(l); }
-
-// Zkat
-constexpr auto operator"" _q_Zkat(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return catalytic_activity<zettakatal, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Zkat(long double l) { return catalytic_activity<zettakatal, long double>(l); }
-
-// Ykat
-constexpr auto operator"" _q_Ykat(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return catalytic_activity<yottakatal, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Ykat(long double l) { return catalytic_activity<yottakatal, long double>(l); }
-
-// U
-constexpr auto operator"" _q_U(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return catalytic_activity<enzyme_unit, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_U(long double l) { return catalytic_activity<enzyme_unit, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-#ifndef UNITS_NO_REFERENCES
-
-namespace catalytic_activity_references {
-
-inline constexpr auto kat = reference<dim_catalytic_activity, katal>{};
-inline constexpr auto ykat = reference<dim_catalytic_activity, yoctokatal>{};
-inline constexpr auto zkat = reference<dim_catalytic_activity, zeptokatal>{};
-inline constexpr auto akat = reference<dim_catalytic_activity, attokatal>{};
-inline constexpr auto fkat = reference<dim_catalytic_activity, femtokatal>{};
-inline constexpr auto pkat = reference<dim_catalytic_activity, picokatal>{};
-inline constexpr auto nkat = reference<dim_catalytic_activity, nanokatal>{};
-inline constexpr auto ukat = reference<dim_catalytic_activity, microkatal>{};
-inline constexpr auto mkat = reference<dim_catalytic_activity, millikatal>{};
-inline constexpr auto ckat = reference<dim_catalytic_activity, centikatal>{};
-inline constexpr auto dkat = reference<dim_catalytic_activity, decikatal>{};
-inline constexpr auto dakat = reference<dim_catalytic_activity, decakatal>{};
-inline constexpr auto hkat = reference<dim_catalytic_activity, hectokatal>{};
-inline constexpr auto kkat = reference<dim_catalytic_activity, kilokatal>{};
-inline constexpr auto Mkat = reference<dim_catalytic_activity, megakatal>{};
-inline constexpr auto Gkat = reference<dim_catalytic_activity, gigakatal>{};
-inline constexpr auto Tkat = reference<dim_catalytic_activity, terakatal>{};
-inline constexpr auto Pkat = reference<dim_catalytic_activity, petakatal>{};
-inline constexpr auto Ekat = reference<dim_catalytic_activity, exakatal>{};
-inline constexpr auto Zkat = reference<dim_catalytic_activity, zettakatal>{};
-inline constexpr auto Ykat = reference<dim_catalytic_activity, yottakatal>{};
-inline constexpr auto U = reference<dim_catalytic_activity, enzyme_unit>{};
-
-}  // namespace catalytic_activity_references
-
-namespace references {
-
-using namespace catalytic_activity_references;
-
-}  // namespace references
-
-#endif  // UNITS_NO_REFERENCES
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::inline catalytic_activity {
-
-template<Representation Rep = double>
-using kat = units::isq::si::catalytic_activity<units::isq::si::katal, Rep>;
-template<Representation Rep = double>
-using ykat = units::isq::si::catalytic_activity<units::isq::si::yoctokatal, Rep>;
-template<Representation Rep = double>
-using zkat = units::isq::si::catalytic_activity<units::isq::si::zeptokatal, Rep>;
-template<Representation Rep = double>
-using akat = units::isq::si::catalytic_activity<units::isq::si::attokatal, Rep>;
-template<Representation Rep = double>
-using fkat = units::isq::si::catalytic_activity<units::isq::si::femtokatal, Rep>;
-template<Representation Rep = double>
-using pkat = units::isq::si::catalytic_activity<units::isq::si::picokatal, Rep>;
-template<Representation Rep = double>
-using nkat = units::isq::si::catalytic_activity<units::isq::si::nanokatal, Rep>;
-template<Representation Rep = double>
-using ukat = units::isq::si::catalytic_activity<units::isq::si::microkatal, Rep>;
-template<Representation Rep = double>
-using mkat = units::isq::si::catalytic_activity<units::isq::si::millikatal, Rep>;
-template<Representation Rep = double>
-using ckat = units::isq::si::catalytic_activity<units::isq::si::centikatal, Rep>;
-template<Representation Rep = double>
-using dkat = units::isq::si::catalytic_activity<units::isq::si::decikatal, Rep>;
-template<Representation Rep = double>
-using dakat = units::isq::si::catalytic_activity<units::isq::si::decakatal, Rep>;
-template<Representation Rep = double>
-using hkat = units::isq::si::catalytic_activity<units::isq::si::hectokatal, Rep>;
-template<Representation Rep = double>
-using kkat = units::isq::si::catalytic_activity<units::isq::si::kilokatal, Rep>;
-template<Representation Rep = double>
-using Mkat = units::isq::si::catalytic_activity<units::isq::si::megakatal, Rep>;
-template<Representation Rep = double>
-using Gkat = units::isq::si::catalytic_activity<units::isq::si::gigakatal, Rep>;
-template<Representation Rep = double>
-using Tkat = units::isq::si::catalytic_activity<units::isq::si::terakatal, Rep>;
-template<Representation Rep = double>
-using Pkat = units::isq::si::catalytic_activity<units::isq::si::petakatal, Rep>;
-template<Representation Rep = double>
-using Ekat = units::isq::si::catalytic_activity<units::isq::si::exakatal, Rep>;
-template<Representation Rep = double>
-using Zkat = units::isq::si::catalytic_activity<units::isq::si::zettakatal, Rep>;
-template<Representation Rep = double>
-using Ykat = units::isq::si::catalytic_activity<units::isq::si::yottakatal, Rep>;
-template<Representation Rep = double>
-using U = units::isq::si::catalytic_activity<units::isq::si::enzyme_unit, Rep>;
-
-}  // namespace units::aliases::isq::si::inline catalytic_activity
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/charge_density.h b/src/systems/si/include/units/isq/si/charge_density.h
deleted file mode 100644
index 52fba248..00000000
--- a/src/systems/si/include/units/isq/si/charge_density.h
+++ /dev/null
@@ -1,93 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/charge_density.h>
-#include <units/quantity.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/electric_charge.h>
-#include <units/isq/si/length.h>
-#include <units/isq/si/prefixes.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct coulomb_per_metre_cub : derived_unit<coulomb_per_metre_cub> {};
-struct coulomb_per_metre_sq : derived_unit<coulomb_per_metre_sq> {};
-
-struct dim_charge_density :
-    isq::dim_charge_density<dim_charge_density, coulomb_per_metre_cub, dim_electric_charge, dim_length> {};
-struct dim_surface_charge_density :
-    isq::dim_surface_charge_density<dim_surface_charge_density, coulomb_per_metre_sq, dim_electric_charge, dim_length> {
-};
-
-template<UnitOf<dim_charge_density> U, Representation Rep = double>
-using charge_density = quantity<dim_charge_density, U, Rep>;
-
-template<UnitOf<dim_surface_charge_density> U, Representation Rep = double>
-using surface_charge_density = quantity<dim_surface_charge_density, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// C/m³
-constexpr auto operator"" _q_C_per_m3(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return charge_density<coulomb_per_metre_cub, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_C_per_m3(long double l) { return charge_density<coulomb_per_metre_cub, long double>(l); }
-
-// C/m²
-constexpr auto operator"" _q_C_per_m2(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return surface_charge_density<coulomb_per_metre_sq, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_C_per_m2(long double l)
-{
-  return surface_charge_density<coulomb_per_metre_sq, long double>(l);
-}
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::inline charge_density {
-
-template<Representation Rep = double>
-using C_per_m3 = units::isq::si::charge_density<units::isq::si::coulomb_per_metre_cub, Rep>;
-template<Representation Rep = double>
-using C_per_m2 = units::isq::si::surface_charge_density<units::isq::si::coulomb_per_metre_sq, Rep>;
-
-}  // namespace units::aliases::isq::si::inline charge_density
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/concentration.h b/src/systems/si/include/units/isq/si/concentration.h
deleted file mode 100644
index 732583a5..00000000
--- a/src/systems/si/include/units/isq/si/concentration.h
+++ /dev/null
@@ -1,71 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/concentration.h>
-#include <units/quantity.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#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 : derived_unit<mol_per_metre_cub> {};
-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>;
-
-#ifndef UNITS_NO_LITERALS
-
-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(long double l) { return concentration<mol_per_metre_cub, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-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>;
-
-}  // namespace units::aliases::isq::si::inline concentration
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/conductance.h b/src/systems/si/include/units/isq/si/conductance.h
deleted file mode 100644
index 5442201f..00000000
--- a/src/systems/si/include/units/isq/si/conductance.h
+++ /dev/null
@@ -1,280 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/conductance.h>
-#include <units/quantity.h>
-#include <units/reference.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/prefixes.h>
-#include <units/isq/si/resistance.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct siemens : named_unit<siemens, "S"> {};
-struct yoctosiemens : prefixed_unit<yoctosiemens, yocto, siemens> {};
-struct zeptosiemens : prefixed_unit<zeptosiemens, zepto, siemens> {};
-struct attosiemens : prefixed_unit<attosiemens, atto, siemens> {};
-struct femtosiemens : prefixed_unit<femtosiemens, femto, siemens> {};
-struct picosiemens : prefixed_unit<picosiemens, pico, siemens> {};
-struct nanosiemens : prefixed_unit<nanosiemens, nano, siemens> {};
-struct microsiemens : prefixed_unit<microsiemens, micro, siemens> {};
-struct millisiemens : prefixed_unit<millisiemens, milli, siemens> {};
-struct kilosiemens : prefixed_unit<kilosiemens, kilo, siemens> {};
-struct megasiemens : prefixed_unit<megasiemens, mega, siemens> {};
-struct gigasiemens : prefixed_unit<gigasiemens, giga, siemens> {};
-struct terasiemens : prefixed_unit<terasiemens, tera, siemens> {};
-struct petasiemens : prefixed_unit<petasiemens, peta, siemens> {};
-struct exasiemens : prefixed_unit<exasiemens, exa, siemens> {};
-struct zettasiemens : prefixed_unit<zettasiemens, zetta, siemens> {};
-struct yottasiemens : prefixed_unit<yottasiemens, yotta, siemens> {};
-
-struct dim_conductance : isq::dim_conductance<dim_conductance, siemens, dim_resistance> {};
-
-template<UnitOf<dim_conductance> U, Representation Rep = double>
-using conductance = quantity<dim_conductance, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(long double l) { return conductance<yottasiemens, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-#ifndef UNITS_NO_REFERENCES
-
-namespace conductance_references {
-
-inline constexpr auto S = reference<dim_conductance, siemens>{};
-inline constexpr auto yS = reference<dim_conductance, yoctosiemens>{};
-inline constexpr auto zS = reference<dim_conductance, zeptosiemens>{};
-inline constexpr auto aS = reference<dim_conductance, attosiemens>{};
-inline constexpr auto fS = reference<dim_conductance, femtosiemens>{};
-inline constexpr auto pS = reference<dim_conductance, picosiemens>{};
-inline constexpr auto nS = reference<dim_conductance, nanosiemens>{};
-inline constexpr auto uS = reference<dim_conductance, microsiemens>{};
-inline constexpr auto mS = reference<dim_conductance, millisiemens>{};
-inline constexpr auto kS = reference<dim_conductance, kilosiemens>{};
-inline constexpr auto MS = reference<dim_conductance, megasiemens>{};
-inline constexpr auto GS = reference<dim_conductance, gigasiemens>{};
-inline constexpr auto TS = reference<dim_conductance, terasiemens>{};
-inline constexpr auto PS = reference<dim_conductance, petasiemens>{};
-inline constexpr auto ES = reference<dim_conductance, exasiemens>{};
-inline constexpr auto ZS = reference<dim_conductance, zettasiemens>{};
-inline constexpr auto YS = reference<dim_conductance, yottasiemens>{};
-
-}  // namespace conductance_references
-
-namespace references {
-
-using namespace conductance_references;
-
-}  // namespace references
-
-#endif  // UNITS_NO_REFERENCES
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-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>;
-
-}  // namespace units::aliases::isq::si::inline conductance
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/constants.h b/src/systems/si/include/units/isq/si/constants.h
deleted file mode 100644
index 74209888..00000000
--- a/src/systems/si/include/units/isq/si/constants.h
+++ /dev/null
@@ -1,61 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/generic/angle.h>
-#include <units/isq/si/amount_of_substance.h>
-#include <units/isq/si/electric_charge.h>
-#include <units/isq/si/energy.h>
-#include <units/isq/si/frequency.h>
-#include <units/isq/si/luminous_flux.h>
-#include <units/isq/si/power.h>
-#include <units/isq/si/speed.h>
-#include <units/isq/si/thermodynamic_temperature.h>
-
-namespace units::isq::si::si2019 {
-
-template<Representation Rep = double>
-inline constexpr auto planck_constant = energy<joule, Rep>(6.62607015e-34) * time<second, Rep>(1);
-
-template<Representation Rep = double>
-inline constexpr auto elementary_charge = electric_charge<coulomb, Rep>(1.602176634e-19);
-
-template<Representation Rep = double>
-inline constexpr auto boltzmann_constant = energy<joule, Rep>(1.380649e-23) / thermodynamic_temperature<kelvin, Rep>(1);
-
-template<Representation Rep = double>
-inline constexpr auto avogadro_constant = Rep(6.02214076e23) / amount_of_substance<mole, Rep>(1);
-
-template<Representation Rep = double>
-inline constexpr auto speed_of_light = speed<metre_per_second, Rep>(299'792'458);
-
-template<Representation Rep = double>
-inline constexpr auto hyperfine_structure_transition_frequency = frequency<hertz, Rep>(Rep{9'192'631'770});
-
-template<Representation Rep = double>
-inline constexpr auto luminous_efficacy = luminous_flux<lumen, Rep>(683) / power<watt, Rep>(1);
-
-template<Representation Rep = double>
-inline constexpr auto standard_gravity = acceleration<metre_per_second_sq, Rep>(9.80665);
-
-}  // namespace units::isq::si::si2019
diff --git a/src/systems/si/include/units/isq/si/current_density.h b/src/systems/si/include/units/isq/si/current_density.h
deleted file mode 100644
index 94234b5b..00000000
--- a/src/systems/si/include/units/isq/si/current_density.h
+++ /dev/null
@@ -1,73 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/current_density.h>
-#include <units/quantity.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/electric_current.h>
-#include <units/isq/si/length.h>
-#include <units/isq/si/prefixes.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct ampere_per_metre_sq : derived_unit<ampere_per_metre_sq> {};
-
-struct dim_current_density :
-    isq::dim_current_density<dim_current_density, ampere_per_metre_sq, dim_electric_current, dim_length> {};
-
-template<UnitOf<dim_current_density> U, Representation Rep = double>
-using current_density = quantity<dim_current_density, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// A / m²
-constexpr auto operator"" _q_A_per_m2(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return current_density<ampere_per_metre_sq, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_A_per_m2(long double l) { return current_density<ampere_per_metre_sq, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::inline current_density {
-
-template<Representation Rep = double>
-using A_per_m2 = units::isq::si::current_density<units::isq::si::ampere_per_metre_sq, Rep>;
-
-}  // namespace units::aliases::isq::si::inline current_density
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/density.h b/src/systems/si/include/units/isq/si/density.h
deleted file mode 100644
index d890e225..00000000
--- a/src/systems/si/include/units/isq/si/density.h
+++ /dev/null
@@ -1,72 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/density.h>
-#include <units/quantity.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/length.h>
-#include <units/isq/si/mass.h>
-#include <units/isq/si/prefixes.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct kilogram_per_metre_cub : derived_unit<kilogram_per_metre_cub> {};
-
-struct dim_density : isq::dim_density<dim_density, kilogram_per_metre_cub, dim_mass, dim_length> {};
-
-template<UnitOf<dim_density> U, Representation Rep = double>
-using density = quantity<dim_density, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-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(long double l) { return density<kilogram_per_metre_cub, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-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>;
-
-}  // namespace units::aliases::isq::si::inline density
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/dynamic_viscosity.h b/src/systems/si/include/units/isq/si/dynamic_viscosity.h
deleted file mode 100644
index 81f0d2bb..00000000
--- a/src/systems/si/include/units/isq/si/dynamic_viscosity.h
+++ /dev/null
@@ -1,71 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/dynamic_viscosity.h>
-#include <units/quantity.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/pressure.h>
-#include <units/isq/si/time.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct pascal_second : derived_unit<pascal_second> {};
-struct dim_dynamic_viscosity :
-    isq::dim_dynamic_viscosity<dim_dynamic_viscosity, pascal_second, dim_pressure, dim_time> {};
-
-template<UnitOf<dim_dynamic_viscosity> U, Representation Rep = double>
-using dynamic_viscosity = quantity<dim_dynamic_viscosity, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// Pa·s
-constexpr auto operator"" _q_Pa_s(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return dynamic_viscosity<pascal_second, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Pa_s(long double l) { return dynamic_viscosity<pascal_second, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::inline dynamic_viscosity {
-
-template<Representation Rep = double>
-using Pa_s = units::isq::si::dynamic_viscosity<units::isq::si::pascal_second, Rep>;
-
-}  // namespace units::aliases::isq::si::inline dynamic_viscosity
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/electric_charge.h b/src/systems/si/include/units/isq/si/electric_charge.h
deleted file mode 100644
index ca431827..00000000
--- a/src/systems/si/include/units/isq/si/electric_charge.h
+++ /dev/null
@@ -1,88 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/electric_charge.h>
-#include <units/quantity.h>
-#include <units/reference.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/electric_current.h>
-#include <units/isq/si/time.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct coulomb : named_unit<coulomb, "C"> {};
-
-struct dim_electric_charge : isq::dim_electric_charge<dim_electric_charge, coulomb, dim_time, dim_electric_current> {};
-
-template<UnitOf<dim_electric_charge> U, Representation Rep = double>
-using electric_charge = quantity<dim_electric_charge, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// C
-constexpr auto operator"" _q_C(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return electric_charge<coulomb, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_C(long double l) { return electric_charge<coulomb, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-#ifndef UNITS_NO_REFERENCES
-
-namespace electric_charge_references {
-
-inline constexpr auto C = reference<dim_electric_charge, coulomb>{};
-
-}  // namespace electric_charge_references
-
-namespace references {
-
-using namespace electric_charge_references;
-
-}  // namespace references
-
-#endif  // UNITS_NO_REFERENCES
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::inline electric_charge {
-
-template<Representation Rep = double>
-using C = units::isq::si::electric_charge<units::isq::si::coulomb, Rep>;
-
-}  // namespace units::aliases::isq::si::inline electric_charge
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/electric_current.h b/src/systems/si/include/units/isq/si/electric_current.h
deleted file mode 100644
index 740eb113..00000000
--- a/src/systems/si/include/units/isq/si/electric_current.h
+++ /dev/null
@@ -1,327 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/electric_current.h>
-#include <units/quantity.h>
-#include <units/reference.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/prefixes.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct ampere : named_unit<ampere, "A"> {};
-struct yoctoampere : prefixed_unit<yoctoampere, yocto, ampere> {};
-struct zeptoampere : prefixed_unit<zeptoampere, zepto, ampere> {};
-struct attoampere : prefixed_unit<attoampere, atto, ampere> {};
-struct femtoampere : prefixed_unit<femtoampere, femto, ampere> {};
-struct picoampere : prefixed_unit<picoampere, pico, ampere> {};
-struct nanoampere : prefixed_unit<nanoampere, nano, ampere> {};
-struct microampere : prefixed_unit<microampere, micro, ampere> {};
-struct milliampere : prefixed_unit<milliampere, milli, ampere> {};
-struct centiampere : prefixed_unit<centiampere, centi, ampere> {};
-struct deciampere : prefixed_unit<deciampere, deci, ampere> {};
-struct decaampere : prefixed_unit<decaampere, deca, ampere> {};
-struct hectoampere : prefixed_unit<hectoampere, hecto, ampere> {};
-struct kiloampere : prefixed_unit<kiloampere, kilo, ampere> {};
-struct megaampere : prefixed_unit<megaampere, mega, ampere> {};
-struct gigaampere : prefixed_unit<gigaampere, giga, ampere> {};
-struct teraampere : prefixed_unit<teraampere, tera, ampere> {};
-struct petaampere : prefixed_unit<petaampere, peta, ampere> {};
-struct exaampere : prefixed_unit<exaampere, exa, ampere> {};
-struct zettaampere : prefixed_unit<zettaampere, zetta, ampere> {};
-struct yottaampere : prefixed_unit<yottaampere, yotta, ampere> {};
-
-struct dim_electric_current : isq::dim_electric_current<ampere> {};
-
-template<UnitOf<dim_electric_current> U, Representation Rep = double>
-using electric_current = quantity<dim_electric_current, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// A
-constexpr auto operator"" _q_A(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return electric_current<ampere, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_A(long double l) { return electric_current<ampere, long double>(l); }
-
-// yA
-constexpr auto operator"" _q_yA(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return electric_current<yoctoampere, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_yA(long double l) { return electric_current<yoctoampere, long double>(l); }
-
-// zA
-constexpr auto operator"" _q_zA(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return electric_current<zeptoampere, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_zA(long double l) { return electric_current<zeptoampere, long double>(l); }
-
-// aA
-constexpr auto operator"" _q_aA(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return electric_current<attoampere, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_aA(long double l) { return electric_current<attoampere, long double>(l); }
-
-// fA
-constexpr auto operator"" _q_fA(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return electric_current<femtoampere, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_fA(long double l) { return electric_current<femtoampere, long double>(l); }
-
-// pA
-constexpr auto operator"" _q_pA(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return electric_current<picoampere, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_pA(long double l) { return electric_current<picoampere, long double>(l); }
-
-// nA
-constexpr auto operator"" _q_nA(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return electric_current<nanoampere, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_nA(long double l) { return electric_current<nanoampere, long double>(l); }
-
-// uA
-constexpr auto operator"" _q_uA(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return electric_current<microampere, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_uA(long double l) { return electric_current<microampere, long double>(l); }
-
-// mA
-constexpr auto operator"" _q_mA(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return electric_current<milliampere, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_mA(long double l) { return electric_current<milliampere, long double>(l); }
-
-// cA
-constexpr auto operator"" _q_cA(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return electric_current<centiampere, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_cA(long double l) { return electric_current<centiampere, long double>(l); }
-
-// dA
-constexpr auto operator"" _q_dA(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return electric_current<deciampere, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_dA(long double l) { return electric_current<deciampere, long double>(l); }
-
-// daA
-constexpr auto operator"" _q_daA(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return electric_current<decaampere, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_daA(long double l) { return electric_current<decaampere, long double>(l); }
-
-// hA
-constexpr auto operator"" _q_hA(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return electric_current<hectoampere, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_hA(long double l) { return electric_current<hectoampere, long double>(l); }
-
-// kA
-constexpr auto operator"" _q_kA(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return electric_current<kiloampere, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_kA(long double l) { return electric_current<kiloampere, long double>(l); }
-
-// MA
-constexpr auto operator"" _q_MA(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return electric_current<megaampere, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_MA(long double l) { return electric_current<megaampere, long double>(l); }
-
-// GA
-constexpr auto operator"" _q_GA(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return electric_current<gigaampere, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_GA(long double l) { return electric_current<gigaampere, long double>(l); }
-
-// TA
-constexpr auto operator"" _q_TA(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return electric_current<teraampere, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_TA(long double l) { return electric_current<teraampere, long double>(l); }
-
-// PA
-constexpr auto operator"" _q_PA(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return electric_current<petaampere, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_PA(long double l) { return electric_current<petaampere, long double>(l); }
-
-// EA
-constexpr auto operator"" _q_EA(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return electric_current<exaampere, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_EA(long double l) { return electric_current<exaampere, long double>(l); }
-
-// ZA
-constexpr auto operator"" _q_ZA(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return electric_current<zettaampere, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_ZA(long double l) { return electric_current<zettaampere, long double>(l); }
-
-// YA
-constexpr auto operator"" _q_YA(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return electric_current<yottaampere, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_YA(long double l) { return electric_current<yottaampere, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-#ifndef UNITS_NO_REFERENCES
-
-namespace electric_current_references {
-
-inline constexpr auto A = reference<dim_electric_current, ampere>{};
-inline constexpr auto yA = reference<dim_electric_current, yoctoampere>{};
-inline constexpr auto zA = reference<dim_electric_current, zeptoampere>{};
-inline constexpr auto aA = reference<dim_electric_current, attoampere>{};
-inline constexpr auto fA = reference<dim_electric_current, femtoampere>{};
-inline constexpr auto pA = reference<dim_electric_current, picoampere>{};
-inline constexpr auto nA = reference<dim_electric_current, nanoampere>{};
-inline constexpr auto uA = reference<dim_electric_current, microampere>{};
-inline constexpr auto mA = reference<dim_electric_current, milliampere>{};
-inline constexpr auto cA = reference<dim_electric_current, centiampere>{};
-inline constexpr auto dA = reference<dim_electric_current, deciampere>{};
-inline constexpr auto daA = reference<dim_electric_current, decaampere>{};
-inline constexpr auto hA = reference<dim_electric_current, hectoampere>{};
-inline constexpr auto kA = reference<dim_electric_current, kiloampere>{};
-inline constexpr auto MA = reference<dim_electric_current, megaampere>{};
-inline constexpr auto GA = reference<dim_electric_current, gigaampere>{};
-inline constexpr auto TA = reference<dim_electric_current, teraampere>{};
-inline constexpr auto PA = reference<dim_electric_current, petaampere>{};
-inline constexpr auto EA = reference<dim_electric_current, exaampere>{};
-inline constexpr auto ZA = reference<dim_electric_current, zettaampere>{};
-inline constexpr auto YA = reference<dim_electric_current, yottaampere>{};
-
-}  // namespace electric_current_references
-
-namespace references {
-
-using namespace electric_current_references;
-
-}  // namespace references
-
-#endif  // UNITS_NO_REFERENCES
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::inline electric_current {
-
-template<Representation Rep = double>
-using A = units::isq::si::electric_current<units::isq::si::ampere, Rep>;
-template<Representation Rep = double>
-using yA = units::isq::si::electric_current<units::isq::si::yoctoampere, Rep>;
-template<Representation Rep = double>
-using zA = units::isq::si::electric_current<units::isq::si::zeptoampere, Rep>;
-template<Representation Rep = double>
-using aA = units::isq::si::electric_current<units::isq::si::attoampere, Rep>;
-template<Representation Rep = double>
-using fA = units::isq::si::electric_current<units::isq::si::femtoampere, Rep>;
-template<Representation Rep = double>
-using pA = units::isq::si::electric_current<units::isq::si::picoampere, Rep>;
-template<Representation Rep = double>
-using nA = units::isq::si::electric_current<units::isq::si::nanoampere, Rep>;
-template<Representation Rep = double>
-using uA = units::isq::si::electric_current<units::isq::si::microampere, Rep>;
-template<Representation Rep = double>
-using mA = units::isq::si::electric_current<units::isq::si::milliampere, Rep>;
-template<Representation Rep = double>
-using cA = units::isq::si::electric_current<units::isq::si::centiampere, Rep>;
-template<Representation Rep = double>
-using dA = units::isq::si::electric_current<units::isq::si::deciampere, Rep>;
-template<Representation Rep = double>
-using daA = units::isq::si::electric_current<units::isq::si::decaampere, Rep>;
-template<Representation Rep = double>
-using hA = units::isq::si::electric_current<units::isq::si::hectoampere, Rep>;
-template<Representation Rep = double>
-using kA = units::isq::si::electric_current<units::isq::si::kiloampere, Rep>;
-template<Representation Rep = double>
-using MA = units::isq::si::electric_current<units::isq::si::megaampere, Rep>;
-template<Representation Rep = double>
-using GA = units::isq::si::electric_current<units::isq::si::gigaampere, Rep>;
-template<Representation Rep = double>
-using TA = units::isq::si::electric_current<units::isq::si::teraampere, Rep>;
-template<Representation Rep = double>
-using PA = units::isq::si::electric_current<units::isq::si::petaampere, Rep>;
-template<Representation Rep = double>
-using EA = units::isq::si::electric_current<units::isq::si::exaampere, Rep>;
-template<Representation Rep = double>
-using ZA = units::isq::si::electric_current<units::isq::si::zettaampere, Rep>;
-template<Representation Rep = double>
-using YA = units::isq::si::electric_current<units::isq::si::yottaampere, Rep>;
-
-}  // namespace units::aliases::isq::si::inline electric_current
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/electric_field_strength.h b/src/systems/si/include/units/isq/si/electric_field_strength.h
deleted file mode 100644
index 773640d5..00000000
--- a/src/systems/si/include/units/isq/si/electric_field_strength.h
+++ /dev/null
@@ -1,70 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/electric_field_strength.h>
-#include <units/quantity.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/voltage.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct volt_per_metre : derived_unit<volt_per_metre> {};
-struct dim_electric_field_strength :
-    isq::dim_electric_field_strength<dim_electric_field_strength, volt_per_metre, dim_voltage, dim_length> {};
-
-template<UnitOf<dim_electric_field_strength> U, Representation Rep = double>
-using electric_field_strength = quantity<dim_electric_field_strength, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// V/m
-constexpr auto operator"" _q_V_per_m(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return electric_field_strength<volt_per_metre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_V_per_m(long double l) { return electric_field_strength<volt_per_metre, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::inline electric_field_strength {
-
-template<Representation Rep = double>
-using V_per_m = units::isq::si::electric_field_strength<units::isq::si::volt_per_metre, Rep>;
-
-}  // namespace units::aliases::isq::si::inline electric_field_strength
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/energy.h b/src/systems/si/include/units/isq/si/energy.h
deleted file mode 100644
index 7511c4d0..00000000
--- a/src/systems/si/include/units/isq/si/energy.h
+++ /dev/null
@@ -1,310 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/energy.h>
-#include <units/quantity.h>
-#include <units/reference.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/force.h>
-#include <units/isq/si/prefixes.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct joule : named_unit<joule, "J"> {};
-struct yoctojoule : prefixed_unit<yoctojoule, yocto, joule> {};
-struct zeptojoule : prefixed_unit<zeptojoule, zepto, joule> {};
-struct attojoule : prefixed_unit<attojoule, atto, joule> {};
-struct femtojoule : prefixed_unit<femtojoule, femto, joule> {};
-struct picojoule : prefixed_unit<picojoule, pico, joule> {};
-struct nanojoule : prefixed_unit<nanojoule, nano, joule> {};
-struct microjoule : prefixed_unit<microjoule, micro, joule> {};
-struct millijoule : prefixed_unit<millijoule, milli, joule> {};
-struct kilojoule : prefixed_unit<kilojoule, kilo, joule> {};
-struct megajoule : prefixed_unit<megajoule, mega, joule> {};
-struct gigajoule : prefixed_unit<gigajoule, giga, joule> {};
-struct terajoule : prefixed_unit<terajoule, tera, joule> {};
-struct petajoule : prefixed_unit<petajoule, peta, joule> {};
-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
-struct electronvolt :
-    named_scaled_unit<electronvolt, "eV", mag<ratio(1'602'176'634, 1'000'000'000)>() * mag_power<10, -19>(), joule> {};
-struct gigaelectronvolt : prefixed_unit<gigaelectronvolt, giga, electronvolt> {};
-
-struct dim_energy : isq::dim_energy<dim_energy, joule, dim_force, dim_length> {};
-
-template<UnitOf<dim_energy> U, Representation Rep = double>
-using energy = quantity<dim_energy, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(long double l) { return energy<gigaelectronvolt, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-#ifndef UNITS_NO_REFERENCES
-
-namespace energy_references {
-
-inline constexpr auto J = reference<dim_energy, joule>{};
-inline constexpr auto yJ = reference<dim_energy, yoctojoule>{};
-inline constexpr auto zJ = reference<dim_energy, zeptojoule>{};
-inline constexpr auto aJ = reference<dim_energy, attojoule>{};
-inline constexpr auto fJ = reference<dim_energy, femtojoule>{};
-inline constexpr auto pJ = reference<dim_energy, picojoule>{};
-inline constexpr auto nJ = reference<dim_energy, nanojoule>{};
-inline constexpr auto uJ = reference<dim_energy, microjoule>{};
-inline constexpr auto mJ = reference<dim_energy, millijoule>{};
-inline constexpr auto kJ = reference<dim_energy, kilojoule>{};
-inline constexpr auto MJ = reference<dim_energy, megajoule>{};
-inline constexpr auto GJ = reference<dim_energy, gigajoule>{};
-inline constexpr auto TJ = reference<dim_energy, terajoule>{};
-inline constexpr auto PJ = reference<dim_energy, petajoule>{};
-inline constexpr auto EJ = reference<dim_energy, exajoule>{};
-inline constexpr auto ZJ = reference<dim_energy, zettajoule>{};
-inline constexpr auto YJ = reference<dim_energy, yottajoule>{};
-
-inline constexpr auto eV = reference<dim_energy, electronvolt>{};
-inline constexpr auto GeV = reference<dim_energy, gigaelectronvolt>{};
-
-}  // namespace energy_references
-
-namespace references {
-
-using namespace energy_references;
-
-}  // namespace references
-
-#endif  // UNITS_NO_REFERENCES
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-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 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
diff --git a/src/systems/si/include/units/isq/si/energy_density.h b/src/systems/si/include/units/isq/si/energy_density.h
deleted file mode 100644
index e9e156d7..00000000
--- a/src/systems/si/include/units/isq/si/energy_density.h
+++ /dev/null
@@ -1,70 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/energy_density.h>
-#include <units/quantity.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/energy.h>
-#include <units/isq/si/volume.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct joule_per_metre_cub : derived_unit<joule_per_metre_cub> {};
-struct dim_energy_density : isq::dim_energy_density<dim_energy_density, joule_per_metre_cub, dim_energy, dim_volume> {};
-
-template<UnitOf<dim_energy_density> U, Representation Rep = double>
-using energy_density = quantity<dim_energy_density, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// N/m
-constexpr auto operator"" _q_J_per_m3(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return energy_density<joule_per_metre_cub, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_J_per_m3(long double l) { return energy_density<joule_per_metre_cub, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::inline energy_density {
-
-template<Representation Rep = double>
-using J_per_m3 = units::isq::si::energy_density<units::isq::si::joule_per_metre_cub, Rep>;
-
-}  // namespace units::aliases::isq::si::inline energy_density
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/force.h b/src/systems/si/include/units/isq/si/force.h
deleted file mode 100644
index fa2c1880..00000000
--- a/src/systems/si/include/units/isq/si/force.h
+++ /dev/null
@@ -1,329 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/force.h>
-#include <units/quantity.h>
-#include <units/reference.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/acceleration.h>
-#include <units/isq/si/mass.h>
-#include <units/isq/si/prefixes.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct newton : named_unit<newton, "N"> {};
-struct yoctonewton : prefixed_unit<yoctonewton, yocto, newton> {};
-struct zeptonewton : prefixed_unit<zeptonewton, zepto, newton> {};
-struct attonewton : prefixed_unit<attonewton, atto, newton> {};
-struct femtonewton : prefixed_unit<femtonewton, femto, newton> {};
-struct piconewton : prefixed_unit<piconewton, pico, newton> {};
-struct nanonewton : prefixed_unit<nanonewton, nano, newton> {};
-struct micronewton : prefixed_unit<micronewton, micro, newton> {};
-struct millinewton : prefixed_unit<millinewton, milli, newton> {};
-struct centinewton : prefixed_unit<centinewton, centi, newton> {};
-struct decinewton : prefixed_unit<decinewton, deci, newton> {};
-struct decanewton : prefixed_unit<decanewton, deca, newton> {};
-struct hectonewton : prefixed_unit<hectonewton, hecto, newton> {};
-struct kilonewton : prefixed_unit<kilonewton, kilo, newton> {};
-struct meganewton : prefixed_unit<meganewton, mega, newton> {};
-struct giganewton : prefixed_unit<giganewton, giga, newton> {};
-struct teranewton : prefixed_unit<teranewton, tera, newton> {};
-struct petanewton : prefixed_unit<petanewton, peta, newton> {};
-struct exanewton : prefixed_unit<exanewton, exa, newton> {};
-struct zettanewton : prefixed_unit<zettanewton, zetta, newton> {};
-struct yottanewton : prefixed_unit<yottanewton, yotta, newton> {};
-
-struct dim_force : isq::dim_force<dim_force, newton, dim_mass, dim_acceleration> {};
-
-template<UnitOf<dim_force> U, Representation Rep = double>
-using force = quantity<dim_force, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(long double l) { return force<yottanewton, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-#ifndef UNITS_NO_REFERENCES
-
-namespace force_references {
-
-inline constexpr auto N = reference<dim_force, newton>{};
-inline constexpr auto yN = reference<dim_force, yoctonewton>{};
-inline constexpr auto zN = reference<dim_force, zeptonewton>{};
-inline constexpr auto aN = reference<dim_force, attonewton>{};
-inline constexpr auto fN = reference<dim_force, femtonewton>{};
-inline constexpr auto pN = reference<dim_force, piconewton>{};
-inline constexpr auto nN = reference<dim_force, nanonewton>{};
-inline constexpr auto uN = reference<dim_force, micronewton>{};
-inline constexpr auto mN = reference<dim_force, millinewton>{};
-inline constexpr auto cN = reference<dim_force, centinewton>{};
-inline constexpr auto dN = reference<dim_force, decinewton>{};
-inline constexpr auto daN = reference<dim_force, decanewton>{};
-inline constexpr auto hN = reference<dim_force, hectonewton>{};
-inline constexpr auto kN = reference<dim_force, kilonewton>{};
-inline constexpr auto MN = reference<dim_force, meganewton>{};
-inline constexpr auto GN = reference<dim_force, giganewton>{};
-inline constexpr auto TN = reference<dim_force, teranewton>{};
-inline constexpr auto PN = reference<dim_force, petanewton>{};
-inline constexpr auto EN = reference<dim_force, exanewton>{};
-inline constexpr auto ZN = reference<dim_force, zettanewton>{};
-inline constexpr auto YN = reference<dim_force, yottanewton>{};
-
-}  // namespace force_references
-
-namespace references {
-
-using namespace force_references;
-
-}  // namespace references
-
-#endif  // UNITS_NO_REFERENCES
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-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>;
-
-}  // namespace units::aliases::isq::si::inline force
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/frequency.h b/src/systems/si/include/units/isq/si/frequency.h
deleted file mode 100644
index 39fa13ee..00000000
--- a/src/systems/si/include/units/isq/si/frequency.h
+++ /dev/null
@@ -1,279 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/frequency.h>
-#include <units/quantity.h>
-#include <units/reference.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/time.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct hertz : named_unit<hertz, "Hz"> {};
-struct yoctohertz : prefixed_unit<yoctohertz, yocto, hertz> {};
-struct zeptohertz : prefixed_unit<zeptohertz, zepto, hertz> {};
-struct attohertz : prefixed_unit<attohertz, atto, hertz> {};
-struct femtohertz : prefixed_unit<femtohertz, femto, hertz> {};
-struct picohertz : prefixed_unit<picohertz, pico, hertz> {};
-struct nanohertz : prefixed_unit<nanohertz, nano, hertz> {};
-struct microhertz : prefixed_unit<microhertz, micro, hertz> {};
-struct millihertz : prefixed_unit<millihertz, milli, hertz> {};
-struct kilohertz : prefixed_unit<kilohertz, kilo, hertz> {};
-struct megahertz : prefixed_unit<megahertz, mega, hertz> {};
-struct gigahertz : prefixed_unit<gigahertz, giga, hertz> {};
-struct terahertz : prefixed_unit<terahertz, tera, hertz> {};
-struct petahertz : prefixed_unit<petahertz, peta, hertz> {};
-struct exahertz : prefixed_unit<exahertz, exa, hertz> {};
-struct zettahertz : prefixed_unit<zettahertz, zetta, hertz> {};
-struct yottahertz : prefixed_unit<yottahertz, yotta, hertz> {};
-
-struct dim_frequency : isq::dim_frequency<dim_frequency, hertz, dim_time> {};
-
-template<UnitOf<dim_frequency> U, Representation Rep = double>
-using frequency = quantity<dim_frequency, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// Hz
-constexpr auto operator"" _q_Hz(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return frequency<hertz, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Hz(long double l) { return frequency<hertz, long double>(l); }
-
-// yHz
-constexpr auto operator"" _q_yHz(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return frequency<yoctohertz, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_yHz(long double l) { return frequency<yoctohertz, long double>(l); }
-
-// zHz
-constexpr auto operator"" _q_zHz(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return frequency<zeptohertz, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_zHz(long double l) { return frequency<zeptohertz, long double>(l); }
-
-// aHz
-constexpr auto operator"" _q_aHz(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return frequency<attohertz, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_aHz(long double l) { return frequency<attohertz, long double>(l); }
-
-// fHz
-constexpr auto operator"" _q_fHz(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return frequency<femtohertz, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_fHz(long double l) { return frequency<femtohertz, long double>(l); }
-
-// pHz
-constexpr auto operator"" _q_pHz(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return frequency<picohertz, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_pHz(long double l) { return frequency<picohertz, long double>(l); }
-
-// nHz
-constexpr auto operator"" _q_nHz(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return frequency<nanohertz, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_nHz(long double l) { return frequency<nanohertz, long double>(l); }
-
-// uHz
-constexpr auto operator"" _q_uHz(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return frequency<microhertz, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_uHz(long double l) { return frequency<microhertz, long double>(l); }
-
-// mHz
-constexpr auto operator"" _q_mHz(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return frequency<millihertz, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_mHz(long double l) { return frequency<millihertz, long double>(l); }
-
-// kHz
-constexpr auto operator"" _q_kHz(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return frequency<kilohertz, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_kHz(long double l) { return frequency<kilohertz, long double>(l); }
-
-// MHz
-constexpr auto operator"" _q_MHz(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return frequency<megahertz, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_MHz(long double l) { return frequency<megahertz, long double>(l); }
-
-// GHz
-constexpr auto operator"" _q_GHz(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return frequency<gigahertz, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_GHz(long double l) { return frequency<gigahertz, long double>(l); }
-
-// THz
-constexpr auto operator"" _q_THz(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return frequency<terahertz, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_THz(long double l) { return frequency<terahertz, long double>(l); }
-
-// PHz
-constexpr auto operator"" _q_PHz(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return frequency<petahertz, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_PHz(long double l) { return frequency<petahertz, long double>(l); }
-
-// EHz
-constexpr auto operator"" _q_EHz(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return frequency<exahertz, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_EHz(long double l) { return frequency<exahertz, long double>(l); }
-
-// ZHz
-constexpr auto operator"" _q_ZHz(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return frequency<zettahertz, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_ZHz(long double l) { return frequency<zettahertz, long double>(l); }
-
-// YHz
-constexpr auto operator"" _q_YHz(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return frequency<yottahertz, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_YHz(long double l) { return frequency<yottahertz, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-#ifndef UNITS_NO_REFERENCES
-
-namespace frequency_references {
-
-inline constexpr auto Hz = reference<dim_frequency, hertz>{};
-inline constexpr auto yHz = reference<dim_frequency, yoctohertz>{};
-inline constexpr auto zHz = reference<dim_frequency, zeptohertz>{};
-inline constexpr auto aHz = reference<dim_frequency, attohertz>{};
-inline constexpr auto fHz = reference<dim_frequency, femtohertz>{};
-inline constexpr auto pHz = reference<dim_frequency, picohertz>{};
-inline constexpr auto nHz = reference<dim_frequency, nanohertz>{};
-inline constexpr auto uHz = reference<dim_frequency, microhertz>{};
-inline constexpr auto mHz = reference<dim_frequency, millihertz>{};
-inline constexpr auto kHz = reference<dim_frequency, kilohertz>{};
-inline constexpr auto MHz = reference<dim_frequency, megahertz>{};
-inline constexpr auto GHz = reference<dim_frequency, gigahertz>{};
-inline constexpr auto THz = reference<dim_frequency, terahertz>{};
-inline constexpr auto PHz = reference<dim_frequency, petahertz>{};
-inline constexpr auto EHz = reference<dim_frequency, exahertz>{};
-inline constexpr auto ZHz = reference<dim_frequency, zettahertz>{};
-inline constexpr auto YHz = reference<dim_frequency, yottahertz>{};
-
-}  // namespace frequency_references
-
-namespace references {
-
-using namespace frequency_references;
-
-}  // namespace references
-
-#endif  // UNITS_NO_REFERENCES
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::inline frequency {
-
-template<Representation Rep = double>
-using Hz = units::isq::si::frequency<units::isq::si::hertz, Rep>;
-template<Representation Rep = double>
-using yHz = units::isq::si::frequency<units::isq::si::yoctohertz, Rep>;
-template<Representation Rep = double>
-using zHz = units::isq::si::frequency<units::isq::si::zeptohertz, Rep>;
-template<Representation Rep = double>
-using aHz = units::isq::si::frequency<units::isq::si::attohertz, Rep>;
-template<Representation Rep = double>
-using fHz = units::isq::si::frequency<units::isq::si::femtohertz, Rep>;
-template<Representation Rep = double>
-using pHz = units::isq::si::frequency<units::isq::si::picohertz, Rep>;
-template<Representation Rep = double>
-using nHz = units::isq::si::frequency<units::isq::si::nanohertz, Rep>;
-template<Representation Rep = double>
-using uHz = units::isq::si::frequency<units::isq::si::microhertz, Rep>;
-template<Representation Rep = double>
-using mHz = units::isq::si::frequency<units::isq::si::millihertz, Rep>;
-template<Representation Rep = double>
-using kHz = units::isq::si::frequency<units::isq::si::kilohertz, Rep>;
-template<Representation Rep = double>
-using MHz = units::isq::si::frequency<units::isq::si::megahertz, Rep>;
-template<Representation Rep = double>
-using GHz = units::isq::si::frequency<units::isq::si::gigahertz, Rep>;
-template<Representation Rep = double>
-using THz = units::isq::si::frequency<units::isq::si::terahertz, Rep>;
-template<Representation Rep = double>
-using PHz = units::isq::si::frequency<units::isq::si::petahertz, Rep>;
-template<Representation Rep = double>
-using EHz = units::isq::si::frequency<units::isq::si::exahertz, Rep>;
-template<Representation Rep = double>
-using ZHz = units::isq::si::frequency<units::isq::si::zettahertz, Rep>;
-template<Representation Rep = double>
-using YHz = units::isq::si::frequency<units::isq::si::yottahertz, Rep>;
-
-}  // namespace units::aliases::isq::si::inline frequency
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/heat_capacity.h b/src/systems/si/include/units/isq/si/heat_capacity.h
deleted file mode 100644
index 5ae30cfa..00000000
--- a/src/systems/si/include/units/isq/si/heat_capacity.h
+++ /dev/null
@@ -1,114 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/heat_capacity.h>
-#include <units/quantity.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/amount_of_substance.h>
-#include <units/isq/si/energy.h>
-#include <units/isq/si/mass.h>
-#include <units/isq/si/thermodynamic_temperature.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct joule_per_kelvin : derived_unit<joule_per_kelvin> {};
-struct joule_per_kilogram_kelvin : derived_unit<joule_per_kilogram_kelvin> {};
-struct joule_per_mole_kelvin : derived_unit<joule_per_mole_kelvin> {};
-
-struct dim_heat_capacity :
-    isq::dim_heat_capacity<dim_heat_capacity, joule_per_kelvin, dim_energy, dim_thermodynamic_temperature> {};
-struct dim_specific_heat_capacity :
-    isq::dim_specific_heat_capacity<dim_specific_heat_capacity, joule_per_kilogram_kelvin, dim_heat_capacity,
-                                    dim_mass> {};
-struct dim_molar_heat_capacity :
-    isq::dim_molar_heat_capacity<dim_molar_heat_capacity, joule_per_mole_kelvin, dim_heat_capacity,
-                                 dim_amount_of_substance> {};
-
-template<UnitOf<dim_heat_capacity> U, Representation Rep = double>
-using heat_capacity = quantity<dim_heat_capacity, U, Rep>;
-
-template<UnitOf<dim_specific_heat_capacity> U, Representation Rep = double>
-using specific_heat_capacity = quantity<dim_specific_heat_capacity, U, Rep>;
-
-template<UnitOf<dim_molar_heat_capacity> U, Representation Rep = double>
-using molar_heat_capacity = quantity<dim_molar_heat_capacity, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// J/K
-constexpr auto operator"" _q_J_per_K(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return heat_capacity<joule_per_kelvin, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_J_per_K(long double l) { return heat_capacity<joule_per_kelvin, long double>(l); }
-
-// J/(kg·K)
-constexpr auto operator"" _q_J_per_kg_K(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return specific_heat_capacity<joule_per_kilogram_kelvin, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_J_per_kg_K(long double l)
-{
-  return specific_heat_capacity<joule_per_kilogram_kelvin, long double>(l);
-}
-
-// J/(mol·K)
-constexpr auto operator"" _q_J_per_mol_K(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return molar_heat_capacity<joule_per_mole_kelvin, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_J_per_mol_K(long double l)
-{
-  return molar_heat_capacity<joule_per_mole_kelvin, long double>(l);
-}
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::heat_capacity {
-
-template<Representation Rep = double>
-using J_per_K = units::isq::si::heat_capacity<units::isq::si::joule_per_kelvin, Rep>;
-template<Representation Rep = double>
-using J_per_kg_K = units::isq::si::specific_heat_capacity<units::isq::si::joule_per_kilogram_kelvin, Rep>;
-template<Representation Rep = double>
-using J_per_mol_K = units::isq::si::molar_heat_capacity<units::isq::si::joule_per_mole_kelvin, Rep>;
-
-}  // namespace units::aliases::isq::si::heat_capacity
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/inductance.h b/src/systems/si/include/units/isq/si/inductance.h
deleted file mode 100644
index c6a14a98..00000000
--- a/src/systems/si/include/units/isq/si/inductance.h
+++ /dev/null
@@ -1,281 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/inductance.h>
-#include <units/quantity.h>
-#include <units/reference.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/electric_current.h>
-#include <units/isq/si/magnetic_flux.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct henry : named_unit<henry, "H"> {};
-
-struct yoctohenry : prefixed_unit<yoctohenry, yocto, henry> {};
-struct zeptohenry : prefixed_unit<zeptohenry, zepto, henry> {};
-struct attohenry : prefixed_unit<attohenry, atto, henry> {};
-struct femtohenry : prefixed_unit<femtohenry, femto, henry> {};
-struct picohenry : prefixed_unit<picohenry, pico, henry> {};
-struct nanohenry : prefixed_unit<nanohenry, nano, henry> {};
-struct microhenry : prefixed_unit<microhenry, micro, henry> {};
-struct millihenry : prefixed_unit<millihenry, milli, henry> {};
-struct kilohenry : prefixed_unit<kilohenry, kilo, henry> {};
-struct megahenry : prefixed_unit<megahenry, mega, henry> {};
-struct gigahenry : prefixed_unit<gigahenry, giga, henry> {};
-struct terahenry : prefixed_unit<terahenry, tera, henry> {};
-struct petahenry : prefixed_unit<petahenry, peta, henry> {};
-struct exahenry : prefixed_unit<exahenry, exa, henry> {};
-struct zettahenry : prefixed_unit<zettahenry, zetta, henry> {};
-struct yottahenry : prefixed_unit<yottahenry, yotta, henry> {};
-
-struct dim_inductance : isq::dim_inductance<dim_inductance, henry, dim_magnetic_flux, dim_electric_current> {};
-
-template<UnitOf<dim_inductance> U, Representation Rep = double>
-using inductance = quantity<dim_inductance, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// H
-constexpr auto operator"" _q_H(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return inductance<henry, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_H(long double l) { return inductance<henry, long double>(l); }
-
-// yH
-constexpr auto operator"" _q_yH(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return inductance<yoctohenry, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_yH(long double l) { return inductance<yoctohenry, long double>(l); }
-
-// zH
-constexpr auto operator"" _q_zH(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return inductance<zeptohenry, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_zH(long double l) { return inductance<zeptohenry, long double>(l); }
-
-// aH
-constexpr auto operator"" _q_aH(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return inductance<attohenry, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_aH(long double l) { return inductance<attohenry, long double>(l); }
-
-// fH
-constexpr auto operator"" _q_fH(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return inductance<femtohenry, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_fH(long double l) { return inductance<femtohenry, long double>(l); }
-
-// pH
-constexpr auto operator"" _q_pH(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return inductance<picohenry, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_pH(long double l) { return inductance<picohenry, long double>(l); }
-
-// nH
-constexpr auto operator"" _q_nH(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return inductance<nanohenry, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_nH(long double l) { return inductance<nanohenry, long double>(l); }
-
-// µH
-constexpr auto operator"" _q_uH(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return inductance<microhenry, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_uH(long double l) { return inductance<microhenry, long double>(l); }
-
-// mH
-constexpr auto operator"" _q_mH(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return inductance<millihenry, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_mH(long double l) { return inductance<millihenry, long double>(l); }
-
-// kH
-constexpr auto operator"" _q_kH(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return inductance<kilohenry, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_kH(long double l) { return inductance<kilohenry, long double>(l); }
-
-// MH
-constexpr auto operator"" _q_MH(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return inductance<megahenry, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_MH(long double l) { return inductance<megahenry, long double>(l); }
-
-// GH
-constexpr auto operator"" _q_GH(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return inductance<gigahenry, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_GH(long double l) { return inductance<gigahenry, long double>(l); }
-
-// TH
-constexpr auto operator"" _q_TH(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return inductance<terahenry, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_TH(long double l) { return inductance<terahenry, long double>(l); }
-
-// PH
-constexpr auto operator"" _q_PH(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return inductance<petahenry, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_PH(long double l) { return inductance<petahenry, long double>(l); }
-
-// EH
-constexpr auto operator"" _q_EH(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return inductance<exahenry, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_EH(long double l) { return inductance<exahenry, long double>(l); }
-
-// ZH
-constexpr auto operator"" _q_ZH(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return inductance<zettahenry, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_ZH(long double l) { return inductance<zettahenry, long double>(l); }
-
-// YH
-constexpr auto operator"" _q_YH(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return inductance<yottahenry, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_YH(long double l) { return inductance<yottahenry, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-#ifndef UNITS_NO_REFERENCES
-
-namespace inductance_references {
-
-inline constexpr auto H = reference<dim_inductance, henry>{};
-inline constexpr auto yH = reference<dim_inductance, yoctohenry>{};
-inline constexpr auto zH = reference<dim_inductance, zeptohenry>{};
-inline constexpr auto aH = reference<dim_inductance, attohenry>{};
-inline constexpr auto fH = reference<dim_inductance, femtohenry>{};
-inline constexpr auto pH = reference<dim_inductance, picohenry>{};
-inline constexpr auto nH = reference<dim_inductance, nanohenry>{};
-inline constexpr auto uH = reference<dim_inductance, microhenry>{};
-inline constexpr auto mH = reference<dim_inductance, millihenry>{};
-inline constexpr auto kH = reference<dim_inductance, kilohenry>{};
-inline constexpr auto MH = reference<dim_inductance, megahenry>{};
-inline constexpr auto GH = reference<dim_inductance, gigahenry>{};
-inline constexpr auto TH = reference<dim_inductance, terahenry>{};
-inline constexpr auto PH = reference<dim_inductance, petahenry>{};
-inline constexpr auto EH = reference<dim_inductance, exahenry>{};
-inline constexpr auto ZH = reference<dim_inductance, zettahenry>{};
-inline constexpr auto YH = reference<dim_inductance, yottahenry>{};
-
-}  // namespace inductance_references
-
-namespace references {
-
-using namespace inductance_references;
-
-}  // namespace references
-
-#endif  // UNITS_NO_REFERENCES
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::inline inductance {
-
-template<Representation Rep = double>
-using H = units::isq::si::inductance<units::isq::si::henry, Rep>;
-template<Representation Rep = double>
-using yH = units::isq::si::inductance<units::isq::si::yoctohenry, Rep>;
-template<Representation Rep = double>
-using zH = units::isq::si::inductance<units::isq::si::zeptohenry, Rep>;
-template<Representation Rep = double>
-using aH = units::isq::si::inductance<units::isq::si::attohenry, Rep>;
-template<Representation Rep = double>
-using fH = units::isq::si::inductance<units::isq::si::femtohenry, Rep>;
-template<Representation Rep = double>
-using pH = units::isq::si::inductance<units::isq::si::picohenry, Rep>;
-template<Representation Rep = double>
-using nH = units::isq::si::inductance<units::isq::si::nanohenry, Rep>;
-template<Representation Rep = double>
-using uH = units::isq::si::inductance<units::isq::si::microhenry, Rep>;
-template<Representation Rep = double>
-using mH = units::isq::si::inductance<units::isq::si::millihenry, Rep>;
-template<Representation Rep = double>
-using kH = units::isq::si::inductance<units::isq::si::kilohenry, Rep>;
-template<Representation Rep = double>
-using MH = units::isq::si::inductance<units::isq::si::megahenry, Rep>;
-template<Representation Rep = double>
-using GH = units::isq::si::inductance<units::isq::si::gigahenry, Rep>;
-template<Representation Rep = double>
-using TH = units::isq::si::inductance<units::isq::si::terahenry, Rep>;
-template<Representation Rep = double>
-using PH = units::isq::si::inductance<units::isq::si::petahenry, Rep>;
-template<Representation Rep = double>
-using EH = units::isq::si::inductance<units::isq::si::exahenry, Rep>;
-template<Representation Rep = double>
-using ZH = units::isq::si::inductance<units::isq::si::zettahenry, Rep>;
-template<Representation Rep = double>
-using YH = units::isq::si::inductance<units::isq::si::yottahenry, Rep>;
-
-}  // namespace units::aliases::isq::si::inline inductance
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/length.h b/src/systems/si/include/units/isq/si/length.h
deleted file mode 100644
index 6585ed92..00000000
--- a/src/systems/si/include/units/isq/si/length.h
+++ /dev/null
@@ -1,340 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/length.h>
-#include <units/quantity.h>
-#include <units/reference.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/prefixes.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct metre : named_unit<metre, "m"> {};
-struct yoctometre : prefixed_unit<yoctometre, yocto, metre> {};
-struct zeptometre : prefixed_unit<zeptometre, zepto, metre> {};
-struct attometre : prefixed_unit<attometre, atto, metre> {};
-struct femtometre : prefixed_unit<femtometre, femto, metre> {};
-struct picometre : prefixed_unit<picometre, pico, metre> {};
-struct nanometre : prefixed_unit<nanometre, nano, metre> {};
-struct micrometre : prefixed_unit<micrometre, micro, metre> {};
-struct millimetre : prefixed_unit<millimetre, milli, metre> {};
-struct centimetre : prefixed_unit<centimetre, centi, metre> {};
-struct decimetre : prefixed_unit<decimetre, deci, metre> {};
-struct decametre : prefixed_unit<decametre, deca, metre> {};
-struct hectometre : prefixed_unit<hectometre, hecto, metre> {};
-struct kilometre : prefixed_unit<kilometre, kilo, metre> {};
-struct megametre : prefixed_unit<megametre, mega, metre> {};
-struct gigametre : prefixed_unit<gigametre, giga, metre> {};
-struct terametre : prefixed_unit<terametre, tera, metre> {};
-struct petametre : prefixed_unit<petametre, peta, metre> {};
-struct exametre : prefixed_unit<exametre, exa, metre> {};
-struct zettametre : prefixed_unit<zettametre, zetta, metre> {};
-struct yottametre : prefixed_unit<yottametre, yotta, metre> {};
-
-struct astronomical_unit : named_scaled_unit<astronomical_unit, "au", mag<149'597'870'700>(), metre> {};
-
-struct dim_length : isq::dim_length<metre> {};
-
-template<UnitOf<dim_length> U, Representation Rep = double>
-using length = quantity<dim_length, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// m
-constexpr auto operator"" _q_m(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return length<metre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_m(long double l) { return length<metre, long double>(l); }
-
-// ym
-constexpr auto operator"" _q_ym(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return length<yoctometre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_ym(long double l) { return length<yoctometre, long double>(l); }
-
-// zm
-constexpr auto operator"" _q_zm(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return length<zeptometre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_zm(long double l) { return length<zeptometre, long double>(l); }
-
-// am
-constexpr auto operator"" _q_am(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return length<attometre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_am(long double l) { return length<attometre, long double>(l); }
-
-// fm
-constexpr auto operator"" _q_fm(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return length<femtometre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_fm(long double l) { return length<femtometre, long double>(l); }
-
-// pm
-constexpr auto operator"" _q_pm(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return length<picometre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_pm(long double l) { return length<picometre, long double>(l); }
-
-// nm
-constexpr auto operator"" _q_nm(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return length<nanometre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_nm(long double l) { return length<nanometre, long double>(l); }
-
-// um
-constexpr auto operator"" _q_um(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return length<micrometre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_um(long double l) { return length<micrometre, long double>(l); }
-
-// mm
-constexpr auto operator"" _q_mm(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return length<millimetre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_mm(long double l) { return length<millimetre, long double>(l); }
-
-// cm
-constexpr auto operator"" _q_cm(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return length<centimetre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_cm(long double l) { return length<centimetre, long double>(l); }
-
-// dm
-constexpr auto operator"" _q_dm(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return length<decimetre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_dm(long double l) { return length<decimetre, long double>(l); }
-
-// dam
-constexpr auto operator"" _q_dam(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return length<decametre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_dam(long double l) { return length<decametre, long double>(l); }
-
-// hm
-constexpr auto operator"" _q_hm(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return length<hectometre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_hm(long double l) { return length<hectometre, long double>(l); }
-
-// km
-constexpr auto operator"" _q_km(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return length<kilometre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_km(long double l) { return length<kilometre, long double>(l); }
-
-// Mm
-constexpr auto operator"" _q_Mm(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return length<megametre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Mm(long double l) { return length<megametre, long double>(l); }
-
-// Gm
-constexpr auto operator"" _q_Gm(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return length<gigametre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Gm(long double l) { return length<gigametre, long double>(l); }
-
-// Tm
-constexpr auto operator"" _q_Tm(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return length<terametre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Tm(long double l) { return length<terametre, long double>(l); }
-
-// Pm
-constexpr auto operator"" _q_Pm(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return length<petametre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Pm(long double l) { return length<petametre, long double>(l); }
-
-// Em
-constexpr auto operator"" _q_Em(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return length<exametre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Em(long double l) { return length<exametre, long double>(l); }
-
-// Zm
-constexpr auto operator"" _q_Zm(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return length<zettametre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Zm(long double l) { return length<zettametre, long double>(l); }
-
-// Ym
-constexpr auto operator"" _q_Ym(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return length<yottametre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Ym(long double l) { return length<yottametre, long double>(l); }
-
-// au
-constexpr auto operator"" _q_au(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return length<astronomical_unit, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_au(long double l) { return length<astronomical_unit, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-#ifndef UNITS_NO_REFERENCES
-
-namespace length_references {
-
-inline constexpr auto m = reference<dim_length, metre>{};
-inline constexpr auto ym = reference<dim_length, yoctometre>{};
-inline constexpr auto zm = reference<dim_length, zeptometre>{};
-inline constexpr auto am = reference<dim_length, attometre>{};
-inline constexpr auto fm = reference<dim_length, femtometre>{};
-inline constexpr auto pm = reference<dim_length, picometre>{};
-inline constexpr auto nm = reference<dim_length, nanometre>{};
-inline constexpr auto um = reference<dim_length, micrometre>{};
-inline constexpr auto mm = reference<dim_length, millimetre>{};
-inline constexpr auto cm = reference<dim_length, centimetre>{};
-inline constexpr auto dm = reference<dim_length, decimetre>{};
-inline constexpr auto dam = reference<dim_length, decametre>{};
-inline constexpr auto hm = reference<dim_length, hectometre>{};
-inline constexpr auto km = reference<dim_length, kilometre>{};
-inline constexpr auto Mm = reference<dim_length, megametre>{};
-inline constexpr auto Gm = reference<dim_length, gigametre>{};
-inline constexpr auto Tm = reference<dim_length, terametre>{};
-inline constexpr auto Pm = reference<dim_length, petametre>{};
-inline constexpr auto Em = reference<dim_length, exametre>{};
-inline constexpr auto Zm = reference<dim_length, zettametre>{};
-inline constexpr auto Ym = reference<dim_length, yottametre>{};
-inline constexpr auto au = reference<dim_length, astronomical_unit>{};
-
-}  // namespace length_references
-
-namespace references {
-
-using namespace length_references;
-
-}  // namespace references
-
-#endif  // UNITS_NO_REFERENCES
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::inline length {
-
-template<Representation Rep = double>
-using m = units::isq::si::length<units::isq::si::metre, Rep>;
-template<Representation Rep = double>
-using ym = units::isq::si::length<units::isq::si::yoctometre, Rep>;
-template<Representation Rep = double>
-using zm = units::isq::si::length<units::isq::si::zeptometre, Rep>;
-template<Representation Rep = double>
-using am = units::isq::si::length<units::isq::si::attometre, Rep>;
-template<Representation Rep = double>
-using fm = units::isq::si::length<units::isq::si::femtometre, Rep>;
-template<Representation Rep = double>
-using pm = units::isq::si::length<units::isq::si::picometre, Rep>;
-template<Representation Rep = double>
-using nm = units::isq::si::length<units::isq::si::nanometre, Rep>;
-template<Representation Rep = double>
-using um = units::isq::si::length<units::isq::si::micrometre, Rep>;
-template<Representation Rep = double>
-using mm = units::isq::si::length<units::isq::si::millimetre, Rep>;
-template<Representation Rep = double>
-using cm = units::isq::si::length<units::isq::si::centimetre, Rep>;
-template<Representation Rep = double>
-using dm = units::isq::si::length<units::isq::si::decimetre, Rep>;
-template<Representation Rep = double>
-using dam = units::isq::si::length<units::isq::si::decametre, Rep>;
-template<Representation Rep = double>
-using hm = units::isq::si::length<units::isq::si::hectometre, Rep>;
-template<Representation Rep = double>
-using km = units::isq::si::length<units::isq::si::kilometre, Rep>;
-template<Representation Rep = double>
-using Mm = units::isq::si::length<units::isq::si::megametre, Rep>;
-template<Representation Rep = double>
-using Gm = units::isq::si::length<units::isq::si::gigametre, Rep>;
-template<Representation Rep = double>
-using Tm = units::isq::si::length<units::isq::si::terametre, Rep>;
-template<Representation Rep = double>
-using Pm = units::isq::si::length<units::isq::si::petametre, Rep>;
-template<Representation Rep = double>
-using Em = units::isq::si::length<units::isq::si::exametre, Rep>;
-template<Representation Rep = double>
-using Zm = units::isq::si::length<units::isq::si::zettametre, Rep>;
-template<Representation Rep = double>
-using Ym = units::isq::si::length<units::isq::si::yottametre, Rep>;
-template<Representation Rep = double>
-using au = units::isq::si::length<units::isq::si::astronomical_unit, Rep>;
-
-}  // namespace units::aliases::isq::si::inline length
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/luminance.h b/src/systems/si/include/units/isq/si/luminance.h
deleted file mode 100644
index 48f01073..00000000
--- a/src/systems/si/include/units/isq/si/luminance.h
+++ /dev/null
@@ -1,70 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/luminance.h>
-#include <units/quantity.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/length.h>
-#include <units/isq/si/luminous_intensity.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct candela_per_metre_sq : derived_unit<candela_per_metre_sq> {};
-struct dim_luminance : isq::dim_luminance<dim_luminance, candela_per_metre_sq, dim_luminous_intensity, dim_length> {};
-
-template<UnitOf<dim_luminance> U, Representation Rep = double>
-using luminance = quantity<dim_luminance, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-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(long double l) { return luminance<candela_per_metre_sq, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-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>;
-
-}  // namespace units::aliases::isq::si::inline luminance
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/luminous_flux.h b/src/systems/si/include/units/isq/si/luminous_flux.h
deleted file mode 100644
index c35f5e8c..00000000
--- a/src/systems/si/include/units/isq/si/luminous_flux.h
+++ /dev/null
@@ -1,90 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/luminous_flux.h>
-#include <units/isq/si/luminous_intensity.h>
-#include <units/quantity.h>
-#include <units/reference.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/generic/solid_angle.h>
-#include <units/isq/si/prefixes.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct lumen : named_unit<lumen, "lm"> {};
-
-struct dim_luminous_flux :
-    isq::dim_luminous_flux<dim_luminous_flux, lumen, dim_luminous_intensity, dim_solid_angle<>> {};
-
-template<UnitOf<dim_luminous_flux> U, Representation Rep = double>
-using luminous_flux = quantity<dim_luminous_flux, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// lm
-constexpr auto operator"" _q_lm(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return luminous_flux<lumen, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_lm(long double l) { return luminous_flux<lumen, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-#ifndef UNITS_NO_REFERENCES
-
-namespace luminous_flux_references {
-
-inline constexpr auto lm = reference<dim_luminous_flux, lumen>{};
-
-}  // namespace luminous_flux_references
-
-namespace references {
-
-using namespace luminous_flux_references;
-
-}  // namespace references
-
-#endif  // UNITS_NO_REFERENCES
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::inline luminous_flux {
-
-template<Representation Rep = double>
-using lm = units::isq::si::luminous_flux<units::isq::si::lumen, Rep>;
-
-}  // namespace units::aliases::isq::si::inline luminous_flux
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/luminous_intensity.h b/src/systems/si/include/units/isq/si/luminous_intensity.h
deleted file mode 100644
index 38e658f0..00000000
--- a/src/systems/si/include/units/isq/si/luminous_intensity.h
+++ /dev/null
@@ -1,327 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/luminous_intensity.h>
-#include <units/quantity.h>
-#include <units/reference.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/prefixes.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct candela : named_unit<candela, "cd"> {};
-struct yoctocandela : prefixed_unit<yoctocandela, yocto, candela> {};
-struct zeptocandela : prefixed_unit<zeptocandela, zepto, candela> {};
-struct attocandela : prefixed_unit<attocandela, atto, candela> {};
-struct femtocandela : prefixed_unit<femtocandela, femto, candela> {};
-struct picocandela : prefixed_unit<picocandela, pico, candela> {};
-struct nanocandela : prefixed_unit<nanocandela, nano, candela> {};
-struct microcandela : prefixed_unit<microcandela, micro, candela> {};
-struct millicandela : prefixed_unit<millicandela, milli, candela> {};
-struct centicandela : prefixed_unit<centicandela, centi, candela> {};
-struct decicandela : prefixed_unit<decicandela, deci, candela> {};
-struct decacandela : prefixed_unit<decacandela, deca, candela> {};
-struct hectocandela : prefixed_unit<hectocandela, hecto, candela> {};
-struct kilocandela : prefixed_unit<kilocandela, kilo, candela> {};
-struct megacandela : prefixed_unit<megacandela, mega, candela> {};
-struct gigacandela : prefixed_unit<gigacandela, giga, candela> {};
-struct teracandela : prefixed_unit<teracandela, tera, candela> {};
-struct petacandela : prefixed_unit<petacandela, peta, candela> {};
-struct exacandela : prefixed_unit<exacandela, exa, candela> {};
-struct zettacandela : prefixed_unit<zettacandela, zetta, candela> {};
-struct yottacandela : prefixed_unit<yottacandela, yotta, candela> {};
-
-struct dim_luminous_intensity : isq::dim_luminous_intensity<candela> {};
-
-template<UnitOf<dim_luminous_intensity> U, Representation Rep = double>
-using luminous_intensity = quantity<dim_luminous_intensity, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(long double l) { return luminous_intensity<yottacandela, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-#ifndef UNITS_NO_REFERENCES
-
-namespace luminous_intensity_references {
-
-inline constexpr auto cd = reference<dim_luminous_intensity, candela>{};
-inline constexpr auto ycd = reference<dim_luminous_intensity, yoctocandela>{};
-inline constexpr auto zcd = reference<dim_luminous_intensity, zeptocandela>{};
-inline constexpr auto acd = reference<dim_luminous_intensity, attocandela>{};
-inline constexpr auto fcd = reference<dim_luminous_intensity, femtocandela>{};
-inline constexpr auto pcd = reference<dim_luminous_intensity, picocandela>{};
-inline constexpr auto ncd = reference<dim_luminous_intensity, nanocandela>{};
-inline constexpr auto ucd = reference<dim_luminous_intensity, microcandela>{};
-inline constexpr auto mcd = reference<dim_luminous_intensity, millicandela>{};
-inline constexpr auto ccd = reference<dim_luminous_intensity, centicandela>{};
-inline constexpr auto dcd = reference<dim_luminous_intensity, decicandela>{};
-inline constexpr auto dacd = reference<dim_luminous_intensity, decacandela>{};
-inline constexpr auto hcd = reference<dim_luminous_intensity, hectocandela>{};
-inline constexpr auto kcd = reference<dim_luminous_intensity, kilocandela>{};
-inline constexpr auto Mcd = reference<dim_luminous_intensity, megacandela>{};
-inline constexpr auto Gcd = reference<dim_luminous_intensity, gigacandela>{};
-inline constexpr auto Tcd = reference<dim_luminous_intensity, teracandela>{};
-inline constexpr auto Pcd = reference<dim_luminous_intensity, petacandela>{};
-inline constexpr auto Ecd = reference<dim_luminous_intensity, exacandela>{};
-inline constexpr auto Zcd = reference<dim_luminous_intensity, zettacandela>{};
-inline constexpr auto Ycd = reference<dim_luminous_intensity, yottacandela>{};
-
-}  // namespace luminous_intensity_references
-
-namespace references {
-
-using namespace luminous_intensity_references;
-
-}  // namespace references
-
-#endif  // UNITS_NO_REFERENCES
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-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>;
-
-}  // namespace units::aliases::isq::si::luminous_intensity
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/magnetic_flux.h b/src/systems/si/include/units/isq/si/magnetic_flux.h
deleted file mode 100644
index 77b1410c..00000000
--- a/src/systems/si/include/units/isq/si/magnetic_flux.h
+++ /dev/null
@@ -1,281 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/magnetic_flux.h>
-#include <units/quantity.h>
-#include <units/reference.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/area.h>
-#include <units/isq/si/magnetic_induction.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct weber : named_unit<weber, "Wb"> {};
-
-struct yoctoweber : prefixed_unit<yoctoweber, yocto, weber> {};
-struct zeptoweber : prefixed_unit<zeptoweber, zepto, weber> {};
-struct attoweber : prefixed_unit<attoweber, atto, weber> {};
-struct femtoweber : prefixed_unit<femtoweber, femto, weber> {};
-struct picoweber : prefixed_unit<picoweber, pico, weber> {};
-struct nanoweber : prefixed_unit<nanoweber, nano, weber> {};
-struct microweber : prefixed_unit<microweber, micro, weber> {};
-struct milliweber : prefixed_unit<milliweber, milli, weber> {};
-struct kiloweber : prefixed_unit<kiloweber, kilo, weber> {};
-struct megaweber : prefixed_unit<megaweber, mega, weber> {};
-struct gigaweber : prefixed_unit<gigaweber, giga, weber> {};
-struct teraweber : prefixed_unit<teraweber, tera, weber> {};
-struct petaweber : prefixed_unit<petaweber, peta, weber> {};
-struct exaweber : prefixed_unit<exaweber, exa, weber> {};
-struct zettaweber : prefixed_unit<zettaweber, zetta, weber> {};
-struct yottaweber : prefixed_unit<yottaweber, yotta, weber> {};
-
-struct dim_magnetic_flux : isq::dim_magnetic_flux<dim_magnetic_flux, weber, dim_magnetic_induction, dim_area> {};
-
-template<UnitOf<dim_magnetic_flux> U, Representation Rep = double>
-using magnetic_flux = quantity<dim_magnetic_flux, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// Wb
-constexpr auto operator"" _q_Wb(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return magnetic_flux<weber, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Wb(long double l) { return magnetic_flux<weber, long double>(l); }
-
-// yWb
-constexpr auto operator"" _q_yWb(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return magnetic_flux<yoctoweber, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_yWb(long double l) { return magnetic_flux<yoctoweber, long double>(l); }
-
-// zWb
-constexpr auto operator"" _q_zWb(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return magnetic_flux<zeptoweber, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_zWb(long double l) { return magnetic_flux<zeptoweber, long double>(l); }
-
-// aWb
-constexpr auto operator"" _q_aWb(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return magnetic_flux<attoweber, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_aWb(long double l) { return magnetic_flux<attoweber, long double>(l); }
-
-// fWb
-constexpr auto operator"" _q_fWb(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return magnetic_flux<femtoweber, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_fWb(long double l) { return magnetic_flux<femtoweber, long double>(l); }
-
-// pWb
-constexpr auto operator"" _q_pWb(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return magnetic_flux<picoweber, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_pWb(long double l) { return magnetic_flux<picoweber, long double>(l); }
-
-// nWb
-constexpr auto operator"" _q_nWb(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return magnetic_flux<nanoweber, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_nWb(long double l) { return magnetic_flux<nanoweber, long double>(l); }
-
-// µWb
-constexpr auto operator"" _q_uWb(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return magnetic_flux<microweber, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_uWb(long double l) { return magnetic_flux<microweber, long double>(l); }
-
-// mWb
-constexpr auto operator"" _q_mWb(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return magnetic_flux<milliweber, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_mWb(long double l) { return magnetic_flux<milliweber, long double>(l); }
-
-// kWb
-constexpr auto operator"" _q_kWb(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return magnetic_flux<kiloweber, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_kWb(long double l) { return magnetic_flux<kiloweber, long double>(l); }
-
-// MWb
-constexpr auto operator"" _q_MWb(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return magnetic_flux<megaweber, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_MWb(long double l) { return magnetic_flux<megaweber, long double>(l); }
-
-// GWb
-constexpr auto operator"" _q_GWb(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return magnetic_flux<gigaweber, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_GWb(long double l) { return magnetic_flux<gigaweber, long double>(l); }
-
-// TWb
-constexpr auto operator"" _q_TWb(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return magnetic_flux<teraweber, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_TWb(long double l) { return magnetic_flux<teraweber, long double>(l); }
-
-// PWb
-constexpr auto operator"" _q_PWb(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return magnetic_flux<petaweber, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_PWb(long double l) { return magnetic_flux<petaweber, long double>(l); }
-
-// EWb
-constexpr auto operator"" _q_EWb(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return magnetic_flux<exaweber, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_EWb(long double l) { return magnetic_flux<exaweber, long double>(l); }
-
-// ZWb
-constexpr auto operator"" _q_ZWb(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return magnetic_flux<zettaweber, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_ZWb(long double l) { return magnetic_flux<zettaweber, long double>(l); }
-
-// YWb
-constexpr auto operator"" _q_YWb(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return magnetic_flux<yottaweber, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_YWb(long double l) { return magnetic_flux<yottaweber, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-#ifndef UNITS_NO_REFERENCES
-
-namespace magnetic_flux_references {
-
-inline constexpr auto Wb = reference<dim_magnetic_flux, weber>{};
-inline constexpr auto yWb = reference<dim_magnetic_flux, yoctoweber>{};
-inline constexpr auto zWb = reference<dim_magnetic_flux, zeptoweber>{};
-inline constexpr auto aWb = reference<dim_magnetic_flux, attoweber>{};
-inline constexpr auto fWb = reference<dim_magnetic_flux, femtoweber>{};
-inline constexpr auto pWb = reference<dim_magnetic_flux, picoweber>{};
-inline constexpr auto nWb = reference<dim_magnetic_flux, nanoweber>{};
-inline constexpr auto uWb = reference<dim_magnetic_flux, microweber>{};
-inline constexpr auto mWb = reference<dim_magnetic_flux, milliweber>{};
-inline constexpr auto kWb = reference<dim_magnetic_flux, kiloweber>{};
-inline constexpr auto MWb = reference<dim_magnetic_flux, megaweber>{};
-inline constexpr auto GWb = reference<dim_magnetic_flux, gigaweber>{};
-inline constexpr auto TWb = reference<dim_magnetic_flux, teraweber>{};
-inline constexpr auto PWb = reference<dim_magnetic_flux, petaweber>{};
-inline constexpr auto EWb = reference<dim_magnetic_flux, exaweber>{};
-inline constexpr auto ZWb = reference<dim_magnetic_flux, zettaweber>{};
-inline constexpr auto YWb = reference<dim_magnetic_flux, yottaweber>{};
-
-}  // namespace magnetic_flux_references
-
-namespace references {
-
-using namespace magnetic_flux_references;
-
-}  // namespace references
-
-#endif  // UNITS_NO_REFERENCES
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::inline magnetic_flux {
-
-template<Representation Rep = double>
-using Wb = units::isq::si::magnetic_flux<units::isq::si::weber, Rep>;
-template<Representation Rep = double>
-using yWb = units::isq::si::magnetic_flux<units::isq::si::yoctoweber, Rep>;
-template<Representation Rep = double>
-using zWb = units::isq::si::magnetic_flux<units::isq::si::zeptoweber, Rep>;
-template<Representation Rep = double>
-using aWb = units::isq::si::magnetic_flux<units::isq::si::attoweber, Rep>;
-template<Representation Rep = double>
-using fWb = units::isq::si::magnetic_flux<units::isq::si::femtoweber, Rep>;
-template<Representation Rep = double>
-using pWb = units::isq::si::magnetic_flux<units::isq::si::picoweber, Rep>;
-template<Representation Rep = double>
-using nWb = units::isq::si::magnetic_flux<units::isq::si::nanoweber, Rep>;
-template<Representation Rep = double>
-using uWb = units::isq::si::magnetic_flux<units::isq::si::microweber, Rep>;
-template<Representation Rep = double>
-using mWb = units::isq::si::magnetic_flux<units::isq::si::milliweber, Rep>;
-template<Representation Rep = double>
-using kWb = units::isq::si::magnetic_flux<units::isq::si::kiloweber, Rep>;
-template<Representation Rep = double>
-using MWb = units::isq::si::magnetic_flux<units::isq::si::megaweber, Rep>;
-template<Representation Rep = double>
-using GWb = units::isq::si::magnetic_flux<units::isq::si::gigaweber, Rep>;
-template<Representation Rep = double>
-using TWb = units::isq::si::magnetic_flux<units::isq::si::teraweber, Rep>;
-template<Representation Rep = double>
-using PWb = units::isq::si::magnetic_flux<units::isq::si::petaweber, Rep>;
-template<Representation Rep = double>
-using EWb = units::isq::si::magnetic_flux<units::isq::si::exaweber, Rep>;
-template<Representation Rep = double>
-using ZWb = units::isq::si::magnetic_flux<units::isq::si::zettaweber, Rep>;
-template<Representation Rep = double>
-using YWb = units::isq::si::magnetic_flux<units::isq::si::yottaweber, Rep>;
-
-}  // namespace units::aliases::isq::si::inline magnetic_flux
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/magnetic_induction.h b/src/systems/si/include/units/isq/si/magnetic_induction.h
deleted file mode 100644
index 529a7f9a..00000000
--- a/src/systems/si/include/units/isq/si/magnetic_induction.h
+++ /dev/null
@@ -1,297 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/magnetic_induction.h>
-#include <units/quantity.h>
-#include <units/reference.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/length.h>
-#include <units/isq/si/prefixes.h>
-#include <units/isq/si/time.h>
-#include <units/isq/si/voltage.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct tesla : named_unit<tesla, "T"> {};
-
-struct yoctotesla : prefixed_unit<yoctotesla, yocto, tesla> {};
-struct zeptotesla : prefixed_unit<zeptotesla, zepto, tesla> {};
-struct attotesla : prefixed_unit<attotesla, atto, tesla> {};
-struct femtotesla : prefixed_unit<femtotesla, femto, tesla> {};
-struct picotesla : prefixed_unit<picotesla, pico, tesla> {};
-struct nanotesla : prefixed_unit<nanotesla, nano, tesla> {};
-struct microtesla : prefixed_unit<microtesla, micro, tesla> {};
-struct millitesla : prefixed_unit<millitesla, milli, tesla> {};
-struct kilotesla : prefixed_unit<kilotesla, kilo, tesla> {};
-struct megatesla : prefixed_unit<megatesla, mega, tesla> {};
-struct gigatesla : prefixed_unit<gigatesla, giga, tesla> {};
-struct teratesla : prefixed_unit<teratesla, tera, tesla> {};
-struct petatesla : prefixed_unit<petatesla, peta, tesla> {};
-struct exatesla : prefixed_unit<exatesla, exa, tesla> {};
-struct zettatesla : prefixed_unit<zettatesla, zetta, tesla> {};
-struct yottatesla : prefixed_unit<yottatesla, yotta, tesla> {};
-
-struct gauss : named_scaled_unit<gauss, "G", mag<ratio(1, 10'000)>(), tesla> {};
-
-struct dim_magnetic_induction :
-    isq::dim_magnetic_induction<dim_magnetic_induction, tesla, dim_voltage, dim_time, dim_length> {};
-
-template<UnitOf<dim_magnetic_induction> U, Representation Rep = double>
-using magnetic_induction = quantity<dim_magnetic_induction, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// T
-constexpr auto operator"" _q_T(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return magnetic_induction<tesla, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_T(long double l) { return magnetic_induction<tesla, long double>(l); }
-
-// yT
-constexpr auto operator"" _q_yT(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return magnetic_induction<yoctotesla, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_yT(long double l) { return magnetic_induction<yoctotesla, long double>(l); }
-
-// zT
-constexpr auto operator"" _q_zT(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return magnetic_induction<zeptotesla, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_zT(long double l) { return magnetic_induction<zeptotesla, long double>(l); }
-
-// aT
-constexpr auto operator"" _q_aT(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return magnetic_induction<attotesla, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_aT(long double l) { return magnetic_induction<attotesla, long double>(l); }
-
-// fT
-constexpr auto operator"" _q_fT(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return magnetic_induction<femtotesla, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_fT(long double l) { return magnetic_induction<femtotesla, long double>(l); }
-
-// pT
-constexpr auto operator"" _q_pT(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return magnetic_induction<picotesla, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_pT(long double l) { return magnetic_induction<picotesla, long double>(l); }
-
-// nT
-constexpr auto operator"" _q_nT(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return magnetic_induction<nanotesla, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_nT(long double l) { return magnetic_induction<nanotesla, long double>(l); }
-
-// µT
-constexpr auto operator"" _q_uT(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return magnetic_induction<microtesla, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_uT(long double l) { return magnetic_induction<microtesla, long double>(l); }
-
-// mT
-constexpr auto operator"" _q_mT(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return magnetic_induction<millitesla, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_mT(long double l) { return magnetic_induction<millitesla, long double>(l); }
-
-// kT
-constexpr auto operator"" _q_kT(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return magnetic_induction<kilotesla, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_kT(long double l) { return magnetic_induction<kilotesla, long double>(l); }
-
-// MT
-constexpr auto operator"" _q_MT(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return magnetic_induction<megatesla, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_MT(long double l) { return magnetic_induction<megatesla, long double>(l); }
-
-// GT
-constexpr auto operator"" _q_GT(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return magnetic_induction<gigatesla, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_GT(long double l) { return magnetic_induction<gigatesla, long double>(l); }
-
-// TT
-constexpr auto operator"" _q_TT(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return magnetic_induction<teratesla, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_TT(long double l) { return magnetic_induction<teratesla, long double>(l); }
-
-// PT
-constexpr auto operator"" _q_PT(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return magnetic_induction<petatesla, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_PT(long double l) { return magnetic_induction<petatesla, long double>(l); }
-
-// ET
-constexpr auto operator"" _q_ET(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return magnetic_induction<exatesla, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_ET(long double l) { return magnetic_induction<exatesla, long double>(l); }
-
-// ZT
-constexpr auto operator"" _q_ZT(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return magnetic_induction<zettatesla, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_ZT(long double l) { return magnetic_induction<zettatesla, long double>(l); }
-
-// YT
-constexpr auto operator"" _q_YT(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return magnetic_induction<yottatesla, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_YT(long double l) { return magnetic_induction<yottatesla, long double>(l); }
-
-// G
-constexpr auto operator"" _q_G(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return magnetic_induction<gauss, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_G(long double l) { return magnetic_induction<gauss, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-#ifndef UNITS_NO_REFERENCES
-
-namespace magnetic_induction_references {
-
-inline constexpr auto T = reference<dim_magnetic_induction, tesla>{};
-inline constexpr auto yT = reference<dim_magnetic_induction, yoctotesla>{};
-inline constexpr auto zT = reference<dim_magnetic_induction, zeptotesla>{};
-inline constexpr auto aT = reference<dim_magnetic_induction, attotesla>{};
-inline constexpr auto fT = reference<dim_magnetic_induction, femtotesla>{};
-inline constexpr auto pT = reference<dim_magnetic_induction, picotesla>{};
-inline constexpr auto nT = reference<dim_magnetic_induction, nanotesla>{};
-inline constexpr auto uT = reference<dim_magnetic_induction, microtesla>{};
-inline constexpr auto mT = reference<dim_magnetic_induction, millitesla>{};
-inline constexpr auto kT = reference<dim_magnetic_induction, kilotesla>{};
-inline constexpr auto MT = reference<dim_magnetic_induction, megatesla>{};
-inline constexpr auto GT = reference<dim_magnetic_induction, gigatesla>{};
-inline constexpr auto TT = reference<dim_magnetic_induction, teratesla>{};
-inline constexpr auto PT = reference<dim_magnetic_induction, petatesla>{};
-inline constexpr auto ET = reference<dim_magnetic_induction, exatesla>{};
-inline constexpr auto ZT = reference<dim_magnetic_induction, zettatesla>{};
-inline constexpr auto YT = reference<dim_magnetic_induction, yottatesla>{};
-inline constexpr auto G = reference<dim_magnetic_induction, gauss>{};
-
-}  // namespace magnetic_induction_references
-
-namespace references {
-
-using namespace magnetic_induction_references;
-
-}  // namespace references
-
-#endif  // UNITS_NO_REFERENCES
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::inline magnetic_induction {
-
-template<Representation Rep = double>
-using T = units::isq::si::magnetic_induction<units::isq::si::tesla, Rep>;
-template<Representation Rep = double>
-using yT = units::isq::si::magnetic_induction<units::isq::si::yoctotesla, Rep>;
-template<Representation Rep = double>
-using zT = units::isq::si::magnetic_induction<units::isq::si::zeptotesla, Rep>;
-template<Representation Rep = double>
-using aT = units::isq::si::magnetic_induction<units::isq::si::attotesla, Rep>;
-template<Representation Rep = double>
-using fT = units::isq::si::magnetic_induction<units::isq::si::femtotesla, Rep>;
-template<Representation Rep = double>
-using pT = units::isq::si::magnetic_induction<units::isq::si::picotesla, Rep>;
-template<Representation Rep = double>
-using nT = units::isq::si::magnetic_induction<units::isq::si::nanotesla, Rep>;
-template<Representation Rep = double>
-using uT = units::isq::si::magnetic_induction<units::isq::si::microtesla, Rep>;
-template<Representation Rep = double>
-using mT = units::isq::si::magnetic_induction<units::isq::si::millitesla, Rep>;
-template<Representation Rep = double>
-using kT = units::isq::si::magnetic_induction<units::isq::si::kilotesla, Rep>;
-template<Representation Rep = double>
-using MT = units::isq::si::magnetic_induction<units::isq::si::megatesla, Rep>;
-template<Representation Rep = double>
-using GT = units::isq::si::magnetic_induction<units::isq::si::gigatesla, Rep>;
-template<Representation Rep = double>
-using TT = units::isq::si::magnetic_induction<units::isq::si::teratesla, Rep>;
-template<Representation Rep = double>
-using PT = units::isq::si::magnetic_induction<units::isq::si::petatesla, Rep>;
-template<Representation Rep = double>
-using ET = units::isq::si::magnetic_induction<units::isq::si::exatesla, Rep>;
-template<Representation Rep = double>
-using ZT = units::isq::si::magnetic_induction<units::isq::si::zettatesla, Rep>;
-template<Representation Rep = double>
-using YT = units::isq::si::magnetic_induction<units::isq::si::yottatesla, Rep>;
-template<Representation Rep = double>
-using G = units::isq::si::magnetic_induction<units::isq::si::gauss, Rep>;
-
-}  // namespace units::aliases::isq::si::inline magnetic_induction
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/mass.h b/src/systems/si/include/units/isq/si/mass.h
deleted file mode 100644
index d57069d8..00000000
--- a/src/systems/si/include/units/isq/si/mass.h
+++ /dev/null
@@ -1,595 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/mass.h>
-#include <units/quantity.h>
-#include <units/reference.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/prefixes.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct gram : named_unit<gram, "g"> {};
-struct yoctogram : prefixed_unit<yoctogram, yocto, gram> {};
-struct zeptogram : prefixed_unit<zeptogram, zepto, gram> {};
-struct attogram : prefixed_unit<attogram, atto, gram> {};
-struct femtogram : prefixed_unit<femtogram, femto, gram> {};
-struct picogram : prefixed_unit<picogram, pico, gram> {};
-struct nanogram : prefixed_unit<nanogram, nano, gram> {};
-struct microgram : prefixed_unit<microgram, micro, gram> {};
-struct milligram : prefixed_unit<milligram, milli, gram> {};
-struct centigram : prefixed_unit<centigram, centi, gram> {};
-struct decigram : prefixed_unit<decigram, deci, gram> {};
-struct decagram : prefixed_unit<decagram, deca, gram> {};
-struct hectogram : prefixed_unit<hectogram, hecto, gram> {};
-struct kilogram : prefixed_unit<kilogram, kilo, gram> {};
-struct megagram : prefixed_unit<megagram, mega, gram> {};
-struct gigagram : prefixed_unit<gigagram, giga, gram> {};
-struct teragram : prefixed_unit<teragram, tera, gram> {};
-struct petagram : prefixed_unit<petagram, peta, gram> {};
-struct exagram : prefixed_unit<exagram, exa, gram> {};
-struct zettagram : prefixed_unit<zettagram, zetta, gram> {};
-struct yottagram : prefixed_unit<yottagram, yotta, gram> {};
-
-struct tonne : alias_unit<megagram, "t"> {};
-struct yoctotonne : prefixed_alias_unit<attogram, yocto, tonne> {};
-struct zeptotonne : prefixed_alias_unit<femtogram, zepto, tonne> {};
-struct attotonne : prefixed_alias_unit<picogram, atto, tonne> {};
-struct femtotonne : prefixed_alias_unit<nanogram, femto, tonne> {};
-struct picotonne : prefixed_alias_unit<microgram, pico, tonne> {};
-struct nanotonne : prefixed_alias_unit<milligram, nano, tonne> {};
-struct microtonne : prefixed_alias_unit<gram, micro, tonne> {};
-struct millitonne : prefixed_alias_unit<kilogram, milli, tonne> {};
-struct centitonne : prefixed_unit<centitonne, centi, tonne> {};
-struct decitonne : prefixed_unit<decitonne, deci, tonne> {};
-struct decatonne : prefixed_unit<decatonne, deca, tonne> {};
-struct hectotonne : prefixed_unit<hectotonne, hecto, tonne> {};
-struct kilotonne : prefixed_alias_unit<gigagram, kilo, tonne> {};
-struct megatonne : prefixed_alias_unit<teragram, mega, tonne> {};
-struct gigatonne : prefixed_alias_unit<petagram, giga, tonne> {};
-struct teratonne : prefixed_alias_unit<exagram, tera, tonne> {};
-struct petatonne : prefixed_alias_unit<zettagram, peta, tonne> {};
-struct exatonne : prefixed_alias_unit<yottagram, exa, tonne> {};
-struct zettatonne : prefixed_unit<zettatonne, zetta, tonne> {};
-struct yottatonne : prefixed_unit<yottatonne, yotta, tonne> {};
-
-struct dalton :
-    named_scaled_unit<dalton, "Da", mag<ratio(16'605'390'666'050, 10'000'000'000'000)>() * mag_power<10, -27>(),
-                      kilogram> {};
-
-struct dim_mass : isq::dim_mass<kilogram> {};
-
-template<UnitOf<dim_mass> U, Representation Rep = double>
-using mass = quantity<dim_mass, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// g
-constexpr auto operator"" _q_g(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<gram, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_g(long double l) { return mass<gram, long double>(l); }
-
-// yg
-constexpr auto operator"" _q_yg(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<yoctogram, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_yg(long double l) { return mass<yoctogram, long double>(l); }
-
-// zg
-constexpr auto operator"" _q_zg(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<zeptogram, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_zg(long double l) { return mass<zeptogram, long double>(l); }
-
-// ag
-constexpr auto operator"" _q_ag(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<attogram, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_ag(long double l) { return mass<attogram, long double>(l); }
-
-// fg
-constexpr auto operator"" _q_fg(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<femtogram, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_fg(long double l) { return mass<femtogram, long double>(l); }
-
-// pg
-constexpr auto operator"" _q_pg(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<picogram, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_pg(long double l) { return mass<picogram, long double>(l); }
-
-// ng
-constexpr auto operator"" _q_ng(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<nanogram, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_ng(long double l) { return mass<nanogram, long double>(l); }
-
-// ug
-constexpr auto operator"" _q_ug(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<microgram, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_ug(long double l) { return mass<microgram, long double>(l); }
-
-// mg
-constexpr auto operator"" _q_mg(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<milligram, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_mg(long double l) { return mass<milligram, long double>(l); }
-
-// cg
-constexpr auto operator"" _q_cg(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<centigram, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_cg(long double l) { return mass<centigram, long double>(l); }
-
-// dg
-constexpr auto operator"" _q_dg(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<decigram, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_dg(long double l) { return mass<decigram, long double>(l); }
-
-// dag
-constexpr auto operator"" _q_dag(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<decagram, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_dag(long double l) { return mass<decagram, long double>(l); }
-
-// hg
-constexpr auto operator"" _q_hg(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<hectogram, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_hg(long double l) { return mass<hectogram, long double>(l); }
-
-// kg
-constexpr auto operator"" _q_kg(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<kilogram, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_kg(long double l) { return mass<kilogram, long double>(l); }
-
-// Mg
-constexpr auto operator"" _q_Mg(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<megagram, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Mg(long double l) { return mass<megagram, long double>(l); }
-
-// Gg
-constexpr auto operator"" _q_Gg(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<gigagram, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Gg(long double l) { return mass<gigagram, long double>(l); }
-
-// Tg
-constexpr auto operator"" _q_Tg(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<teragram, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Tg(long double l) { return mass<teragram, long double>(l); }
-
-// Pg
-constexpr auto operator"" _q_Pg(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<petagram, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Pg(long double l) { return mass<petagram, long double>(l); }
-
-// Eg
-constexpr auto operator"" _q_Eg(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<exagram, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Eg(long double l) { return mass<exagram, long double>(l); }
-
-// Zg
-constexpr auto operator"" _q_Zg(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<zettagram, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Zg(long double l) { return mass<zettagram, long double>(l); }
-
-// Yg
-constexpr auto operator"" _q_Yg(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<yottagram, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Yg(long double l) { return mass<yottagram, long double>(l); }
-
-// t
-constexpr auto operator"" _q_t(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<tonne, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_t(long double l) { return mass<tonne, long double>(l); }
-
-// yt
-constexpr auto operator"" _q_yt(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<yoctotonne, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_yt(long double l) { return mass<yoctotonne, long double>(l); }
-
-// zt
-constexpr auto operator"" _q_zt(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<zeptotonne, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_zt(long double l) { return mass<zeptotonne, long double>(l); }
-
-// at
-constexpr auto operator"" _q_at(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<attotonne, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_at(long double l) { return mass<attotonne, long double>(l); }
-
-// TODO Collides with foot
-// ft
-// constexpr auto operator"" _q_ft(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return
-// mass<femtotonne, std::int64_t>(static_cast<std::int64_t>(l)); } constexpr auto operator"" _q_ft(long double l) {
-// return mass<femtotonne, long double>(l); }
-
-// pt
-constexpr auto operator"" _q_pt(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<picotonne, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_pt(long double l) { return mass<picotonne, long double>(l); }
-
-// nt
-constexpr auto operator"" _q_nt(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<nanotonne, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_nt(long double l) { return mass<nanotonne, long double>(l); }
-
-// ut
-constexpr auto operator"" _q_ut(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<microtonne, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_ut(long double l) { return mass<microtonne, long double>(l); }
-
-// mt
-constexpr auto operator"" _q_mt(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<millitonne, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_mt(long double l) { return mass<millitonne, long double>(l); }
-
-// ct
-constexpr auto operator"" _q_ct(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<centitonne, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_ct(long double l) { return mass<centitonne, long double>(l); }
-
-// dt
-constexpr auto operator"" _q_dt(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<decitonne, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_dt(long double l) { return mass<decitonne, long double>(l); }
-
-// dat
-constexpr auto operator"" _q_dat(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<decatonne, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_dat(long double l) { return mass<decatonne, long double>(l); }
-
-// ht
-constexpr auto operator"" _q_ht(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<hectotonne, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_ht(long double l) { return mass<hectotonne, long double>(l); }
-
-// kt
-constexpr auto operator"" _q_kt(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<kilotonne, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_kt(long double l) { return mass<kilotonne, long double>(l); }
-
-// Mt
-constexpr auto operator"" _q_Mt(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<megatonne, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Mt(long double l) { return mass<megatonne, long double>(l); }
-
-// Gt
-constexpr auto operator"" _q_Gt(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<gigatonne, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Gt(long double l) { return mass<gigatonne, long double>(l); }
-
-// Tt
-constexpr auto operator"" _q_Tt(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<teratonne, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Tt(long double l) { return mass<teratonne, long double>(l); }
-
-// Pt
-constexpr auto operator"" _q_Pt(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<petatonne, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Pt(long double l) { return mass<petatonne, long double>(l); }
-
-// Et
-constexpr auto operator"" _q_Et(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<exatonne, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Et(long double l) { return mass<exatonne, long double>(l); }
-
-// Zt
-constexpr auto operator"" _q_Zt(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<zettatonne, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Zt(long double l) { return mass<zettatonne, long double>(l); }
-
-// Yt
-constexpr auto operator"" _q_Yt(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<yottatonne, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Yt(long double l) { return mass<yottatonne, long double>(l); }
-
-// Da
-constexpr auto operator"" _q_Da(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return mass<dalton, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Da(long double l) { return mass<dalton, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-#ifndef UNITS_NO_REFERENCES
-
-namespace mass_references {
-
-inline constexpr auto g = reference<dim_mass, gram>{};
-inline constexpr auto yg = reference<dim_mass, yoctogram>{};
-inline constexpr auto zg = reference<dim_mass, zeptogram>{};
-inline constexpr auto ag = reference<dim_mass, attogram>{};
-inline constexpr auto fg = reference<dim_mass, femtogram>{};
-inline constexpr auto pg = reference<dim_mass, picogram>{};
-inline constexpr auto ng = reference<dim_mass, nanogram>{};
-inline constexpr auto ug = reference<dim_mass, microgram>{};
-inline constexpr auto mg = reference<dim_mass, milligram>{};
-inline constexpr auto cg = reference<dim_mass, centigram>{};
-inline constexpr auto dg = reference<dim_mass, decigram>{};
-inline constexpr auto dag = reference<dim_mass, decagram>{};
-inline constexpr auto hg = reference<dim_mass, hectogram>{};
-inline constexpr auto kg = reference<dim_mass, kilogram>{};
-inline constexpr auto Mg = reference<dim_mass, megagram>{};
-inline constexpr auto Gg = reference<dim_mass, gigagram>{};
-inline constexpr auto Tg = reference<dim_mass, teragram>{};
-inline constexpr auto Pg = reference<dim_mass, petagram>{};
-inline constexpr auto Eg = reference<dim_mass, exagram>{};
-inline constexpr auto Zg = reference<dim_mass, zettagram>{};
-inline constexpr auto Yg = reference<dim_mass, yottagram>{};
-
-inline constexpr auto t = reference<dim_mass, tonne>{};
-inline constexpr auto yt = reference<dim_mass, yoctotonne>{};
-inline constexpr auto zt = reference<dim_mass, zeptotonne>{};
-inline constexpr auto at = reference<dim_mass, attotonne>{};
-inline constexpr auto ft = reference<dim_mass, femtotonne>{};
-inline constexpr auto pt = reference<dim_mass, picotonne>{};
-inline constexpr auto nt = reference<dim_mass, nanotonne>{};
-inline constexpr auto ut = reference<dim_mass, microtonne>{};
-inline constexpr auto mt = reference<dim_mass, millitonne>{};
-inline constexpr auto ct = reference<dim_mass, centitonne>{};
-inline constexpr auto dt = reference<dim_mass, decitonne>{};
-inline constexpr auto dat = reference<dim_mass, decatonne>{};
-inline constexpr auto ht = reference<dim_mass, hectotonne>{};
-inline constexpr auto kt = reference<dim_mass, kilotonne>{};
-inline constexpr auto Mt = reference<dim_mass, megatonne>{};
-inline constexpr auto Gt = reference<dim_mass, gigatonne>{};
-inline constexpr auto Tt = reference<dim_mass, teratonne>{};
-inline constexpr auto Pt = reference<dim_mass, petatonne>{};
-inline constexpr auto Et = reference<dim_mass, exatonne>{};
-inline constexpr auto Zt = reference<dim_mass, zettatonne>{};
-inline constexpr auto Yt = reference<dim_mass, yottatonne>{};
-inline constexpr auto Da = reference<dim_mass, dalton>{};
-
-}  // namespace mass_references
-
-namespace references {
-
-using namespace mass_references;
-
-}  // namespace references
-
-#endif  // UNITS_NO_REFERENCES
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::inline mass {
-
-template<Representation Rep = double>
-using g = units::isq::si::mass<units::isq::si::gram, Rep>;
-template<Representation Rep = double>
-using yg = units::isq::si::mass<units::isq::si::yoctogram, Rep>;
-template<Representation Rep = double>
-using zg = units::isq::si::mass<units::isq::si::zeptogram, Rep>;
-template<Representation Rep = double>
-using ag = units::isq::si::mass<units::isq::si::attogram, Rep>;
-template<Representation Rep = double>
-using fg = units::isq::si::mass<units::isq::si::femtogram, Rep>;
-template<Representation Rep = double>
-using pg = units::isq::si::mass<units::isq::si::picogram, Rep>;
-template<Representation Rep = double>
-using ng = units::isq::si::mass<units::isq::si::nanogram, Rep>;
-template<Representation Rep = double>
-using ug = units::isq::si::mass<units::isq::si::microgram, Rep>;
-template<Representation Rep = double>
-using mg = units::isq::si::mass<units::isq::si::milligram, Rep>;
-template<Representation Rep = double>
-using cg = units::isq::si::mass<units::isq::si::centigram, Rep>;
-template<Representation Rep = double>
-using dg = units::isq::si::mass<units::isq::si::decigram, Rep>;
-template<Representation Rep = double>
-using dag = units::isq::si::mass<units::isq::si::decagram, Rep>;
-template<Representation Rep = double>
-using hg = units::isq::si::mass<units::isq::si::hectogram, Rep>;
-template<Representation Rep = double>
-using kg = units::isq::si::mass<units::isq::si::kilogram, Rep>;
-template<Representation Rep = double>
-using Mg = units::isq::si::mass<units::isq::si::megagram, Rep>;
-template<Representation Rep = double>
-using Gg = units::isq::si::mass<units::isq::si::gigagram, Rep>;
-template<Representation Rep = double>
-using Tg = units::isq::si::mass<units::isq::si::teragram, Rep>;
-template<Representation Rep = double>
-using Pg = units::isq::si::mass<units::isq::si::petagram, Rep>;
-template<Representation Rep = double>
-using Eg = units::isq::si::mass<units::isq::si::exagram, Rep>;
-template<Representation Rep = double>
-using Zg = units::isq::si::mass<units::isq::si::zettagram, Rep>;
-template<Representation Rep = double>
-using Yg = units::isq::si::mass<units::isq::si::yottagram, Rep>;
-
-template<Representation Rep = double>
-using t = units::isq::si::mass<units::isq::si::tonne, Rep>;
-template<Representation Rep = double>
-using yt = units::isq::si::mass<units::isq::si::yoctotonne, Rep>;
-template<Representation Rep = double>
-using zt = units::isq::si::mass<units::isq::si::zeptotonne, Rep>;
-template<Representation Rep = double>
-using at = units::isq::si::mass<units::isq::si::attotonne, Rep>;
-template<Representation Rep = double>
-using ft = units::isq::si::mass<units::isq::si::femtotonne, Rep>;
-template<Representation Rep = double>
-using pt = units::isq::si::mass<units::isq::si::picotonne, Rep>;
-template<Representation Rep = double>
-using nt = units::isq::si::mass<units::isq::si::nanotonne, Rep>;
-template<Representation Rep = double>
-using ut = units::isq::si::mass<units::isq::si::microtonne, Rep>;
-template<Representation Rep = double>
-using mt = units::isq::si::mass<units::isq::si::millitonne, Rep>;
-template<Representation Rep = double>
-using ct = units::isq::si::mass<units::isq::si::centitonne, Rep>;
-template<Representation Rep = double>
-using dt = units::isq::si::mass<units::isq::si::decitonne, Rep>;
-template<Representation Rep = double>
-using dat = units::isq::si::mass<units::isq::si::decatonne, Rep>;
-template<Representation Rep = double>
-using ht = units::isq::si::mass<units::isq::si::hectotonne, Rep>;
-template<Representation Rep = double>
-using kt = units::isq::si::mass<units::isq::si::kilotonne, Rep>;
-template<Representation Rep = double>
-using Mt = units::isq::si::mass<units::isq::si::megatonne, Rep>;
-template<Representation Rep = double>
-using Gt = units::isq::si::mass<units::isq::si::gigatonne, Rep>;
-template<Representation Rep = double>
-using Tt = units::isq::si::mass<units::isq::si::teratonne, Rep>;
-template<Representation Rep = double>
-using Pt = units::isq::si::mass<units::isq::si::petatonne, Rep>;
-template<Representation Rep = double>
-using Et = units::isq::si::mass<units::isq::si::exatonne, Rep>;
-template<Representation Rep = double>
-using Zt = units::isq::si::mass<units::isq::si::zettatonne, Rep>;
-template<Representation Rep = double>
-using Yt = units::isq::si::mass<units::isq::si::yottatonne, Rep>;
-template<Representation Rep = double>
-using Da = units::isq::si::mass<units::isq::si::dalton, Rep>;
-
-}  // namespace units::aliases::isq::si::inline mass
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/molar_energy.h b/src/systems/si/include/units/isq/si/molar_energy.h
deleted file mode 100644
index 02cb9072..00000000
--- a/src/systems/si/include/units/isq/si/molar_energy.h
+++ /dev/null
@@ -1,73 +0,0 @@
-// The MIT License (MIT)
-//
-// Hopyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOHTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OH ANY KIND, EXPRESS OR
-// IMPLIED, INHLUDING BUT NOT LIMITED TO THE WARRANTIES OH MERHHANTABILITY,
-// HITNESS HOR A PARTIHULAR PURPOSE AND NONINHRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR HOPYRIGHT HOLDERS BE LIABLE HOR ANY HLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN AHTION OH HONTRAHT, TORT OR OTHERWISE, ARISING HROM,
-// OUT OH OR IN HONNEHTION WITH THE SOHTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOHTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/molar_energy.h>
-#include <units/quantity.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/amount_of_substance.h>
-#include <units/isq/si/energy.h>
-#include <units/isq/si/prefixes.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct joule_per_mole : derived_unit<joule_per_mole> {};
-
-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>;
-
-#ifndef UNITS_NO_LITERALS
-
-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(long double l) { return molar_energy<joule_per_mole, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-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>;
-
-}  // namespace units::aliases::isq::si::inline molar_energy
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/momentum.h b/src/systems/si/include/units/isq/si/momentum.h
deleted file mode 100644
index 46446c92..00000000
--- a/src/systems/si/include/units/isq/si/momentum.h
+++ /dev/null
@@ -1,70 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/momentum.h>
-#include <units/quantity.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/mass.h>
-#include <units/isq/si/speed.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct kilogram_metre_per_second : derived_unit<kilogram_metre_per_second> {};
-struct dim_momentum : isq::dim_momentum<dim_momentum, kilogram_metre_per_second, dim_mass, dim_speed> {};
-
-template<UnitOf<dim_momentum> U, Representation Rep = double>
-using momentum = quantity<dim_momentum, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// kg*m/s
-constexpr auto operator"" _q_kg_m_per_s(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return momentum<kilogram_metre_per_second, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_kg_m_per_s(long double l) { return momentum<kilogram_metre_per_second, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::inline momentum {
-
-template<Representation Rep = double>
-using kg_m_per_s = units::isq::si::momentum<units::isq::si::kilogram_metre_per_second, Rep>;
-
-}  // namespace units::aliases::isq::si::inline momentum
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/permeability.h b/src/systems/si/include/units/isq/si/permeability.h
deleted file mode 100644
index 5b961b21..00000000
--- a/src/systems/si/include/units/isq/si/permeability.h
+++ /dev/null
@@ -1,71 +0,0 @@
-// The MIT License (MIT)
-//
-// Hopyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOHTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OH ANY KIND, EXPRESS OR
-// IMPLIED, INHLUDING BUT NOT LIMITED TO THE WARRANTIES OH MERHHANTABILITY,
-// HITNESS HOR A PARTIHULAR PURPOSE AND NONINHRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR HOPYRIGHT HOLDERS BE LIABLE HOR ANY HLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN AHTION OH HONTRAHT, TORT OR OTHERWISE, ARISING HROM,
-// OUT OH OR IN HONNEHTION WITH THE SOHTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOHTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/permeability.h>
-#include <units/quantity.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/inductance.h>
-#include <units/isq/si/prefixes.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct henry_per_metre : derived_unit<henry_per_metre> {};
-
-struct dim_permeability : isq::dim_permeability<dim_permeability, henry_per_metre, dim_inductance, dim_length> {};
-
-template<UnitOf<dim_permeability> U, Representation Rep = double>
-using permeability = quantity<dim_permeability, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// H/m
-constexpr auto operator"" _q_H_per_m(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return permeability<henry_per_metre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_H_per_m(long double l) { return permeability<henry_per_metre, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::inline permeability {
-
-template<Representation Rep = double>
-using H_per_m = units::isq::si::permeability<units::isq::si::henry_per_metre, Rep>;
-
-}  // namespace units::aliases::isq::si::inline permeability
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/permittivity.h b/src/systems/si/include/units/isq/si/permittivity.h
deleted file mode 100644
index cd99be6c..00000000
--- a/src/systems/si/include/units/isq/si/permittivity.h
+++ /dev/null
@@ -1,71 +0,0 @@
-// The MIT License (MIT)
-//
-// Fopyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INFLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERFHANTABILITY,
-// FITNESS FOR A PARTIFULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR FOPYRIGHT HOLDERS BE LIABLE FOR ANY FLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN AFTION OF FONTRAFT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN FONNEFTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/permittivity.h>
-#include <units/quantity.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/capacitance.h>
-#include <units/isq/si/prefixes.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct farad_per_metre : derived_unit<farad_per_metre> {};
-
-struct dim_permittivity : isq::dim_permittivity<dim_permittivity, farad_per_metre, dim_capacitance, dim_length> {};
-
-template<UnitOf<dim_permittivity> U, Representation Rep = double>
-using permittivity = quantity<dim_permittivity, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// F/m
-constexpr auto operator"" _q_F_per_m(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return permittivity<farad_per_metre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_F_per_m(long double l) { return permittivity<farad_per_metre, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::inline permittivity {
-
-template<Representation Rep = double>
-using F_per_m = units::isq::si::permittivity<units::isq::si::farad_per_metre, Rep>;
-
-}  // namespace units::aliases::isq::si::inline permittivity
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/power.h b/src/systems/si/include/units/isq/si/power.h
deleted file mode 100644
index d95d5c30..00000000
--- a/src/systems/si/include/units/isq/si/power.h
+++ /dev/null
@@ -1,280 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/power.h>
-#include <units/quantity.h>
-#include <units/reference.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/energy.h>
-#include <units/isq/si/prefixes.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct watt : named_unit<watt, "W"> {};
-struct yoctowatt : prefixed_unit<yoctowatt, yocto, watt> {};
-struct zeptowatt : prefixed_unit<zeptowatt, zepto, watt> {};
-struct attowatt : prefixed_unit<attowatt, atto, watt> {};
-struct femtowatt : prefixed_unit<femtowatt, femto, watt> {};
-struct picowatt : prefixed_unit<picowatt, pico, watt> {};
-struct nanowatt : prefixed_unit<nanowatt, nano, watt> {};
-struct microwatt : prefixed_unit<microwatt, micro, watt> {};
-struct milliwatt : prefixed_unit<milliwatt, milli, watt> {};
-struct kilowatt : prefixed_unit<kilowatt, kilo, watt> {};
-struct megawatt : prefixed_unit<megawatt, mega, watt> {};
-struct gigawatt : prefixed_unit<gigawatt, giga, watt> {};
-struct terawatt : prefixed_unit<terawatt, tera, watt> {};
-struct petawatt : prefixed_unit<petawatt, peta, watt> {};
-struct exawatt : prefixed_unit<exawatt, exa, watt> {};
-struct zettawatt : prefixed_unit<zettawatt, zetta, watt> {};
-struct yottawatt : prefixed_unit<yottawatt, yotta, watt> {};
-
-struct dim_power : isq::dim_power<dim_power, watt, dim_energy, dim_time> {};
-
-template<UnitOf<dim_power> U, Representation Rep = double>
-using power = quantity<dim_power, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// W
-constexpr auto operator"" _q_W(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return power<watt, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_W(long double l) { return power<watt, long double>(l); }
-
-// yW
-constexpr auto operator"" _q_yW(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return power<yoctowatt, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_yW(long double l) { return power<yoctowatt, long double>(l); }
-
-// zW
-constexpr auto operator"" _q_zW(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return power<zeptowatt, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_zW(long double l) { return power<zeptowatt, long double>(l); }
-
-// aW
-constexpr auto operator"" _q_aW(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return power<attowatt, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_aW(long double l) { return power<attowatt, long double>(l); }
-
-// fW
-constexpr auto operator"" _q_fW(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return power<femtowatt, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_fW(long double l) { return power<femtowatt, long double>(l); }
-
-// pW
-constexpr auto operator"" _q_pW(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return power<picowatt, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_pW(long double l) { return power<picowatt, long double>(l); }
-
-// nW
-constexpr auto operator"" _q_nW(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return power<nanowatt, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_nW(long double l) { return power<nanowatt, long double>(l); }
-
-// uW
-constexpr auto operator"" _q_uW(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return power<microwatt, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_uW(long double l) { return power<microwatt, long double>(l); }
-
-// mW
-constexpr auto operator"" _q_mW(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return power<milliwatt, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_mW(long double l) { return power<milliwatt, long double>(l); }
-
-// kW
-constexpr auto operator"" _q_kW(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return power<kilowatt, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_kW(long double l) { return power<kilowatt, long double>(l); }
-
-// MW
-constexpr auto operator"" _q_MW(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return power<megawatt, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_MW(long double l) { return power<megawatt, long double>(l); }
-
-// GW
-constexpr auto operator"" _q_GW(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return power<gigawatt, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_GW(long double l) { return power<gigawatt, long double>(l); }
-
-// TW
-constexpr auto operator"" _q_TW(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return power<terawatt, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_TW(long double l) { return power<terawatt, long double>(l); }
-
-// PW
-constexpr auto operator"" _q_PW(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return power<petawatt, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_PW(long double l) { return power<petawatt, long double>(l); }
-
-// EW
-constexpr auto operator"" _q_EW(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return power<exawatt, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_EW(long double l) { return power<exawatt, long double>(l); }
-
-// ZW
-constexpr auto operator"" _q_ZW(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return power<zettawatt, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_ZW(long double l) { return power<zettawatt, long double>(l); }
-
-// YW
-constexpr auto operator"" _q_YW(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return power<yottawatt, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_YW(long double l) { return power<yottawatt, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-#ifndef UNITS_NO_REFERENCES
-
-namespace power_references {
-
-inline constexpr auto W = reference<dim_power, watt>{};
-inline constexpr auto yW = reference<dim_power, yoctowatt>{};
-inline constexpr auto zW = reference<dim_power, zeptowatt>{};
-inline constexpr auto aW = reference<dim_power, attowatt>{};
-inline constexpr auto fW = reference<dim_power, femtowatt>{};
-inline constexpr auto pW = reference<dim_power, picowatt>{};
-inline constexpr auto nW = reference<dim_power, nanowatt>{};
-inline constexpr auto uW = reference<dim_power, microwatt>{};
-inline constexpr auto mW = reference<dim_power, milliwatt>{};
-inline constexpr auto kW = reference<dim_power, kilowatt>{};
-inline constexpr auto MW = reference<dim_power, megawatt>{};
-inline constexpr auto GW = reference<dim_power, gigawatt>{};
-inline constexpr auto TW = reference<dim_power, terawatt>{};
-inline constexpr auto PW = reference<dim_power, petawatt>{};
-inline constexpr auto EW = reference<dim_power, exawatt>{};
-inline constexpr auto ZW = reference<dim_power, zettawatt>{};
-inline constexpr auto YW = reference<dim_power, yottawatt>{};
-
-}  // namespace power_references
-
-namespace references {
-
-using namespace power_references;
-
-}  // namespace references
-
-#endif  // UNITS_NO_REFERENCES
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::inline power {
-
-template<Representation Rep = double>
-using W = units::isq::si::power<units::isq::si::watt, Rep>;
-template<Representation Rep = double>
-using yW = units::isq::si::power<units::isq::si::yoctowatt, Rep>;
-template<Representation Rep = double>
-using zW = units::isq::si::power<units::isq::si::zeptowatt, Rep>;
-template<Representation Rep = double>
-using aW = units::isq::si::power<units::isq::si::attowatt, Rep>;
-template<Representation Rep = double>
-using fW = units::isq::si::power<units::isq::si::femtowatt, Rep>;
-template<Representation Rep = double>
-using pW = units::isq::si::power<units::isq::si::picowatt, Rep>;
-template<Representation Rep = double>
-using nW = units::isq::si::power<units::isq::si::nanowatt, Rep>;
-template<Representation Rep = double>
-using uW = units::isq::si::power<units::isq::si::microwatt, Rep>;
-template<Representation Rep = double>
-using mW = units::isq::si::power<units::isq::si::milliwatt, Rep>;
-template<Representation Rep = double>
-using kW = units::isq::si::power<units::isq::si::kilowatt, Rep>;
-template<Representation Rep = double>
-using MW = units::isq::si::power<units::isq::si::megawatt, Rep>;
-template<Representation Rep = double>
-using GW = units::isq::si::power<units::isq::si::gigawatt, Rep>;
-template<Representation Rep = double>
-using TW = units::isq::si::power<units::isq::si::terawatt, Rep>;
-template<Representation Rep = double>
-using PW = units::isq::si::power<units::isq::si::petawatt, Rep>;
-template<Representation Rep = double>
-using EW = units::isq::si::power<units::isq::si::exawatt, Rep>;
-template<Representation Rep = double>
-using ZW = units::isq::si::power<units::isq::si::zettawatt, Rep>;
-template<Representation Rep = double>
-using YW = units::isq::si::power<units::isq::si::yottawatt, Rep>;
-
-}  // namespace units::aliases::isq::si::inline power
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/prefixes.h b/src/systems/si/include/units/isq/si/prefixes.h
deleted file mode 100644
index 5ecd21e6..00000000
--- a/src/systems/si/include/units/isq/si/prefixes.h
+++ /dev/null
@@ -1,70 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-template<NamedUnit auto U>
-struct yocto : prefixed_unit<"y", mag_power<10, -24>, U> {};
-template<NamedUnit auto U>
-struct zepto : prefixed_unit<"z", mag_power<10, -21>, U> {};
-template<NamedUnit auto U>
-struct atto : prefixed_unit<"a", mag_power<10, -18>, U> {};
-template<NamedUnit auto U>
-struct femto : prefixed_unit<"f", mag_power<10, -15>, U> {};
-template<NamedUnit auto U>
-struct pico : prefixed_unit<"p", mag_power<10, -12>, U> {};
-template<NamedUnit auto U>
-struct nano : prefixed_unit<"n", mag_power<10, -9>, U> {};
-template<NamedUnit auto U>
-struct micro : prefixed_unit<basic_symbol_text{"\u00b5", "u"}, mag_power<10, -6>, U> {};
-template<NamedUnit auto U>
-struct milli : prefixed_unit<"m", mag_power<10, -3>, U> {};
-template<NamedUnit auto U>
-struct centi : prefixed_unit<"c", mag_power<10, -2>, U> {};
-template<NamedUnit auto U>
-struct deci : prefixed_unit<"d", mag_power<10, -1>, U> {};
-template<NamedUnit auto U>
-struct deca : prefixed_unit<"da", mag_power<10, 1>, U> {};
-template<NamedUnit auto U>
-struct hecto : prefixed_unit<"h", mag_power<10, 2>, U> {};
-template<NamedUnit auto U>
-struct kilo : prefixed_unit<"k", mag_power<10, 3>, U> {};
-template<NamedUnit auto U>
-struct mega : prefixed_unit<"M", mag_power<10, 6>, U> {};
-template<NamedUnit auto U>
-struct giga : prefixed_unit<"G", mag_power<10, 9>, U> {};
-template<NamedUnit auto U>
-struct tera : prefixed_unit<"T", mag_power<10, 12>, U> {};
-template<NamedUnit auto U>
-struct peta : prefixed_unit<"P", mag_power<10, 15>, U> {};
-template<NamedUnit auto U>
-struct exa : prefixed_unit<"E", mag_power<10, 18>, U> {};
-template<NamedUnit auto U>
-struct zetta : prefixed_unit<"Z", mag_power<10, 21>, U> {};
-template<NamedUnit auto U>
-struct yotta : prefixed_unit<"Y", mag_power<10, 24>, U> {};
-
-}  // namespace units::isq::si
diff --git a/src/systems/si/include/units/isq/si/pressure.h b/src/systems/si/include/units/isq/si/pressure.h
deleted file mode 100644
index 86bed5d2..00000000
--- a/src/systems/si/include/units/isq/si/pressure.h
+++ /dev/null
@@ -1,329 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/pressure.h>
-#include <units/quantity.h>
-#include <units/reference.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/area.h>
-#include <units/isq/si/force.h>
-#include <units/isq/si/prefixes.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct pascal : named_unit<pascal, "Pa"> {};
-struct yoctopascal : prefixed_unit<yoctopascal, yocto, pascal> {};
-struct zeptopascal : prefixed_unit<zeptopascal, zepto, pascal> {};
-struct attopascal : prefixed_unit<attopascal, atto, pascal> {};
-struct femtopascal : prefixed_unit<femtopascal, femto, pascal> {};
-struct picopascal : prefixed_unit<picopascal, pico, pascal> {};
-struct nanopascal : prefixed_unit<nanopascal, nano, pascal> {};
-struct micropascal : prefixed_unit<micropascal, micro, pascal> {};
-struct millipascal : prefixed_unit<millipascal, milli, pascal> {};
-struct centipascal : prefixed_unit<centipascal, centi, pascal> {};
-struct decipascal : prefixed_unit<decipascal, deci, pascal> {};
-struct decapascal : prefixed_unit<decapascal, deca, pascal> {};
-struct hectopascal : prefixed_unit<hectopascal, hecto, pascal> {};
-struct kilopascal : prefixed_unit<kilopascal, kilo, pascal> {};
-struct megapascal : prefixed_unit<megapascal, mega, pascal> {};
-struct gigapascal : prefixed_unit<gigapascal, giga, pascal> {};
-struct terapascal : prefixed_unit<terapascal, tera, pascal> {};
-struct petapascal : prefixed_unit<petapascal, peta, pascal> {};
-struct exapascal : prefixed_unit<exapascal, exa, pascal> {};
-struct zettapascal : prefixed_unit<zettapascal, zetta, pascal> {};
-struct yottapascal : prefixed_unit<yottapascal, yotta, pascal> {};
-
-struct dim_pressure : isq::dim_pressure<dim_pressure, pascal, dim_force, dim_area> {};
-
-template<UnitOf<dim_pressure> U, Representation Rep = double>
-using pressure = quantity<dim_pressure, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(long double l) { return pressure<yottapascal, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-#ifndef UNITS_NO_REFERENCES
-
-namespace pressure_references {
-
-inline constexpr auto Pa = reference<dim_pressure, pascal>{};
-inline constexpr auto yPa = reference<dim_pressure, yoctopascal>{};
-inline constexpr auto zPa = reference<dim_pressure, zeptopascal>{};
-inline constexpr auto aPa = reference<dim_pressure, attopascal>{};
-inline constexpr auto fPa = reference<dim_pressure, femtopascal>{};
-inline constexpr auto pPa = reference<dim_pressure, picopascal>{};
-inline constexpr auto nPa = reference<dim_pressure, nanopascal>{};
-inline constexpr auto uPa = reference<dim_pressure, micropascal>{};
-inline constexpr auto mPa = reference<dim_pressure, millipascal>{};
-inline constexpr auto cPa = reference<dim_pressure, centipascal>{};
-inline constexpr auto dPa = reference<dim_pressure, decipascal>{};
-inline constexpr auto daPa = reference<dim_pressure, decapascal>{};
-inline constexpr auto hPa = reference<dim_pressure, hectopascal>{};
-inline constexpr auto kPa = reference<dim_pressure, kilopascal>{};
-inline constexpr auto MPa = reference<dim_pressure, megapascal>{};
-inline constexpr auto GPa = reference<dim_pressure, gigapascal>{};
-inline constexpr auto TPa = reference<dim_pressure, terapascal>{};
-inline constexpr auto PPa = reference<dim_pressure, petapascal>{};
-inline constexpr auto EPa = reference<dim_pressure, exapascal>{};
-inline constexpr auto ZPa = reference<dim_pressure, zettapascal>{};
-inline constexpr auto YPa = reference<dim_pressure, yottapascal>{};
-
-}  // namespace pressure_references
-
-namespace references {
-
-using namespace pressure_references;
-
-}  // namespace references
-
-#endif  // UNITS_NO_REFERENCES
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-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>;
-
-}  // namespace units::aliases::isq::si::inline pressure
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/radioactivity.h b/src/systems/si/include/units/isq/si/radioactivity.h
deleted file mode 100644
index d46c81e4..00000000
--- a/src/systems/si/include/units/isq/si/radioactivity.h
+++ /dev/null
@@ -1,327 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/radioactivity.h>
-#include <units/quantity.h>
-#include <units/reference.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/time.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct becquerel : named_unit<becquerel, "Bq"> {};
-struct yoctobecquerel : prefixed_unit<yoctobecquerel, yocto, becquerel> {};
-struct zeptobecquerel : prefixed_unit<zeptobecquerel, zepto, becquerel> {};
-struct attobecquerel : prefixed_unit<attobecquerel, atto, becquerel> {};
-struct femtobecquerel : prefixed_unit<femtobecquerel, femto, becquerel> {};
-struct picobecquerel : prefixed_unit<picobecquerel, pico, becquerel> {};
-struct nanobecquerel : prefixed_unit<nanobecquerel, nano, becquerel> {};
-struct microbecquerel : prefixed_unit<microbecquerel, micro, becquerel> {};
-struct millibecquerel : prefixed_unit<millibecquerel, milli, becquerel> {};
-struct centibecquerel : prefixed_unit<centibecquerel, centi, becquerel> {};
-struct decibecquerel : prefixed_unit<decibecquerel, deci, becquerel> {};
-struct decabecquerel : prefixed_unit<decabecquerel, deca, becquerel> {};
-struct hectobecquerel : prefixed_unit<hectobecquerel, hecto, becquerel> {};
-struct kilobecquerel : prefixed_unit<kilobecquerel, kilo, becquerel> {};
-struct megabecquerel : prefixed_unit<megabecquerel, mega, becquerel> {};
-struct gigabecquerel : prefixed_unit<gigabecquerel, giga, becquerel> {};
-struct terabecquerel : prefixed_unit<terabecquerel, tera, becquerel> {};
-struct petabecquerel : prefixed_unit<petabecquerel, peta, becquerel> {};
-struct exabecquerel : prefixed_unit<exabecquerel, exa, becquerel> {};
-struct zettabecquerel : prefixed_unit<zettabecquerel, zetta, becquerel> {};
-struct yottabecquerel : prefixed_unit<yottabecquerel, yotta, becquerel> {};
-
-struct dim_radioactivity : isq::dim_radioactivity<dim_radioactivity, becquerel, dim_time> {};
-
-template<UnitOf<dim_radioactivity> U, Representation Rep = double>
-using radioactivity = quantity<dim_radioactivity, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(long double l) { return radioactivity<yottabecquerel, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-#ifndef UNITS_NO_REFERENCES
-
-namespace radioactivity_references {
-
-inline constexpr auto Bq = reference<dim_radioactivity, becquerel>{};
-inline constexpr auto yBq = reference<dim_radioactivity, yoctobecquerel>{};
-inline constexpr auto zBq = reference<dim_radioactivity, zeptobecquerel>{};
-inline constexpr auto aBq = reference<dim_radioactivity, attobecquerel>{};
-inline constexpr auto fBq = reference<dim_radioactivity, femtobecquerel>{};
-inline constexpr auto pBq = reference<dim_radioactivity, picobecquerel>{};
-inline constexpr auto nBq = reference<dim_radioactivity, nanobecquerel>{};
-inline constexpr auto uBq = reference<dim_radioactivity, microbecquerel>{};
-inline constexpr auto mBq = reference<dim_radioactivity, millibecquerel>{};
-inline constexpr auto cBq = reference<dim_radioactivity, centibecquerel>{};
-inline constexpr auto dBq = reference<dim_radioactivity, decibecquerel>{};
-inline constexpr auto daBq = reference<dim_radioactivity, decabecquerel>{};
-inline constexpr auto hBq = reference<dim_radioactivity, hectobecquerel>{};
-inline constexpr auto kBq = reference<dim_radioactivity, kilobecquerel>{};
-inline constexpr auto MBq = reference<dim_radioactivity, megabecquerel>{};
-inline constexpr auto GBq = reference<dim_radioactivity, gigabecquerel>{};
-inline constexpr auto TBq = reference<dim_radioactivity, terabecquerel>{};
-inline constexpr auto PBq = reference<dim_radioactivity, petabecquerel>{};
-inline constexpr auto EBq = reference<dim_radioactivity, exabecquerel>{};
-inline constexpr auto ZBq = reference<dim_radioactivity, zettabecquerel>{};
-inline constexpr auto YBq = reference<dim_radioactivity, yottabecquerel>{};
-
-}  // namespace radioactivity_references
-
-namespace references {
-
-using namespace radioactivity_references;
-
-}  // namespace references
-
-#endif  // UNITS_NO_REFERENCES
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::inline radioactivity {
-
-template<Representation Rep = double>
-using Bq = units::isq::si::radioactivity<units::isq::si::becquerel, Rep>;
-template<Representation Rep = double>
-using yBq = units::isq::si::radioactivity<units::isq::si::yoctobecquerel, Rep>;
-template<Representation Rep = double>
-using zBq = units::isq::si::radioactivity<units::isq::si::zeptobecquerel, Rep>;
-template<Representation Rep = double>
-using aBq = units::isq::si::radioactivity<units::isq::si::attobecquerel, Rep>;
-template<Representation Rep = double>
-using fBq = units::isq::si::radioactivity<units::isq::si::femtobecquerel, Rep>;
-template<Representation Rep = double>
-using pBq = units::isq::si::radioactivity<units::isq::si::picobecquerel, Rep>;
-template<Representation Rep = double>
-using nBq = units::isq::si::radioactivity<units::isq::si::nanobecquerel, Rep>;
-template<Representation Rep = double>
-using uBq = units::isq::si::radioactivity<units::isq::si::microbecquerel, Rep>;
-template<Representation Rep = double>
-using mBq = units::isq::si::radioactivity<units::isq::si::millibecquerel, Rep>;
-template<Representation Rep = double>
-using cBq = units::isq::si::radioactivity<units::isq::si::centibecquerel, Rep>;
-template<Representation Rep = double>
-using dBq = units::isq::si::radioactivity<units::isq::si::decibecquerel, Rep>;
-template<Representation Rep = double>
-using daBq = units::isq::si::radioactivity<units::isq::si::decabecquerel, Rep>;
-template<Representation Rep = double>
-using hBq = units::isq::si::radioactivity<units::isq::si::hectobecquerel, Rep>;
-template<Representation Rep = double>
-using kBq = units::isq::si::radioactivity<units::isq::si::kilobecquerel, Rep>;
-template<Representation Rep = double>
-using MBq = units::isq::si::radioactivity<units::isq::si::megabecquerel, Rep>;
-template<Representation Rep = double>
-using GBq = units::isq::si::radioactivity<units::isq::si::gigabecquerel, Rep>;
-template<Representation Rep = double>
-using TBq = units::isq::si::radioactivity<units::isq::si::terabecquerel, Rep>;
-template<Representation Rep = double>
-using PBq = units::isq::si::radioactivity<units::isq::si::petabecquerel, Rep>;
-template<Representation Rep = double>
-using EBq = units::isq::si::radioactivity<units::isq::si::exabecquerel, Rep>;
-template<Representation Rep = double>
-using ZBq = units::isq::si::radioactivity<units::isq::si::zettabecquerel, Rep>;
-template<Representation Rep = double>
-using YBq = units::isq::si::radioactivity<units::isq::si::yottabecquerel, Rep>;
-
-}  // namespace units::aliases::isq::si::inline radioactivity
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/resistance.h b/src/systems/si/include/units/isq/si/resistance.h
deleted file mode 100644
index ea57ed61..00000000
--- a/src/systems/si/include/units/isq/si/resistance.h
+++ /dev/null
@@ -1,281 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/resistance.h>
-#include <units/quantity.h>
-#include <units/reference.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/electric_current.h>
-#include <units/isq/si/prefixes.h>
-#include <units/isq/si/voltage.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct ohm : named_unit<ohm, basic_symbol_text{"Ω", "ohm"}> {};
-struct yoctoohm : prefixed_unit<yoctoohm, yocto, ohm> {};
-struct zeptoohm : prefixed_unit<zeptoohm, zepto, ohm> {};
-struct attoohm : prefixed_unit<attoohm, atto, ohm> {};
-struct femtoohm : prefixed_unit<femtoohm, femto, ohm> {};
-struct picoohm : prefixed_unit<picoohm, pico, ohm> {};
-struct nanoohm : prefixed_unit<nanoohm, nano, ohm> {};
-struct microohm : prefixed_unit<microohm, micro, ohm> {};
-struct milliohm : prefixed_unit<milliohm, milli, ohm> {};
-struct kiloohm : prefixed_unit<kiloohm, kilo, ohm> {};
-struct megaohm : prefixed_unit<megaohm, mega, ohm> {};
-struct gigaohm : prefixed_unit<gigaohm, giga, ohm> {};
-struct teraohm : prefixed_unit<teraohm, tera, ohm> {};
-struct petaohm : prefixed_unit<petaohm, peta, ohm> {};
-struct exaohm : prefixed_unit<exaohm, exa, ohm> {};
-struct zettaohm : prefixed_unit<zettaohm, zetta, ohm> {};
-struct yottaohm : prefixed_unit<yottaohm, yotta, ohm> {};
-
-struct dim_resistance : isq::dim_resistance<dim_resistance, ohm, dim_voltage, dim_electric_current> {};
-
-template<UnitOf<dim_resistance> U, Representation Rep = double>
-using resistance = quantity<dim_resistance, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// R
-constexpr auto operator"" _q_R(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return resistance<ohm, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_R(long double l) { return resistance<ohm, long double>(l); }
-
-// yR
-constexpr auto operator"" _q_yR(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return resistance<yoctoohm, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_yR(long double l) { return resistance<yoctoohm, long double>(l); }
-
-// zR
-constexpr auto operator"" _q_zR(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return resistance<zeptoohm, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_zR(long double l) { return resistance<zeptoohm, long double>(l); }
-
-// aR
-constexpr auto operator"" _q_aR(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return resistance<attoohm, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_aR(long double l) { return resistance<attoohm, long double>(l); }
-
-// fR
-constexpr auto operator"" _q_fR(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return resistance<femtoohm, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_fR(long double l) { return resistance<femtoohm, long double>(l); }
-
-// pR
-constexpr auto operator"" _q_pR(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return resistance<picoohm, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_pR(long double l) { return resistance<picoohm, long double>(l); }
-
-// nR
-constexpr auto operator"" _q_nR(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return resistance<nanoohm, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_nR(long double l) { return resistance<nanoohm, long double>(l); }
-
-// uR
-constexpr auto operator"" _q_uR(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return resistance<microohm, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_uR(long double l) { return resistance<microohm, long double>(l); }
-
-// mR
-constexpr auto operator"" _q_mR(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return resistance<milliohm, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_mR(long double l) { return resistance<milliohm, long double>(l); }
-
-// kR
-constexpr auto operator"" _q_kR(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return resistance<kiloohm, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_kR(long double l) { return resistance<kiloohm, long double>(l); }
-
-// MR
-constexpr auto operator"" _q_MR(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return resistance<megaohm, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_MR(long double l) { return resistance<megaohm, long double>(l); }
-
-// GR
-constexpr auto operator"" _q_GR(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return resistance<gigaohm, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_GR(long double l) { return resistance<gigaohm, long double>(l); }
-
-// TR
-constexpr auto operator"" _q_TR(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return resistance<teraohm, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_TR(long double l) { return resistance<teraohm, long double>(l); }
-
-// PR
-constexpr auto operator"" _q_PR(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return resistance<petaohm, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_PR(long double l) { return resistance<petaohm, long double>(l); }
-
-// ER
-constexpr auto operator"" _q_ER(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return resistance<exaohm, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_ER(long double l) { return resistance<exaohm, long double>(l); }
-
-// ZR
-constexpr auto operator"" _q_ZR(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return resistance<zettaohm, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_ZR(long double l) { return resistance<zettaohm, long double>(l); }
-
-// YR
-constexpr auto operator"" _q_YR(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return resistance<yottaohm, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_YR(long double l) { return resistance<yottaohm, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-#ifndef UNITS_NO_REFERENCES
-
-namespace resistance_references {
-
-inline constexpr auto R = reference<dim_resistance, ohm>{};
-inline constexpr auto yR = reference<dim_resistance, yoctoohm>{};
-inline constexpr auto zR = reference<dim_resistance, zeptoohm>{};
-inline constexpr auto aR = reference<dim_resistance, attoohm>{};
-inline constexpr auto fR = reference<dim_resistance, femtoohm>{};
-inline constexpr auto pR = reference<dim_resistance, picoohm>{};
-inline constexpr auto nR = reference<dim_resistance, nanoohm>{};
-inline constexpr auto uR = reference<dim_resistance, microohm>{};
-inline constexpr auto mR = reference<dim_resistance, milliohm>{};
-inline constexpr auto kR = reference<dim_resistance, kiloohm>{};
-inline constexpr auto MR = reference<dim_resistance, megaohm>{};
-inline constexpr auto GR = reference<dim_resistance, gigaohm>{};
-inline constexpr auto TR = reference<dim_resistance, teraohm>{};
-inline constexpr auto PR = reference<dim_resistance, petaohm>{};
-inline constexpr auto ER = reference<dim_resistance, exaohm>{};
-inline constexpr auto ZR = reference<dim_resistance, zettaohm>{};
-inline constexpr auto YR = reference<dim_resistance, yottaohm>{};
-
-}  // namespace resistance_references
-
-namespace references {
-
-using namespace resistance_references;
-
-}  // namespace references
-
-#endif  // UNITS_NO_REFERENCES
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::inline resistance {
-
-template<Representation Rep = double>
-using R = units::isq::si::resistance<units::isq::si::ohm, Rep>;
-template<Representation Rep = double>
-using yR = units::isq::si::resistance<units::isq::si::yoctoohm, Rep>;
-template<Representation Rep = double>
-using zR = units::isq::si::resistance<units::isq::si::zeptoohm, Rep>;
-template<Representation Rep = double>
-using aR = units::isq::si::resistance<units::isq::si::attoohm, Rep>;
-template<Representation Rep = double>
-using fR = units::isq::si::resistance<units::isq::si::femtoohm, Rep>;
-template<Representation Rep = double>
-using pR = units::isq::si::resistance<units::isq::si::picoohm, Rep>;
-template<Representation Rep = double>
-using nR = units::isq::si::resistance<units::isq::si::nanoohm, Rep>;
-template<Representation Rep = double>
-using uR = units::isq::si::resistance<units::isq::si::microohm, Rep>;
-template<Representation Rep = double>
-using mR = units::isq::si::resistance<units::isq::si::milliohm, Rep>;
-template<Representation Rep = double>
-using kR = units::isq::si::resistance<units::isq::si::kiloohm, Rep>;
-template<Representation Rep = double>
-using MR = units::isq::si::resistance<units::isq::si::megaohm, Rep>;
-template<Representation Rep = double>
-using GR = units::isq::si::resistance<units::isq::si::gigaohm, Rep>;
-template<Representation Rep = double>
-using TR = units::isq::si::resistance<units::isq::si::teraohm, Rep>;
-template<Representation Rep = double>
-using PR = units::isq::si::resistance<units::isq::si::petaohm, Rep>;
-template<Representation Rep = double>
-using ER = units::isq::si::resistance<units::isq::si::exaohm, Rep>;
-template<Representation Rep = double>
-using ZR = units::isq::si::resistance<units::isq::si::zettaohm, Rep>;
-template<Representation Rep = double>
-using YR = units::isq::si::resistance<units::isq::si::yottaohm, Rep>;
-
-}  // namespace units::aliases::isq::si::inline resistance
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/si.h b/src/systems/si/include/units/isq/si/si.h
deleted file mode 100644
index 683047fb..00000000
--- a/src/systems/si/include/units/isq/si/si.h
+++ /dev/null
@@ -1,78 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/si/absorbed_dose.h>
-#include <units/isq/si/acceleration.h>
-#include <units/isq/si/amount_of_substance.h>
-#include <units/isq/si/angular_acceleration.h>
-#include <units/isq/si/angular_velocity.h>
-#include <units/isq/si/area.h>
-#include <units/isq/si/capacitance.h>
-#include <units/isq/si/catalytic_activity.h>
-#include <units/isq/si/charge_density.h>
-#include <units/isq/si/concentration.h>
-#include <units/isq/si/conductance.h>
-#include <units/isq/si/constants.h>
-#include <units/isq/si/current_density.h>
-#include <units/isq/si/density.h>
-#include <units/isq/si/dynamic_viscosity.h>
-#include <units/isq/si/electric_charge.h>
-#include <units/isq/si/electric_current.h>
-#include <units/isq/si/electric_field_strength.h>
-#include <units/isq/si/energy.h>
-#include <units/isq/si/force.h>
-#include <units/isq/si/frequency.h>
-#include <units/isq/si/heat_capacity.h>
-#include <units/isq/si/inductance.h>
-#include <units/isq/si/length.h>
-#include <units/isq/si/luminance.h>
-#include <units/isq/si/luminous_flux.h>
-#include <units/isq/si/luminous_intensity.h>
-#include <units/isq/si/magnetic_flux.h>
-#include <units/isq/si/magnetic_induction.h>
-#include <units/isq/si/mass.h>
-#include <units/isq/si/molar_energy.h>
-#include <units/isq/si/momentum.h>
-#include <units/isq/si/permeability.h>
-#include <units/isq/si/permittivity.h>
-#include <units/isq/si/power.h>
-#include <units/isq/si/prefixes.h>
-#include <units/isq/si/pressure.h>
-#include <units/isq/si/resistance.h>
-#include <units/isq/si/speed.h>
-#include <units/isq/si/surface_tension.h>
-#include <units/isq/si/thermal_conductivity.h>
-#include <units/isq/si/thermodynamic_temperature.h>
-#include <units/isq/si/time.h>
-#include <units/isq/si/torque.h>
-#include <units/isq/si/voltage.h>
-#include <units/isq/si/volume.h>
-// IWYU pragma: end_exports
-
-// TODO Add when downcasting issue is solved (collides with pressure)
-// #include <units/isq/si/energy_density.h>
-
-// TODO Add when downcasting issue is solved (collides with frequency)
-// #include <units/isq/si/radioactivity.h>
diff --git a/src/systems/si/include/units/isq/si/speed.h b/src/systems/si/include/units/isq/si/speed.h
deleted file mode 100644
index 8bcc17b7..00000000
--- a/src/systems/si/include/units/isq/si/speed.h
+++ /dev/null
@@ -1,82 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/speed.h>
-#include <units/quantity.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/length.h>
-#include <units/isq/si/time.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct metre_per_second : derived_unit<metre_per_second> {};
-struct dim_speed : isq::dim_speed<dim_speed, metre_per_second, dim_length, dim_time> {};
-
-struct kilometre_per_hour : derived_scaled_unit<kilometre_per_hour, dim_speed, kilometre, hour> {};
-
-template<UnitOf<dim_speed> U, Representation Rep = double>
-using speed = quantity<dim_speed, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// m/s
-constexpr auto operator"" _q_m_per_s(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return speed<metre_per_second, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_m_per_s(long double l) { return speed<metre_per_second, long double>(l); }
-
-// km/h
-constexpr auto operator"" _q_km_per_h(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return speed<kilometre_per_hour, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_km_per_h(long double l) { return speed<kilometre_per_hour, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::inline speed {
-
-template<Representation Rep = double>
-using m_per_s = units::isq::si::speed<units::isq::si::metre_per_second, Rep>;
-template<Representation Rep = double>
-using km_per_h = units::isq::si::speed<units::isq::si::kilometre_per_hour, Rep>;
-
-}  // namespace units::aliases::isq::si::inline speed
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/surface_tension.h b/src/systems/si/include/units/isq/si/surface_tension.h
deleted file mode 100644
index 382b133f..00000000
--- a/src/systems/si/include/units/isq/si/surface_tension.h
+++ /dev/null
@@ -1,70 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/surface_tension.h>
-#include <units/quantity.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/force.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct newton_per_metre : derived_unit<newton_per_metre> {};
-
-struct dim_surface_tension : isq::dim_surface_tension<dim_surface_tension, newton_per_metre, dim_force, dim_length> {};
-
-template<UnitOf<dim_surface_tension> U, Representation Rep = double>
-using surface_tension = quantity<dim_surface_tension, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// N/m
-constexpr auto operator"" _q_N_per_m(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return surface_tension<newton_per_metre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_N_per_m(long double l) { return surface_tension<newton_per_metre, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::inline surface_tension {
-
-template<Representation Rep = double>
-using N_per_m = units::isq::si::surface_tension<units::isq::si::newton_per_metre, Rep>;
-
-}  // namespace units::aliases::isq::si::inline surface_tension
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/thermal_conductivity.h b/src/systems/si/include/units/isq/si/thermal_conductivity.h
deleted file mode 100644
index 64177b52..00000000
--- a/src/systems/si/include/units/isq/si/thermal_conductivity.h
+++ /dev/null
@@ -1,76 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/thermal_conductivity.h>
-#include <units/quantity.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/power.h>
-#include <units/isq/si/thermodynamic_temperature.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct watt_per_metre_kelvin : derived_unit<watt_per_metre_kelvin> {};
-
-struct dim_thermal_conductivity :
-    isq::dim_thermal_conductivity<dim_thermal_conductivity, watt_per_metre_kelvin, dim_power, dim_length,
-                                  dim_thermodynamic_temperature> {};
-
-template<UnitOf<dim_thermal_conductivity> U, Representation Rep = double>
-using thermal_conductivity = quantity<dim_thermal_conductivity, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// W/(m K)
-constexpr auto operator"" _q_W_per_m_K(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return thermal_conductivity<watt_per_metre_kelvin, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_W_per_m_K(long double l)
-{
-  return thermal_conductivity<watt_per_metre_kelvin, long double>(l);
-}
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::inline thermal_conductivity {
-
-template<Representation Rep = double>
-using W_per_m_K = units::isq::si::thermal_conductivity<units::isq::si::watt_per_metre_kelvin, Rep>;
-
-}  // namespace units::aliases::isq::si::inline thermal_conductivity
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/thermodynamic_temperature.h b/src/systems/si/include/units/isq/si/thermodynamic_temperature.h
deleted file mode 100644
index cc0e3206..00000000
--- a/src/systems/si/include/units/isq/si/thermodynamic_temperature.h
+++ /dev/null
@@ -1,87 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/thermodynamic_temperature.h>
-#include <units/quantity.h>
-#include <units/reference.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/prefixes.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct kelvin : named_unit<kelvin, "K"> {};
-
-struct dim_thermodynamic_temperature : isq::dim_thermodynamic_temperature<kelvin> {};
-
-template<UnitOf<dim_thermodynamic_temperature> U, Representation Rep = double>
-using thermodynamic_temperature = quantity<dim_thermodynamic_temperature, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// K
-constexpr auto operator"" _q_K(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return thermodynamic_temperature<kelvin, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_K(long double l) { return thermodynamic_temperature<kelvin, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-#ifndef UNITS_NO_REFERENCES
-
-namespace thermodynamic_temperature_references {
-
-inline constexpr auto K = reference<dim_thermodynamic_temperature, kelvin>{};
-
-}  // namespace thermodynamic_temperature_references
-
-namespace references {
-
-using namespace thermodynamic_temperature_references;
-
-}  // namespace references
-
-#endif  // UNITS_NO_REFERENCES
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::inline thermodynamic_temperature {
-
-template<Representation Rep = double>
-using K = units::isq::si::thermodynamic_temperature<units::isq::si::kelvin, Rep>;
-
-}  // namespace units::aliases::isq::si::inline thermodynamic_temperature
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/time.h b/src/systems/si/include/units/isq/si/time.h
deleted file mode 100644
index f023377a..00000000
--- a/src/systems/si/include/units/isq/si/time.h
+++ /dev/null
@@ -1,219 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/quantity.h>
-#include <units/reference.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/dimensions/time.h>
-#include <units/isq/si/prefixes.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct second : named_unit<second, "s"> {};
-struct yoctosecond : prefixed_unit<yoctosecond, yocto, second> {};
-struct zeptosecond : prefixed_unit<zeptosecond, zepto, second> {};
-struct attosecond : prefixed_unit<attosecond, atto, second> {};
-struct femtosecond : prefixed_unit<femtosecond, femto, second> {};
-struct picosecond : prefixed_unit<picosecond, pico, second> {};
-struct nanosecond : prefixed_unit<nanosecond, nano, second> {};
-struct microsecond : prefixed_unit<microsecond, micro, second> {};
-struct millisecond : prefixed_unit<millisecond, milli, second> {};
-struct minute : named_scaled_unit<minute, "min", mag<60>(), second> {};
-struct hour : named_scaled_unit<hour, "h", mag<60>(), minute> {};
-struct day : named_scaled_unit<day, "d", mag<24>(), hour> {};
-
-struct dim_time : isq::dim_time<second> {};
-
-template<UnitOf<dim_time> U, Representation Rep = double>
-using time = quantity<dim_time, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// ys
-constexpr auto operator"" _q_ys(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return time<yoctosecond, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_ys(long double l) { return time<yoctosecond, long double>(l); }
-
-// zs
-constexpr auto operator"" _q_zs(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return time<zeptosecond, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_zs(long double l) { return time<zeptosecond, long double>(l); }
-
-// as
-constexpr auto operator"" _q_as(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return time<attosecond, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_as(long double l) { return time<attosecond, long double>(l); }
-
-// fs
-constexpr auto operator"" _q_fs(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return time<femtosecond, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_fs(long double l) { return time<femtosecond, long double>(l); }
-
-// ps
-constexpr auto operator"" _q_ps(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return time<picosecond, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_ps(long double l) { return time<picosecond, long double>(l); }
-
-// ns
-constexpr auto operator"" _q_ns(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return time<nanosecond, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_ns(long double l) { return time<nanosecond, long double>(l); }
-
-// us
-constexpr auto operator"" _q_us(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return time<microsecond, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_us(long double l) { return time<microsecond, long double>(l); }
-
-// ms
-constexpr auto operator"" _q_ms(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return time<millisecond, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_ms(long double l) { return time<millisecond, long double>(l); }
-
-// s
-constexpr auto operator"" _q_s(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return time<second, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_s(long double l) { return time<second, long double>(l); }
-
-// min
-constexpr auto operator"" _q_min(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return time<minute, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_min(long double l) { return time<minute, long double>(l); }
-
-// h
-constexpr auto operator"" _q_h(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return time<hour, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_h(long double l) { return time<hour, long double>(l); }
-
-// d
-constexpr auto operator"" _q_d(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return time<day, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_d(long double l) { return time<day, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-#ifndef UNITS_NO_REFERENCES
-
-namespace time_references {
-
-inline constexpr auto ys = reference<dim_time, yoctosecond>{};
-inline constexpr auto zs = reference<dim_time, zeptosecond>{};
-inline constexpr auto as = reference<dim_time, attosecond>{};
-inline constexpr auto fs = reference<dim_time, femtosecond>{};
-inline constexpr auto ps = reference<dim_time, picosecond>{};
-inline constexpr auto ns = reference<dim_time, nanosecond>{};
-inline constexpr auto us = reference<dim_time, microsecond>{};
-inline constexpr auto ms = reference<dim_time, millisecond>{};
-inline constexpr auto s = reference<dim_time, second>{};
-inline constexpr auto min = reference<dim_time, minute>{};
-inline constexpr auto h = reference<dim_time, hour>{};
-inline constexpr auto d = reference<dim_time, day>{};
-
-}  // namespace time_references
-
-namespace references {
-
-using namespace time_references;
-
-}  // namespace references
-
-#endif  // UNITS_NO_REFERENCES
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::inline time {
-
-template<Representation Rep = double>
-using ys = units::isq::si::time<units::isq::si::yoctosecond, Rep>;
-template<Representation Rep = double>
-using zs = units::isq::si::time<units::isq::si::zeptosecond, Rep>;
-template<Representation Rep = double>
-using as = units::isq::si::time<units::isq::si::attosecond, Rep>;
-template<Representation Rep = double>
-using fs = units::isq::si::time<units::isq::si::femtosecond, Rep>;
-template<Representation Rep = double>
-using ps = units::isq::si::time<units::isq::si::picosecond, Rep>;
-template<Representation Rep = double>
-using ns = units::isq::si::time<units::isq::si::nanosecond, Rep>;
-template<Representation Rep = double>
-using us = units::isq::si::time<units::isq::si::microsecond, Rep>;
-template<Representation Rep = double>
-using ms = units::isq::si::time<units::isq::si::millisecond, Rep>;
-template<Representation Rep = double>
-using s = units::isq::si::time<units::isq::si::second, Rep>;
-template<Representation Rep = double>
-using min = units::isq::si::time<units::isq::si::minute, Rep>;
-template<Representation Rep = double>
-using h = units::isq::si::time<units::isq::si::hour, Rep>;
-template<Representation Rep = double>
-using d = units::isq::si::time<units::isq::si::day, Rep>;
-
-}  // namespace units::aliases::isq::si::inline time
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/torque.h b/src/systems/si/include/units/isq/si/torque.h
deleted file mode 100644
index 14e5aec2..00000000
--- a/src/systems/si/include/units/isq/si/torque.h
+++ /dev/null
@@ -1,72 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/torque.h>
-#include <units/quantity.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/generic/angle.h>
-#include <units/isq/si/energy.h>
-#include <units/isq/si/prefixes.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct newton_metre_per_radian : derived_unit<newton_metre_per_radian> {};
-
-struct dim_torque : isq::dim_torque<dim_torque, newton_metre_per_radian, dim_force, dim_length, dim_angle<>> {};
-
-template<UnitOf<dim_torque> U, Representation Rep = double>
-using torque = quantity<dim_torque, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// Nm
-constexpr auto operator"" _q_N_m_per_rad(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return torque<newton_metre_per_radian, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_N_m_per_rad(long double l) { return torque<newton_metre_per_radian, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::inline torque {
-
-template<Representation Rep = double>
-using N_m_per_rad = units::isq::si::torque<units::isq::si::newton_metre_per_radian, Rep>;
-
-}  // namespace units::aliases::isq::si::inline torque
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/voltage.h b/src/systems/si/include/units/isq/si/voltage.h
deleted file mode 100644
index e06cc1be..00000000
--- a/src/systems/si/include/units/isq/si/voltage.h
+++ /dev/null
@@ -1,329 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/voltage.h>
-#include <units/quantity.h>
-#include <units/reference.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/electric_current.h>
-#include <units/isq/si/power.h>
-#include <units/isq/si/prefixes.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct volt : named_unit<volt, "V"> {};
-struct yoctovolt : prefixed_unit<yoctovolt, yocto, volt> {};
-struct zeptovolt : prefixed_unit<zeptovolt, zepto, volt> {};
-struct attovolt : prefixed_unit<attovolt, atto, volt> {};
-struct femtovolt : prefixed_unit<femtovolt, femto, volt> {};
-struct picovolt : prefixed_unit<picovolt, pico, volt> {};
-struct nanovolt : prefixed_unit<nanovolt, nano, volt> {};
-struct microvolt : prefixed_unit<microvolt, micro, volt> {};
-struct millivolt : prefixed_unit<millivolt, milli, volt> {};
-struct centivolt : prefixed_unit<centivolt, centi, volt> {};
-struct decivolt : prefixed_unit<decivolt, deci, volt> {};
-struct decavolt : prefixed_unit<decavolt, deca, volt> {};
-struct hectovolt : prefixed_unit<hectovolt, hecto, volt> {};
-struct kilovolt : prefixed_unit<kilovolt, kilo, volt> {};
-struct megavolt : prefixed_unit<megavolt, mega, volt> {};
-struct gigavolt : prefixed_unit<gigavolt, giga, volt> {};
-struct teravolt : prefixed_unit<teravolt, tera, volt> {};
-struct petavolt : prefixed_unit<petavolt, peta, volt> {};
-struct exavolt : prefixed_unit<exavolt, exa, volt> {};
-struct zettavolt : prefixed_unit<zettavolt, zetta, volt> {};
-struct yottavolt : prefixed_unit<yottavolt, yotta, volt> {};
-
-struct dim_voltage : isq::dim_voltage<dim_voltage, volt, dim_power, dim_electric_current> {};
-
-template<UnitOf<dim_voltage> U, Representation Rep = double>
-using voltage = quantity<dim_voltage, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(long double l) { return voltage<yottavolt, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-#ifndef UNITS_NO_REFERENCES
-
-namespace voltage_references {
-
-inline constexpr auto V = reference<dim_voltage, volt>{};
-inline constexpr auto yV = reference<dim_voltage, yoctovolt>{};
-inline constexpr auto zV = reference<dim_voltage, zeptovolt>{};
-inline constexpr auto aV = reference<dim_voltage, attovolt>{};
-inline constexpr auto fV = reference<dim_voltage, femtovolt>{};
-inline constexpr auto pV = reference<dim_voltage, picovolt>{};
-inline constexpr auto nV = reference<dim_voltage, nanovolt>{};
-inline constexpr auto uV = reference<dim_voltage, microvolt>{};
-inline constexpr auto mV = reference<dim_voltage, millivolt>{};
-inline constexpr auto cV = reference<dim_voltage, centivolt>{};
-inline constexpr auto dV = reference<dim_voltage, decivolt>{};
-inline constexpr auto daV = reference<dim_voltage, decavolt>{};
-inline constexpr auto hV = reference<dim_voltage, hectovolt>{};
-inline constexpr auto kV = reference<dim_voltage, kilovolt>{};
-inline constexpr auto MV = reference<dim_voltage, megavolt>{};
-inline constexpr auto GV = reference<dim_voltage, gigavolt>{};
-inline constexpr auto TV = reference<dim_voltage, teravolt>{};
-inline constexpr auto PV = reference<dim_voltage, petavolt>{};
-inline constexpr auto EV = reference<dim_voltage, exavolt>{};
-inline constexpr auto ZV = reference<dim_voltage, zettavolt>{};
-inline constexpr auto YV = reference<dim_voltage, yottavolt>{};
-
-}  // namespace voltage_references
-
-namespace references {
-
-using namespace voltage_references;
-
-}  // namespace references
-
-#endif  // UNITS_NO_REFERENCES
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-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>;
-
-}  // namespace units::aliases::isq::si::inline voltage
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si/include/units/isq/si/volume.h b/src/systems/si/include/units/isq/si/volume.h
deleted file mode 100644
index 1f61d874..00000000
--- a/src/systems/si/include/units/isq/si/volume.h
+++ /dev/null
@@ -1,582 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#pragma once
-
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/volume.h>
-#include <units/quantity.h>
-#include <units/reference.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
-
-#include <units/isq/si/length.h>
-#include <units/unit.h>
-
-namespace units::isq::si {
-
-struct cubic_metre : derived_unit<cubic_metre> {};
-struct dim_volume : isq::dim_volume<dim_volume, cubic_metre, dim_length> {};
-
-struct cubic_yoctometre : derived_scaled_unit<cubic_yoctometre, dim_volume, yoctometre> {};
-struct cubic_zeptometre : derived_scaled_unit<cubic_zeptometre, dim_volume, zeptometre> {};
-struct cubic_attometre : derived_scaled_unit<cubic_attometre, dim_volume, attometre> {};
-struct cubic_femtometre : derived_scaled_unit<cubic_femtometre, dim_volume, femtometre> {};
-struct cubic_picometre : derived_scaled_unit<cubic_picometre, dim_volume, picometre> {};
-struct cubic_nanometre : derived_scaled_unit<cubic_nanometre, dim_volume, nanometre> {};
-struct cubic_micrometre : derived_scaled_unit<cubic_micrometre, dim_volume, micrometre> {};
-struct cubic_millimetre : derived_scaled_unit<cubic_millimetre, dim_volume, millimetre> {};
-struct cubic_centimetre : derived_scaled_unit<cubic_centimetre, dim_volume, centimetre> {};
-struct cubic_decimetre : derived_scaled_unit<cubic_decimetre, dim_volume, decimetre> {};
-struct cubic_decametre : derived_scaled_unit<cubic_decametre, dim_volume, decametre> {};
-struct cubic_hectometre : derived_scaled_unit<cubic_hectometre, dim_volume, hectometre> {};
-struct cubic_kilometre : derived_scaled_unit<cubic_kilometre, dim_volume, kilometre> {};
-struct cubic_megametre : derived_scaled_unit<cubic_megametre, dim_volume, megametre> {};
-struct cubic_gigametre : derived_scaled_unit<cubic_gigametre, dim_volume, gigametre> {};
-struct cubic_terametre : derived_scaled_unit<cubic_terametre, dim_volume, terametre> {};
-struct cubic_petametre : derived_scaled_unit<cubic_petametre, dim_volume, petametre> {};
-struct cubic_exametre : derived_scaled_unit<cubic_exametre, dim_volume, exametre> {};
-struct cubic_zettametre : derived_scaled_unit<cubic_zettametre, dim_volume, zettametre> {};
-struct cubic_yottametre : derived_scaled_unit<cubic_yottametre, dim_volume, yottametre> {};
-
-struct litre : alias_unit<cubic_decimetre, "l"> {};
-struct yoctolitre : prefixed_alias_unit<cubic_nanometre, yocto, litre> {};
-struct zeptolitre : prefixed_unit<zeptolitre, zepto, litre> {};
-struct attolitre : prefixed_unit<attolitre, atto, litre> {};
-struct femtolitre : prefixed_alias_unit<cubic_micrometre, femto, litre> {};
-struct picolitre : prefixed_unit<picolitre, pico, litre> {};
-struct nanolitre : prefixed_unit<nanolitre, nano, litre> {};
-struct microlitre : prefixed_alias_unit<cubic_millimetre, micro, litre> {};
-struct millilitre : prefixed_alias_unit<cubic_centimetre, milli, litre> {};
-struct centilitre : prefixed_unit<centilitre, centi, litre> {};
-struct decilitre : prefixed_unit<decilitre, deci, litre> {};
-struct decalitre : prefixed_unit<decalitre, deca, litre> {};
-struct hectolitre : prefixed_alias_unit<cubic_decimetre, hecto, litre> {};
-struct kilolitre : prefixed_alias_unit<cubic_metre, kilo, litre> {};
-struct megalitre : prefixed_alias_unit<cubic_decametre, mega, litre> {};
-struct gigalitre : prefixed_alias_unit<cubic_hectometre, giga, litre> {};
-struct teralitre : prefixed_alias_unit<cubic_kilometre, tera, litre> {};
-struct petalitre : prefixed_unit<petalitre, peta, litre> {};
-struct exalitre : prefixed_unit<exalitre, exa, litre> {};
-struct zettalitre : prefixed_alias_unit<cubic_megametre, zetta, litre> {};
-struct yottalitre : prefixed_unit<yottalitre, yotta, litre> {};
-
-template<UnitOf<dim_volume> U, Representation Rep = double>
-using volume = quantity<dim_volume, U, Rep>;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-// m3
-constexpr auto operator"" _q_m3(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<cubic_metre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_m3(long double l) { return volume<cubic_metre, long double>(l); }
-
-// ym3
-constexpr auto operator"" _q_ym3(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<cubic_yoctometre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_ym3(long double l) { return volume<cubic_yoctometre, long double>(l); }
-
-// zm3
-constexpr auto operator"" _q_zm3(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<cubic_zeptometre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_zm3(long double l) { return volume<cubic_zeptometre, long double>(l); }
-
-// am3
-constexpr auto operator"" _q_am3(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<cubic_attometre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_am3(long double l) { return volume<cubic_attometre, long double>(l); }
-
-// fm3
-constexpr auto operator"" _q_fm3(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<cubic_femtometre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_fm3(long double l) { return volume<cubic_femtometre, long double>(l); }
-
-// pm3
-constexpr auto operator"" _q_pm3(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<cubic_picometre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_pm3(long double l) { return volume<cubic_picometre, long double>(l); }
-
-// nm3
-constexpr auto operator"" _q_nm3(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<cubic_nanometre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_nm3(long double l) { return volume<cubic_nanometre, long double>(l); }
-
-// um3
-constexpr auto operator"" _q_um3(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<cubic_micrometre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_um3(long double l) { return volume<cubic_micrometre, long double>(l); }
-
-// mm3
-constexpr auto operator"" _q_mm3(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<cubic_millimetre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_mm3(long double l) { return volume<cubic_millimetre, long double>(l); }
-
-// cm3
-constexpr auto operator"" _q_cm3(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<cubic_centimetre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_cm3(long double l) { return volume<cubic_centimetre, long double>(l); }
-
-// dm3
-constexpr auto operator"" _q_dm3(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<cubic_decimetre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_dm3(long double l) { return volume<cubic_decimetre, long double>(l); }
-
-// dam3
-constexpr auto operator"" _q_dam3(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<cubic_decametre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_dam3(long double l) { return volume<cubic_decametre, long double>(l); }
-
-// hm3
-constexpr auto operator"" _q_hm3(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<cubic_hectometre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_hm3(long double l) { return volume<cubic_hectometre, long double>(l); }
-
-// km3
-constexpr auto operator"" _q_km3(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<cubic_kilometre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_km3(long double l) { return volume<cubic_kilometre, long double>(l); }
-
-// Mm3
-constexpr auto operator"" _q_Mm3(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<cubic_megametre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Mm3(long double l) { return volume<cubic_megametre, long double>(l); }
-
-// Gm3
-constexpr auto operator"" _q_Gm3(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<cubic_gigametre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Gm3(long double l) { return volume<cubic_gigametre, long double>(l); }
-
-// Tm3
-constexpr auto operator"" _q_Tm3(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<cubic_terametre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Tm3(long double l) { return volume<cubic_terametre, long double>(l); }
-
-// Pm3
-constexpr auto operator"" _q_Pm3(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<cubic_petametre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Pm3(long double l) { return volume<cubic_petametre, long double>(l); }
-
-// Em3
-constexpr auto operator"" _q_Em3(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<cubic_exametre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Em3(long double l) { return volume<cubic_exametre, long double>(l); }
-
-// Zm3
-constexpr auto operator"" _q_Zm3(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<cubic_zettametre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Zm3(long double l) { return volume<cubic_zettametre, long double>(l); }
-
-// Ym3
-constexpr auto operator"" _q_Ym3(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<cubic_yottametre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Ym3(long double l) { return volume<cubic_yottametre, long double>(l); }
-
-// l
-constexpr auto operator"" _q_l(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<litre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_l(long double l) { return volume<litre, long double>(l); }
-
-// yl
-constexpr auto operator"" _q_yl(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<yoctolitre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_yl(long double l) { return volume<yoctolitre, long double>(l); }
-
-// zl
-constexpr auto operator"" _q_zl(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<zeptolitre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_zl(long double l) { return volume<zeptolitre, long double>(l); }
-
-// al
-constexpr auto operator"" _q_al(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<attolitre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_al(long double l) { return volume<attolitre, long double>(l); }
-
-// fl
-constexpr auto operator"" _q_fl(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<femtolitre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_fl(long double l) { return volume<femtolitre, long double>(l); }
-
-// pl
-constexpr auto operator"" _q_pl(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<picolitre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_pl(long double l) { return volume<picolitre, long double>(l); }
-
-// nl
-constexpr auto operator"" _q_nl(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<nanolitre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_nl(long double l) { return volume<nanolitre, long double>(l); }
-
-// ul
-constexpr auto operator"" _q_ul(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<microlitre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_ul(long double l) { return volume<microlitre, long double>(l); }
-
-// ml
-constexpr auto operator"" _q_ml(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<millilitre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_ml(long double l) { return volume<millilitre, long double>(l); }
-
-// cl
-constexpr auto operator"" _q_cl(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<centilitre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_cl(long double l) { return volume<centilitre, long double>(l); }
-
-// dl
-constexpr auto operator"" _q_dl(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<decilitre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_dl(long double l) { return volume<decilitre, long double>(l); }
-
-// dal
-constexpr auto operator"" _q_dal(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<decalitre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_dal(long double l) { return volume<decalitre, long double>(l); }
-
-// hl
-constexpr auto operator"" _q_hl(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<hectolitre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_hl(long double l) { return volume<hectolitre, long double>(l); }
-
-// kl
-constexpr auto operator"" _q_kl(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<kilolitre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_kl(long double l) { return volume<kilolitre, long double>(l); }
-
-// Ml
-constexpr auto operator"" _q_Ml(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<megalitre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Ml(long double l) { return volume<megalitre, long double>(l); }
-
-// Gl
-constexpr auto operator"" _q_Gl(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<gigalitre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Gl(long double l) { return volume<gigalitre, long double>(l); }
-
-// Tl
-constexpr auto operator"" _q_Tl(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<teralitre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Tl(long double l) { return volume<teralitre, long double>(l); }
-
-// Pl
-constexpr auto operator"" _q_Pl(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<petalitre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Pl(long double l) { return volume<petalitre, long double>(l); }
-
-// El
-constexpr auto operator"" _q_El(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<exalitre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_El(long double l) { return volume<exalitre, long double>(l); }
-
-// Zl
-constexpr auto operator"" _q_Zl(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<zettalitre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Zl(long double l) { return volume<zettalitre, long double>(l); }
-
-// Yl
-constexpr auto operator"" _q_Yl(unsigned long long l)
-{
-  gsl_ExpectsAudit(std::in_range<std::int64_t>(l));
-  return volume<yottalitre, std::int64_t>(static_cast<std::int64_t>(l));
-}
-constexpr auto operator"" _q_Yl(long double l) { return volume<yottalitre, long double>(l); }
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-#ifndef UNITS_NO_REFERENCES
-
-namespace volume_references {
-
-inline constexpr auto m3 = reference<dim_volume, cubic_metre>{};
-inline constexpr auto ym3 = reference<dim_volume, cubic_yoctometre>{};
-inline constexpr auto zm3 = reference<dim_volume, cubic_zeptometre>{};
-inline constexpr auto am3 = reference<dim_volume, cubic_attometre>{};
-inline constexpr auto fm3 = reference<dim_volume, cubic_femtometre>{};
-inline constexpr auto pm3 = reference<dim_volume, cubic_picometre>{};
-inline constexpr auto nm3 = reference<dim_volume, cubic_nanometre>{};
-inline constexpr auto um3 = reference<dim_volume, cubic_micrometre>{};
-inline constexpr auto mm3 = reference<dim_volume, cubic_millimetre>{};
-inline constexpr auto cm3 = reference<dim_volume, cubic_centimetre>{};
-inline constexpr auto dm3 = reference<dim_volume, cubic_decimetre>{};
-inline constexpr auto dam3 = reference<dim_volume, cubic_decametre>{};
-inline constexpr auto hm3 = reference<dim_volume, cubic_hectometre>{};
-inline constexpr auto km3 = reference<dim_volume, cubic_kilometre>{};
-inline constexpr auto Mm3 = reference<dim_volume, cubic_megametre>{};
-inline constexpr auto Gm3 = reference<dim_volume, cubic_gigametre>{};
-inline constexpr auto Tm3 = reference<dim_volume, cubic_terametre>{};
-inline constexpr auto Pm3 = reference<dim_volume, cubic_petametre>{};
-inline constexpr auto Em3 = reference<dim_volume, cubic_exametre>{};
-inline constexpr auto Zm3 = reference<dim_volume, cubic_zettametre>{};
-inline constexpr auto Ym3 = reference<dim_volume, cubic_yottametre>{};
-
-inline constexpr auto l = reference<dim_volume, litre>{};
-inline constexpr auto yl = reference<dim_volume, yoctolitre>{};
-inline constexpr auto zl = reference<dim_volume, zeptolitre>{};
-inline constexpr auto al = reference<dim_volume, attolitre>{};
-inline constexpr auto fl = reference<dim_volume, femtolitre>{};
-inline constexpr auto pl = reference<dim_volume, picolitre>{};
-inline constexpr auto nl = reference<dim_volume, nanolitre>{};
-inline constexpr auto ul = reference<dim_volume, microlitre>{};
-inline constexpr auto ml = reference<dim_volume, millilitre>{};
-inline constexpr auto cl = reference<dim_volume, centilitre>{};
-inline constexpr auto dl = reference<dim_volume, decilitre>{};
-inline constexpr auto dal = reference<dim_volume, decalitre>{};
-inline constexpr auto hl = reference<dim_volume, hectolitre>{};
-inline constexpr auto kl = reference<dim_volume, kilolitre>{};
-inline constexpr auto Ml = reference<dim_volume, megalitre>{};
-inline constexpr auto Gl = reference<dim_volume, gigalitre>{};
-inline constexpr auto Tl = reference<dim_volume, teralitre>{};
-inline constexpr auto Pl = reference<dim_volume, petalitre>{};
-inline constexpr auto El = reference<dim_volume, exalitre>{};
-inline constexpr auto Zl = reference<dim_volume, zettalitre>{};
-inline constexpr auto Yl = reference<dim_volume, yottalitre>{};
-
-}  // namespace volume_references
-
-namespace references {
-
-using namespace volume_references;
-
-}  // namespace references
-
-#endif  // UNITS_NO_REFERENCES
-
-}  // namespace units::isq::si
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::inline volume {
-
-template<Representation Rep = double>
-using m3 = units::isq::si::volume<units::isq::si::cubic_metre, Rep>;
-template<Representation Rep = double>
-using ym3 = units::isq::si::volume<units::isq::si::cubic_yoctometre, Rep>;
-template<Representation Rep = double>
-using zm3 = units::isq::si::volume<units::isq::si::cubic_zeptometre, Rep>;
-template<Representation Rep = double>
-using am3 = units::isq::si::volume<units::isq::si::cubic_attometre, Rep>;
-template<Representation Rep = double>
-using fm3 = units::isq::si::volume<units::isq::si::cubic_femtometre, Rep>;
-template<Representation Rep = double>
-using pm3 = units::isq::si::volume<units::isq::si::cubic_picometre, Rep>;
-template<Representation Rep = double>
-using nm3 = units::isq::si::volume<units::isq::si::cubic_nanometre, Rep>;
-template<Representation Rep = double>
-using um3 = units::isq::si::volume<units::isq::si::cubic_micrometre, Rep>;
-template<Representation Rep = double>
-using mm3 = units::isq::si::volume<units::isq::si::cubic_millimetre, Rep>;
-template<Representation Rep = double>
-using cm3 = units::isq::si::volume<units::isq::si::cubic_centimetre, Rep>;
-template<Representation Rep = double>
-using dm3 = units::isq::si::volume<units::isq::si::cubic_decimetre, Rep>;
-template<Representation Rep = double>
-using dam3 = units::isq::si::volume<units::isq::si::cubic_decametre, Rep>;
-template<Representation Rep = double>
-using hm3 = units::isq::si::volume<units::isq::si::cubic_hectometre, Rep>;
-template<Representation Rep = double>
-using km3 = units::isq::si::volume<units::isq::si::cubic_kilometre, Rep>;
-template<Representation Rep = double>
-using Mm3 = units::isq::si::volume<units::isq::si::cubic_megametre, Rep>;
-template<Representation Rep = double>
-using Gm3 = units::isq::si::volume<units::isq::si::cubic_gigametre, Rep>;
-template<Representation Rep = double>
-using Tm3 = units::isq::si::volume<units::isq::si::cubic_terametre, Rep>;
-template<Representation Rep = double>
-using Pm3 = units::isq::si::volume<units::isq::si::cubic_petametre, Rep>;
-template<Representation Rep = double>
-using Em3 = units::isq::si::volume<units::isq::si::cubic_exametre, Rep>;
-template<Representation Rep = double>
-using Zm3 = units::isq::si::volume<units::isq::si::cubic_zettametre, Rep>;
-template<Representation Rep = double>
-using Ym3 = units::isq::si::volume<units::isq::si::cubic_yottametre, Rep>;
-
-template<Representation Rep = double>
-using l = units::isq::si::volume<units::isq::si::litre, Rep>;
-template<Representation Rep = double>
-using yl = units::isq::si::volume<units::isq::si::yoctolitre, Rep>;
-template<Representation Rep = double>
-using zl = units::isq::si::volume<units::isq::si::zeptolitre, Rep>;
-template<Representation Rep = double>
-using al = units::isq::si::volume<units::isq::si::attolitre, Rep>;
-template<Representation Rep = double>
-using fl = units::isq::si::volume<units::isq::si::femtolitre, Rep>;
-template<Representation Rep = double>
-using pl = units::isq::si::volume<units::isq::si::picolitre, Rep>;
-template<Representation Rep = double>
-using nl = units::isq::si::volume<units::isq::si::nanolitre, Rep>;
-template<Representation Rep = double>
-using ul = units::isq::si::volume<units::isq::si::microlitre, Rep>;
-template<Representation Rep = double>
-using ml = units::isq::si::volume<units::isq::si::millilitre, Rep>;
-template<Representation Rep = double>
-using cl = units::isq::si::volume<units::isq::si::centilitre, Rep>;
-template<Representation Rep = double>
-using dl = units::isq::si::volume<units::isq::si::decilitre, Rep>;
-template<Representation Rep = double>
-using dal = units::isq::si::volume<units::isq::si::decalitre, Rep>;
-template<Representation Rep = double>
-using hl = units::isq::si::volume<units::isq::si::hectolitre, Rep>;
-template<Representation Rep = double>
-using kl = units::isq::si::volume<units::isq::si::kilolitre, Rep>;
-template<Representation Rep = double>
-using Ml = units::isq::si::volume<units::isq::si::megalitre, Rep>;
-template<Representation Rep = double>
-using Gl = units::isq::si::volume<units::isq::si::gigalitre, Rep>;
-template<Representation Rep = double>
-using Tl = units::isq::si::volume<units::isq::si::teralitre, Rep>;
-template<Representation Rep = double>
-using Pl = units::isq::si::volume<units::isq::si::petalitre, Rep>;
-template<Representation Rep = double>
-using El = units::isq::si::volume<units::isq::si::exalitre, Rep>;
-template<Representation Rep = double>
-using Zl = units::isq::si::volume<units::isq::si::zettalitre, Rep>;
-template<Representation Rep = double>
-using Yl = units::isq::si::volume<units::isq::si::yottalitre, Rep>;
-
-}  // namespace units::aliases::isq::si::inline volume
-
-#endif  // UNITS_NO_ALIASES
diff --git a/src/systems/si-cgs/include/units/isq/si/cgs/time.h b/src/systems/si/include/units/si/base_quantities.h
similarity index 56%
rename from src/systems/si-cgs/include/units/isq/si/cgs/time.h
rename to src/systems/si/include/units/si/base_quantities.h
index e84ae05c..91d557f5 100644
--- a/src/systems/si-cgs/include/units/isq/si/cgs/time.h
+++ b/src/systems/si/include/units/si/base_quantities.h
@@ -22,55 +22,22 @@
 
 #pragma once
 
-// IWYU pragma: begin_exports
-#include <units/isq/dimensions/time.h>
-#include <units/isq/si/time.h>
-#include <units/quantity.h>
+#include <units/isq/base_dimensions.h>
 #include <units/reference.h>
-#include <units/symbol_text.h>
-// IWYU pragma: end_exports
+#include <units/si/units.h>
 
-namespace units::isq::si::cgs {
+namespace units::si {
 
-using si::second;
+// inline constexpr struct time : system_reference<isq::time_dim, second> {} time;
+// inline constexpr struct length : system_reference<isq::length_dim, metre> {} length;
+// inline constexpr struct mass : system_reference<isq::mass_dim, kilogram> {} mass;
+inline constexpr struct electric_current : system_reference<isq::electric_current_dim, ampere> {
+} electric_current;
+inline constexpr struct thermodynamic_temperature : system_reference<isq::thermodynamic_temperature_dim, kelvin> {
+} thermodynamic_temperature;
+inline constexpr struct amount_of_substance : system_reference<isq::amount_of_substance_dim, kilogram> {
+} amount_of_substance;
+inline constexpr struct luminous_intensity : system_reference<isq::luminous_intensity_dim, candela> {
+} luminous_intensity;
 
-using si::dim_time;
-using si::time;
-
-#ifndef UNITS_NO_LITERALS
-
-inline namespace literals {
-
-using si::literals::operator"" _q_s;
-
-}  // namespace literals
-
-#endif  // UNITS_NO_LITERALS
-
-#ifndef UNITS_NO_REFERENCES
-
-namespace time_references {
-
-using si::references::s;
-
-}  // namespace time_references
-
-namespace references {
-
-using namespace time_references;
-
-}  // namespace references
-
-#endif  // UNITS_NO_REFERENCES
-
-}  // namespace units::isq::si::cgs
-
-#ifndef UNITS_NO_ALIASES
-
-namespace units::aliases::isq::si::cgs::inline time {
-
-using namespace units::aliases::isq::si::time;
-
-}  // namespace units::aliases::isq::si::cgs::inline time
-
-#endif  // UNITS_NO_ALIASES
+}  // namespace units::si
diff --git a/src/systems/si/include/units/si/constants.h b/src/systems/si/include/units/si/constants.h
new file mode 100644
index 00000000..1027bf37
--- /dev/null
+++ b/src/systems/si/include/units/si/constants.h
@@ -0,0 +1,80 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2018 Mateusz Pusz
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#pragma once
+
+#include <units/quantity.h>
+#include <units/si/mechanics.h>
+#include <units/si/space_and_time.h>
+#include <units/si/thermodynamics.h>
+#include <units/si/units.h>
+
+namespace units::si {
+
+namespace si2019 {
+
+// clang-format off
+inline constexpr struct mag_planck : decltype(mag<ratio(662'607'015, 100'000'000)> * mag_power<10, -34>) {} mag_planck;
+inline constexpr struct mag_speed_of_light : decltype(mag<299'792'458>) {} mag_speed_of_light;
+// clang-format on
+
+template<typename Rep = double>
+inline constexpr auto planck_constant = Rep{1} * (mag_planck * energy[joule] * time[second]);
+
+template<typename Rep = double>
+inline constexpr auto speed_of_light = Rep{1} * speed[mag_speed_of_light * metre / second];
+
+// template<Representation Rep = double>
+// inline constexpr auto planck_constant = energy<joule, Rep>(6.62607015e-34) * time<second, Rep>(1);
+
+// template<Representation Rep = double>
+// inline constexpr auto elementary_charge = electric_charge<coulomb, Rep>(1.602176634e-19);
+
+// template<Representation Rep = double>
+// inline constexpr auto boltzmann_constant = energy<joule, Rep>(1.380649e-23) / thermodynamic_temperature<kelvin,
+// Rep>(1);
+
+// template<Representation Rep = double>
+// inline constexpr auto avogadro_constant = Rep(6.02214076e23) / amount_of_substance<mole, Rep>(1);
+
+// template<Representation Rep = double>
+// inline constexpr auto speed_of_light = speed<metre_per_second, Rep>(299'792'458);
+
+// template<Representation Rep = double>
+// inline constexpr auto hyperfine_structure_transition_frequency = frequency<hertz, Rep>(Rep{9'192'631'770});
+
+// template<Representation Rep = double>
+// inline constexpr auto luminous_efficacy = luminous_flux<lumen, Rep>(683) / power<watt, Rep>(1);
+
+// template<Representation Rep = double>
+// inline constexpr auto standard_gravity = acceleration<metre_per_second_sq, Rep>(9.80665);
+
+}  // namespace si2019
+
+// clang-format off
+inline constexpr struct mag_standard_gravity : decltype(mag<ratio{980'665, 10'000}>) {} mag_standard_gravity;
+// clang-format on
+
+template<typename Rep = double>
+inline constexpr auto standard_gravity = Rep{1} * acceleration[mag_standard_gravity * metre / square<second>];
+
+}  // namespace units::si
diff --git a/src/systems/si/include/units/si/mechanics.h b/src/systems/si/include/units/si/mechanics.h
new file mode 100644
index 00000000..e657aca7
--- /dev/null
+++ b/src/systems/si/include/units/si/mechanics.h
@@ -0,0 +1,68 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2018 Mateusz Pusz
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#pragma once
+
+#include <units/isq/mechanics.h>
+#include <units/isq/space_and_time.h>
+#include <units/reference.h>
+#include <units/si/units.h>
+
+namespace units::si {
+
+// clang-format off
+inline constexpr struct mass : system_reference<isq::mass_dim, kilogram> {} mass;
+inline constexpr struct mass_density : system_reference<isq::mass_density_dim, kilogram / cubic<metre>> {} mass_density;
+inline constexpr struct specific_volume : system_reference<isq::specific_volume_dim, cubic<metre> / kilogram> {} specific_volume;
+inline constexpr struct relative_mass_density : system_reference<isq::relative_mass_density_dim, one> {} relative_mass_density;
+inline constexpr struct surface_mass_density : system_reference<isq::surface_mass_density_dim, kilogram / square<metre>> {} surface_mass_density;
+inline constexpr struct linear_mass_density : system_reference<isq::linear_mass_density_dim, kilogram / metre> {} linear_mass_density;
+inline constexpr struct momentum : system_reference<isq::momentum_dim, kilogram * metre / second> {} momentum;
+inline constexpr struct force : system_reference<isq::force_dim, newton> {} force;
+// inline constexpr struct weight : system_reference<isq::weight_dim, newton> {} weight;
+inline constexpr struct impulse : system_reference<isq::impulse_dim, newton * second> {} impulse;
+inline constexpr struct angular_momentum : system_reference<isq::angular_momentum_dim, kilogram * square<metre> / second> {} angular_momentum;  // TODO radian?
+inline constexpr struct moment_of_inertia : system_reference<isq::moment_of_inertia_dim, kilogram * square<metre>> {} moment_of_inertia;
+inline constexpr struct moment_of_force : system_reference<isq::moment_of_force_dim, newton * metre> {} moment_of_force;
+inline constexpr struct torque : system_reference<isq::torque_dim, newton * metre> {} torque;
+inline constexpr struct angular_impulse : system_reference<isq::angular_impulse_dim, newton * metre * second> {} angular_impulse;
+inline constexpr struct pressure : system_reference<isq::pressure_dim, pascal> {} pressure;
+inline constexpr struct stress : system_reference<isq::stress_dim, pascal> {} stress;
+inline constexpr struct normal_stress : system_reference<isq::normal_stress_dim, pascal> {} normal_stress;
+inline constexpr struct strain : system_reference<isq::strain_dim, one> {} strain;
+inline constexpr struct poisson_number : system_reference<isq::poisson_number_dim, one> {} poisson_number;
+inline constexpr struct compressibility : system_reference<isq::compressibility_dim, 1 / pascal> {} compressibility;
+inline constexpr struct second_axial_moment_of_area : system_reference<isq::second_axial_moment_of_area_dim, square<metre> * square<metre>> {} second_axial_moment_of_area;
+inline constexpr struct section_modulus : system_reference<isq::section_modulus_dim, cubic<metre>> {} section_modulus;
+inline constexpr struct dynamic_viscosity : system_reference<isq::dynamic_viscosity_dim, pascal * second> {} dynamic_viscosity;
+inline constexpr struct kinematic_viscosity : system_reference<isq::kinematic_viscosity_dim, square<metre> / second> {} kinematic_viscosity;
+inline constexpr struct surface_tension : system_reference<isq::surface_tension_dim, newton / metre> {} surface_tension;
+inline constexpr struct power : system_reference<isq::power_dim, watt> {} power;
+inline constexpr struct efficiency : system_reference<isq::efficiency_dim, one> {} efficiency;
+inline constexpr struct mass_flow : system_reference<isq::mass_flow_dim, kilogram / (square<metre> * second)> {} mass_flow;
+inline constexpr struct mass_flow_rate : system_reference<isq::mass_flow_rate_dim, kilogram / second> {} mass_flow_rate;
+inline constexpr struct mass_change_rate : system_reference<isq::mass_change_rate_dim, kilogram / second> {} mass_change_rate;
+inline constexpr struct volume_flow_rate : system_reference<isq::volume_flow_rate_dim, cubic<metre> / second> {} volume_flow_rate;
+// inline constexpr struct action : system_reference<isq::action_dim, joule* second> {} action;  // TODO make it compile
+// clang-format on
+
+}  // namespace units::si
diff --git a/src/systems/si/include/units/si/prefixes.h b/src/systems/si/include/units/si/prefixes.h
new file mode 100644
index 00000000..f90bdbde
--- /dev/null
+++ b/src/systems/si/include/units/si/prefixes.h
@@ -0,0 +1,111 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2018 Mateusz Pusz
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#pragma once
+
+#include <units/unit.h>
+
+namespace units::si {
+
+template<NamedUnit auto U>
+struct yocto_ : prefixed_unit<"y", mag_power<10, -24>, U> {};
+template<NamedUnit auto U>
+struct zepto_ : prefixed_unit<"z", mag_power<10, -21>, U> {};
+template<NamedUnit auto U>
+struct atto_ : prefixed_unit<"a", mag_power<10, -18>, U> {};
+template<NamedUnit auto U>
+struct femto_ : prefixed_unit<"f", mag_power<10, -15>, U> {};
+template<NamedUnit auto U>
+struct pico_ : prefixed_unit<"p", mag_power<10, -12>, U> {};
+template<NamedUnit auto U>
+struct nano_ : prefixed_unit<"n", mag_power<10, -9>, U> {};
+template<NamedUnit auto U>
+struct micro_ : prefixed_unit<basic_symbol_text{"\u00b5", "u"}, mag_power<10, -6>, U> {};
+template<NamedUnit auto U>
+struct milli_ : prefixed_unit<"m", mag_power<10, -3>, U> {};
+template<NamedUnit auto U>
+struct centi_ : prefixed_unit<"c", mag_power<10, -2>, U> {};
+template<NamedUnit auto U>
+struct deci_ : prefixed_unit<"d", mag_power<10, -1>, U> {};
+template<NamedUnit auto U>
+struct deca_ : prefixed_unit<"da", mag_power<10, 1>, U> {};
+template<NamedUnit auto U>
+struct hecto_ : prefixed_unit<"h", mag_power<10, 2>, U> {};
+template<NamedUnit auto U>
+struct kilo_ : prefixed_unit<"k", mag_power<10, 3>, U> {};
+template<NamedUnit auto U>
+struct mega_ : prefixed_unit<"M", mag_power<10, 6>, U> {};
+template<NamedUnit auto U>
+struct giga_ : prefixed_unit<"G", mag_power<10, 9>, U> {};
+template<NamedUnit auto U>
+struct tera_ : prefixed_unit<"T", mag_power<10, 12>, U> {};
+template<NamedUnit auto U>
+struct peta_ : prefixed_unit<"P", mag_power<10, 15>, U> {};
+template<NamedUnit auto U>
+struct exa_ : prefixed_unit<"E", mag_power<10, 18>, U> {};
+template<NamedUnit auto U>
+struct zetta_ : prefixed_unit<"Z", mag_power<10, 21>, U> {};
+template<NamedUnit auto U>
+struct yotta_ : prefixed_unit<"Y", mag_power<10, 24>, U> {};
+
+template<NamedUnit auto U>
+inline constexpr yocto_<U> yocto;
+template<NamedUnit auto U>
+inline constexpr zepto_<U> zepto;
+template<NamedUnit auto U>
+inline constexpr atto_<U> atto;
+template<NamedUnit auto U>
+inline constexpr femto_<U> femto;
+template<NamedUnit auto U>
+inline constexpr pico_<U> pico;
+template<NamedUnit auto U>
+inline constexpr nano_<U> nano;
+template<NamedUnit auto U>
+inline constexpr micro_<U> micro;
+template<NamedUnit auto U>
+inline constexpr milli_<U> milli;
+template<NamedUnit auto U>
+inline constexpr centi_<U> centi;
+template<NamedUnit auto U>
+inline constexpr deci_<U> deci;
+template<NamedUnit auto U>
+inline constexpr deca_<U> deca;
+template<NamedUnit auto U>
+inline constexpr hecto_<U> hecto;
+template<NamedUnit auto U>
+inline constexpr kilo_<U> kilo;
+template<NamedUnit auto U>
+inline constexpr mega_<U> mega;
+template<NamedUnit auto U>
+inline constexpr giga_<U> giga;
+template<NamedUnit auto U>
+inline constexpr tera_<U> tera;
+template<NamedUnit auto U>
+inline constexpr peta_<U> peta;
+template<NamedUnit auto U>
+inline constexpr exa_<U> exa;
+template<NamedUnit auto U>
+inline constexpr zetta_<U> zetta;
+template<NamedUnit auto U>
+inline constexpr yotta_<U> yotta;
+
+}  // namespace units::si
diff --git a/src/systems/isq/include/units/isq/dimensions/luminous_intensity.h b/src/systems/si/include/units/si/si.h
similarity index 81%
rename from src/systems/isq/include/units/isq/dimensions/luminous_intensity.h
rename to src/systems/si/include/units/si/si.h
index fb04a3fe..70878f77 100644
--- a/src/systems/isq/include/units/isq/dimensions/luminous_intensity.h
+++ b/src/systems/si/include/units/si/si.h
@@ -22,14 +22,11 @@
 
 #pragma once
 
-#include <units/concepts.h>
-
-namespace units::isq {
-
-template<Unit U>
-struct dim_luminous_intensity : base_dimension<"J", U> {};
-
-template<typename T>
-concept LuminousIntensity = QuantityOfT<T, dim_luminous_intensity>;
-
-}  // namespace units::isq
+#include <units/si/base_quantities.h>
+#include <units/si/constants.h>
+#include <units/si/mechanics.h>
+#include <units/si/prefixes.h>
+#include <units/si/space_and_time.h>
+#include <units/si/thermodynamics.h>
+#include <units/si/unit_symbols.h>
+#include <units/si/units.h>
diff --git a/src/systems/si/include/units/si/space_and_time.h b/src/systems/si/include/units/si/space_and_time.h
new file mode 100644
index 00000000..697429d0
--- /dev/null
+++ b/src/systems/si/include/units/si/space_and_time.h
@@ -0,0 +1,64 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2018 Mateusz Pusz
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#pragma once
+
+#include <units/isq/space_and_time.h>
+#include <units/reference.h>
+#include <units/si/units.h>
+
+namespace units::si {
+
+// clang-format off
+inline constexpr struct length : system_reference<isq::length_dim, metre> {} length;
+inline constexpr struct curvature : system_reference<isq::curvature_dim, 1 / metre> {} curvature;
+inline constexpr struct area : system_reference<isq::area_dim, square<metre>> {} area;
+inline constexpr struct volume : system_reference<isq::volume_dim, cubic<metre>> {} volume;
+inline constexpr struct angular_measure : system_reference<isq::angular_measure_dim, radian> {} angular_measure;
+inline constexpr struct angular_displacement : system_reference<isq::angular_displacement_dim, radian> {} angular_displacement;
+inline constexpr struct phase_angle : system_reference<isq::phase_angle_dim, radian> {} phase_angle;
+inline constexpr struct solid_angular_measure : system_reference<isq::solid_angular_measure_dim, steradian> {} solid_angular_measure;
+inline constexpr struct time : system_reference<isq::time_dim, second> {} time;  // TODO called duration in ISO 80000
+// TODO there is also a velocity in ISO 80000
+inline constexpr struct speed : system_reference<isq::speed_dim, metre / second> {} speed;
+inline constexpr struct acceleration : system_reference<isq::acceleration_dim, metre / square<second>> {} acceleration;
+inline constexpr struct angular_velocity : system_reference<isq::angular_velocity_dim, radian / second> {} angular_velocity;
+inline constexpr struct angular_acceleration : system_reference<isq::angular_acceleration_dim, radian / square<second>> {} angular_acceleration;
+inline constexpr struct period_duration : system_reference<isq::period_duration_dim, second> {} period_duration;
+inline constexpr struct time_constant : system_reference<isq::time_constant_dim, second> {} time_constant;
+inline constexpr struct rotation : system_reference<isq::rotation_dim, one> {} rotation;
+inline constexpr struct frequency : system_reference<isq::frequency_dim, hertz> {} frequency;
+inline constexpr struct rotational_frequency : system_reference<isq::rotational_frequency_dim, hertz> {} rotational_frequency;
+inline constexpr struct angular_frequency : system_reference<isq::angular_frequency_dim, radian / second> {} angular_frequency;
+inline constexpr struct wavelength : system_reference<isq::wavelength_dim, metre> {} wavelength;
+inline constexpr struct repetency : system_reference<isq::repetency_dim, 1 / metre> {} repetency;
+inline constexpr struct wave_vector : system_reference<isq::wave_vector_dim, 1 / metre> {} wave_vector;
+inline constexpr struct angular_repetency : system_reference<isq::angular_repetency_dim, 1 / metre> {} angular_repetency;
+inline constexpr struct phase_velocity : system_reference<isq::phase_velocity_dim, metre / second> {} phase_velocity;
+inline constexpr struct damping_coefficient : system_reference<isq::damping_coefficient_dim, 1 / second> {} damping_coefficient;
+inline constexpr struct logarithmic_decrement : system_reference<isq::logarithmic_decrement_dim, one> {} logarithmic_decrement;
+inline constexpr struct attenuation : system_reference<isq::attenuation_dim, 1 / metre> {} attenuation;
+inline constexpr struct phase_coefficient : system_reference<isq::phase_coefficient_dim, radian / metre> {} phase_coefficient;
+inline constexpr struct propagation_coefficient : system_reference<isq::propagation_coefficient_dim, 1 / metre> {} propagation_coefficient;
+// clang-format on
+
+}  // namespace units::si
diff --git a/src/systems/isq/include/units/isq/dimensions/area.h b/src/systems/si/include/units/si/thermodynamics.h
similarity index 71%
rename from src/systems/isq/include/units/isq/dimensions/area.h
rename to src/systems/si/include/units/si/thermodynamics.h
index f03a4209..33538eb9 100644
--- a/src/systems/isq/include/units/isq/dimensions/area.h
+++ b/src/systems/si/include/units/si/thermodynamics.h
@@ -22,18 +22,18 @@
 
 #pragma once
 
-#include <units/concepts.h>
-#include <units/isq/dimensions/length.h>
+#include <units/isq/mechanics.h>
+// #include <units/isq/space_and_time.h>
+#include <units/isq/thermodynamics.h>
+#include <units/reference.h>
+#include <units/si/units.h>
 
-namespace units::isq {
+namespace units::si {
 
-template<typename Child, Unit U, typename...>
-struct dim_area;
+// inline constexpr struct thermodynamic_temperature : system_reference<isq::thermodynamic_temperature_dim, kelvin> {}
+// thermodynamic_temperature;
 
-template<typename Child, Unit U, DimensionOfT<dim_length> L>
-struct dim_area<Child, U, L> : derived_dimension<Child, U, exponent<L, 2>> {};
+inline constexpr struct energy : system_reference<isq::energy_dim, joule> {
+} energy;
 
-template<typename T>
-concept Area = QuantityOfT<T, dim_area>;
-
-}  // namespace units::isq
+}  // namespace units::si
diff --git a/src/systems/si/include/units/si/unit_symbols.h b/src/systems/si/include/units/si/unit_symbols.h
new file mode 100644
index 00000000..49a4418b
--- /dev/null
+++ b/src/systems/si/include/units/si/unit_symbols.h
@@ -0,0 +1,637 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2018 Mateusz Pusz
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#pragma once
+
+#include <units/si/prefixes.h>
+#include <units/si/units.h>
+
+namespace units::si::unit_symbols {
+
+inline constexpr auto ym = yocto<metre>;
+inline constexpr auto zm = zepto<metre>;
+inline constexpr auto am = atto<metre>;
+inline constexpr auto fm = femto<metre>;
+inline constexpr auto pm = pico<metre>;
+inline constexpr auto nm = nano<metre>;
+inline constexpr auto um = micro<metre>;
+inline constexpr auto mm = milli<metre>;
+inline constexpr auto cm = centi<metre>;
+inline constexpr auto dm = deci<metre>;
+inline constexpr auto m = metre;
+inline constexpr auto dam = deca<metre>;
+inline constexpr auto hm = hecto<metre>;
+inline constexpr auto km = kilo<metre>;
+inline constexpr auto Mm = mega<metre>;
+inline constexpr auto Gm = giga<metre>;
+inline constexpr auto Tm = tera<metre>;
+inline constexpr auto Pm = peta<metre>;
+inline constexpr auto Em = exa<metre>;
+inline constexpr auto Zm = zetta<metre>;
+inline constexpr auto Ym = yotta<metre>;
+
+inline constexpr auto ys = yocto<second>;
+inline constexpr auto zs = zepto<second>;
+inline constexpr auto as = atto<second>;
+inline constexpr auto fs = femto<second>;
+inline constexpr auto ps = pico<second>;
+inline constexpr auto ns = nano<second>;
+inline constexpr auto us = micro<second>;
+inline constexpr auto ms = milli<second>;
+inline constexpr auto cs = centi<second>;
+inline constexpr auto ds = deci<second>;
+inline constexpr auto s = second;
+inline constexpr auto das = deca<second>;
+inline constexpr auto hs = hecto<second>;
+inline constexpr auto ks = kilo<second>;
+inline constexpr auto Ms = mega<second>;
+inline constexpr auto Gs = giga<second>;
+inline constexpr auto Ts = tera<second>;
+inline constexpr auto Ps = peta<second>;
+inline constexpr auto Es = exa<second>;
+inline constexpr auto Zs = zetta<second>;
+inline constexpr auto Ys = yotta<second>;
+
+inline constexpr auto yg = yocto<gram>;
+inline constexpr auto zg = zepto<gram>;
+inline constexpr auto ag = atto<gram>;
+inline constexpr auto fg = femto<gram>;
+inline constexpr auto pg = pico<gram>;
+inline constexpr auto ng = nano<gram>;
+inline constexpr auto ug = micro<gram>;
+inline constexpr auto mg = milli<gram>;
+inline constexpr auto cg = centi<gram>;
+inline constexpr auto dg = deci<gram>;
+inline constexpr auto g = gram;
+inline constexpr auto dag = deca<gram>;
+inline constexpr auto hg = hecto<gram>;
+inline constexpr auto kg = kilo<gram>;
+inline constexpr auto Mg = mega<gram>;
+inline constexpr auto Gg = giga<gram>;
+inline constexpr auto Tg = tera<gram>;
+inline constexpr auto Pg = peta<gram>;
+inline constexpr auto Eg = exa<gram>;
+inline constexpr auto Zg = zetta<gram>;
+inline constexpr auto Yg = yotta<gram>;
+
+inline constexpr auto yA = yocto<ampere>;
+inline constexpr auto zA = zepto<ampere>;
+inline constexpr auto aA = atto<ampere>;
+inline constexpr auto fA = femto<ampere>;
+inline constexpr auto pA = pico<ampere>;
+inline constexpr auto nA = nano<ampere>;
+inline constexpr auto uA = micro<ampere>;
+inline constexpr auto mA = milli<ampere>;
+inline constexpr auto cA = centi<ampere>;
+inline constexpr auto dA = deci<ampere>;
+inline constexpr auto A = ampere;
+inline constexpr auto daA = deca<ampere>;
+inline constexpr auto hA = hecto<ampere>;
+inline constexpr auto kA = kilo<ampere>;
+inline constexpr auto MA = mega<ampere>;
+inline constexpr auto GA = giga<ampere>;
+inline constexpr auto TA = tera<ampere>;
+inline constexpr auto PA = peta<ampere>;
+inline constexpr auto EA = exa<ampere>;
+inline constexpr auto ZA = zetta<ampere>;
+inline constexpr auto YA = yotta<ampere>;
+
+inline constexpr auto yK = yocto<kelvin>;
+inline constexpr auto zK = zepto<kelvin>;
+inline constexpr auto aK = atto<kelvin>;
+inline constexpr auto fK = femto<kelvin>;
+inline constexpr auto pK = pico<kelvin>;
+inline constexpr auto nK = nano<kelvin>;
+inline constexpr auto uK = micro<kelvin>;
+inline constexpr auto mK = milli<kelvin>;
+inline constexpr auto cK = centi<kelvin>;
+inline constexpr auto dK = deci<kelvin>;
+inline constexpr auto K = kelvin;
+inline constexpr auto daK = deca<kelvin>;
+inline constexpr auto hK = hecto<kelvin>;
+inline constexpr auto kK = kilo<kelvin>;
+inline constexpr auto MK = mega<kelvin>;
+inline constexpr auto GK = giga<kelvin>;
+inline constexpr auto TK = tera<kelvin>;
+inline constexpr auto PK = peta<kelvin>;
+inline constexpr auto EK = exa<kelvin>;
+inline constexpr auto ZK = zetta<kelvin>;
+inline constexpr auto YK = yotta<kelvin>;
+
+inline constexpr auto ymol = yocto<mole>;
+inline constexpr auto zmol = zepto<mole>;
+inline constexpr auto amol = atto<mole>;
+inline constexpr auto fmol = femto<mole>;
+inline constexpr auto pmol = pico<mole>;
+inline constexpr auto nmol = nano<mole>;
+inline constexpr auto umol = micro<mole>;
+inline constexpr auto mmol = milli<mole>;
+inline constexpr auto cmol = centi<mole>;
+inline constexpr auto dmol = deci<mole>;
+inline constexpr auto mol = mole;
+inline constexpr auto damol = deca<mole>;
+inline constexpr auto hmol = hecto<mole>;
+inline constexpr auto kmol = kilo<mole>;
+inline constexpr auto Mmol = mega<mole>;
+inline constexpr auto Gmol = giga<mole>;
+inline constexpr auto Tmol = tera<mole>;
+inline constexpr auto Pmol = peta<mole>;
+inline constexpr auto Emol = exa<mole>;
+inline constexpr auto Zmol = zetta<mole>;
+inline constexpr auto Ymol = yotta<mole>;
+
+inline constexpr auto ycd = yocto<candela>;
+inline constexpr auto zcd = zepto<candela>;
+inline constexpr auto acd = atto<candela>;
+inline constexpr auto fcd = femto<candela>;
+inline constexpr auto pcd = pico<candela>;
+inline constexpr auto ncd = nano<candela>;
+inline constexpr auto ucd = micro<candela>;
+inline constexpr auto mcd = milli<candela>;
+inline constexpr auto ccd = centi<candela>;
+inline constexpr auto dcd = deci<candela>;
+inline constexpr auto cd = candela;
+inline constexpr auto dacd = deca<candela>;
+inline constexpr auto hcd = hecto<candela>;
+inline constexpr auto kcd = kilo<candela>;
+inline constexpr auto Mcd = mega<candela>;
+inline constexpr auto Gcd = giga<candela>;
+inline constexpr auto Tcd = tera<candela>;
+inline constexpr auto Pcd = peta<candela>;
+inline constexpr auto Ecd = exa<candela>;
+inline constexpr auto Zcd = zetta<candela>;
+inline constexpr auto Ycd = yotta<candela>;
+
+inline constexpr auto yrad = yocto<radian>;
+inline constexpr auto zrad = zepto<radian>;
+inline constexpr auto arad = atto<radian>;
+inline constexpr auto frad = femto<radian>;
+inline constexpr auto prad = pico<radian>;
+inline constexpr auto nrad = nano<radian>;
+inline constexpr auto urad = micro<radian>;
+inline constexpr auto mrad = milli<radian>;
+inline constexpr auto crad = centi<radian>;
+inline constexpr auto drad = deci<radian>;
+inline constexpr auto rad = radian;
+inline constexpr auto darad = deca<radian>;
+inline constexpr auto hrad = hecto<radian>;
+inline constexpr auto krad = kilo<radian>;
+inline constexpr auto Mrad = mega<radian>;
+inline constexpr auto Grad = giga<radian>;
+inline constexpr auto Trad = tera<radian>;
+inline constexpr auto Prad = peta<radian>;
+inline constexpr auto Erad = exa<radian>;
+inline constexpr auto Zrad = zetta<radian>;
+inline constexpr auto Yrad = yotta<radian>;
+
+inline constexpr auto ysr = yocto<steradian>;
+inline constexpr auto zsr = zepto<steradian>;
+inline constexpr auto asr = atto<steradian>;
+inline constexpr auto fsr = femto<steradian>;
+inline constexpr auto psr = pico<steradian>;
+inline constexpr auto nsr = nano<steradian>;
+inline constexpr auto usr = micro<steradian>;
+inline constexpr auto msr = milli<steradian>;
+inline constexpr auto csr = centi<steradian>;
+inline constexpr auto dsr = deci<steradian>;
+inline constexpr auto sr = steradian;
+inline constexpr auto dasr = deca<steradian>;
+inline constexpr auto hsr = hecto<steradian>;
+inline constexpr auto ksr = kilo<steradian>;
+inline constexpr auto Msr = mega<steradian>;
+inline constexpr auto Gsr = giga<steradian>;
+inline constexpr auto Tsr = tera<steradian>;
+inline constexpr auto Psr = peta<steradian>;
+inline constexpr auto Esr = exa<steradian>;
+inline constexpr auto Zsr = zetta<steradian>;
+inline constexpr auto Ysr = yotta<steradian>;
+
+inline constexpr auto yHz = yocto<hertz>;
+inline constexpr auto zHz = zepto<hertz>;
+inline constexpr auto aHz = atto<hertz>;
+inline constexpr auto fHz = femto<hertz>;
+inline constexpr auto pHz = pico<hertz>;
+inline constexpr auto nHz = nano<hertz>;
+inline constexpr auto uHz = micro<hertz>;
+inline constexpr auto mHz = milli<hertz>;
+inline constexpr auto cHz = centi<hertz>;
+inline constexpr auto dHz = deci<hertz>;
+inline constexpr auto Hz = hertz;
+inline constexpr auto daHz = deca<hertz>;
+inline constexpr auto hHz = hecto<hertz>;
+inline constexpr auto kHz = kilo<hertz>;
+inline constexpr auto MHz = mega<hertz>;
+inline constexpr auto GHz = giga<hertz>;
+inline constexpr auto THz = tera<hertz>;
+inline constexpr auto PHz = peta<hertz>;
+inline constexpr auto EHz = exa<hertz>;
+inline constexpr auto ZHz = zetta<hertz>;
+inline constexpr auto YHz = yotta<hertz>;
+
+inline constexpr auto yN = yocto<newton>;
+inline constexpr auto zN = zepto<newton>;
+inline constexpr auto aN = atto<newton>;
+inline constexpr auto fN = femto<newton>;
+inline constexpr auto pN = pico<newton>;
+inline constexpr auto nN = nano<newton>;
+inline constexpr auto uN = micro<newton>;
+inline constexpr auto mN = milli<newton>;
+inline constexpr auto cN = centi<newton>;
+inline constexpr auto dN = deci<newton>;
+inline constexpr auto N = newton;
+inline constexpr auto daN = deca<newton>;
+inline constexpr auto hN = hecto<newton>;
+inline constexpr auto kN = kilo<newton>;
+inline constexpr auto MN = mega<newton>;
+inline constexpr auto GN = giga<newton>;
+inline constexpr auto TN = tera<newton>;
+inline constexpr auto PN = peta<newton>;
+inline constexpr auto EN = exa<newton>;
+inline constexpr auto ZN = zetta<newton>;
+inline constexpr auto YN = yotta<newton>;
+
+inline constexpr auto yPa = yocto<pascal>;
+inline constexpr auto zPa = zepto<pascal>;
+inline constexpr auto aPa = atto<pascal>;
+inline constexpr auto fPa = femto<pascal>;
+inline constexpr auto pPa = pico<pascal>;
+inline constexpr auto nPa = nano<pascal>;
+inline constexpr auto uPa = micro<pascal>;
+inline constexpr auto mPa = milli<pascal>;
+inline constexpr auto cPa = centi<pascal>;
+inline constexpr auto dPa = deci<pascal>;
+inline constexpr auto Pa = pascal;
+inline constexpr auto daPa = deca<pascal>;
+inline constexpr auto hPa = hecto<pascal>;
+inline constexpr auto kPa = kilo<pascal>;
+inline constexpr auto MPa = mega<pascal>;
+inline constexpr auto GPa = giga<pascal>;
+inline constexpr auto TPa = tera<pascal>;
+inline constexpr auto PPa = peta<pascal>;
+inline constexpr auto EPa = exa<pascal>;
+inline constexpr auto ZPa = zetta<pascal>;
+inline constexpr auto YPa = yotta<pascal>;
+
+inline constexpr auto yJ = yocto<joule>;
+inline constexpr auto zJ = zepto<joule>;
+inline constexpr auto aJ = atto<joule>;
+inline constexpr auto fJ = femto<joule>;
+inline constexpr auto pJ = pico<joule>;
+inline constexpr auto nJ = nano<joule>;
+inline constexpr auto uJ = micro<joule>;
+inline constexpr auto mJ = milli<joule>;
+inline constexpr auto cJ = centi<joule>;
+inline constexpr auto dJ = deci<joule>;
+inline constexpr auto J = joule;
+inline constexpr auto daJ = deca<joule>;
+inline constexpr auto hJ = hecto<joule>;
+inline constexpr auto kJ = kilo<joule>;
+inline constexpr auto MJ = mega<joule>;
+inline constexpr auto GJ = giga<joule>;
+inline constexpr auto TJ = tera<joule>;
+inline constexpr auto PJ = peta<joule>;
+inline constexpr auto EJ = exa<joule>;
+inline constexpr auto ZJ = zetta<joule>;
+inline constexpr auto YJ = yotta<joule>;
+
+inline constexpr auto yW = yocto<watt>;
+inline constexpr auto zW = zepto<watt>;
+inline constexpr auto aW = atto<watt>;
+inline constexpr auto fW = femto<watt>;
+inline constexpr auto pW = pico<watt>;
+inline constexpr auto nW = nano<watt>;
+inline constexpr auto uW = micro<watt>;
+inline constexpr auto mW = milli<watt>;
+inline constexpr auto cW = centi<watt>;
+inline constexpr auto dW = deci<watt>;
+inline constexpr auto W = watt;
+inline constexpr auto daW = deca<watt>;
+inline constexpr auto hW = hecto<watt>;
+inline constexpr auto kW = kilo<watt>;
+inline constexpr auto MW = mega<watt>;
+inline constexpr auto GW = giga<watt>;
+inline constexpr auto TW = tera<watt>;
+inline constexpr auto PW = peta<watt>;
+inline constexpr auto EW = exa<watt>;
+inline constexpr auto ZW = zetta<watt>;
+inline constexpr auto YW = yotta<watt>;
+
+inline constexpr auto yC = yocto<coulomb>;
+inline constexpr auto zC = zepto<coulomb>;
+inline constexpr auto aC = atto<coulomb>;
+inline constexpr auto fC = femto<coulomb>;
+inline constexpr auto pC = pico<coulomb>;
+inline constexpr auto nC = nano<coulomb>;
+inline constexpr auto uC = micro<coulomb>;
+inline constexpr auto mC = milli<coulomb>;
+inline constexpr auto cC = centi<coulomb>;
+inline constexpr auto dC = deci<coulomb>;
+inline constexpr auto C = coulomb;
+inline constexpr auto daC = deca<coulomb>;
+inline constexpr auto hC = hecto<coulomb>;
+inline constexpr auto kC = kilo<coulomb>;
+inline constexpr auto MC = mega<coulomb>;
+inline constexpr auto GC = giga<coulomb>;
+inline constexpr auto TC = tera<coulomb>;
+inline constexpr auto PC = peta<coulomb>;
+inline constexpr auto EC = exa<coulomb>;
+inline constexpr auto ZC = zetta<coulomb>;
+inline constexpr auto YC = yotta<coulomb>;
+
+inline constexpr auto yV = yocto<volt>;
+inline constexpr auto zV = zepto<volt>;
+inline constexpr auto aV = atto<volt>;
+inline constexpr auto fV = femto<volt>;
+inline constexpr auto pV = pico<volt>;
+inline constexpr auto nV = nano<volt>;
+inline constexpr auto uV = micro<volt>;
+inline constexpr auto mV = milli<volt>;
+inline constexpr auto cV = centi<volt>;
+inline constexpr auto dV = deci<volt>;
+inline constexpr auto V = volt;
+inline constexpr auto daV = deca<volt>;
+inline constexpr auto hV = hecto<volt>;
+inline constexpr auto kV = kilo<volt>;
+inline constexpr auto MV = mega<volt>;
+inline constexpr auto GV = giga<volt>;
+inline constexpr auto TV = tera<volt>;
+inline constexpr auto PV = peta<volt>;
+inline constexpr auto EV = exa<volt>;
+inline constexpr auto ZV = zetta<volt>;
+inline constexpr auto YV = yotta<volt>;
+
+inline constexpr auto yF = yocto<farad>;
+inline constexpr auto zF = zepto<farad>;
+inline constexpr auto aF = atto<farad>;
+inline constexpr auto fF = femto<farad>;
+inline constexpr auto pF = pico<farad>;
+inline constexpr auto nF = nano<farad>;
+inline constexpr auto uF = micro<farad>;
+inline constexpr auto mF = milli<farad>;
+inline constexpr auto cF = centi<farad>;
+inline constexpr auto dF = deci<farad>;
+inline constexpr auto F = farad;
+inline constexpr auto daF = deca<farad>;
+inline constexpr auto hF = hecto<farad>;
+inline constexpr auto kF = kilo<farad>;
+inline constexpr auto MF = mega<farad>;
+inline constexpr auto GF = giga<farad>;
+inline constexpr auto TF = tera<farad>;
+inline constexpr auto PF = peta<farad>;
+inline constexpr auto EF = exa<farad>;
+inline constexpr auto ZF = zetta<farad>;
+inline constexpr auto YF = yotta<farad>;
+
+inline constexpr auto yS = yocto<siemens>;
+inline constexpr auto zS = zepto<siemens>;
+inline constexpr auto aS = atto<siemens>;
+inline constexpr auto fS = femto<siemens>;
+inline constexpr auto pS = pico<siemens>;
+inline constexpr auto nS = nano<siemens>;
+inline constexpr auto uS = micro<siemens>;
+inline constexpr auto mS = milli<siemens>;
+inline constexpr auto cS = centi<siemens>;
+inline constexpr auto dS = deci<siemens>;
+inline constexpr auto S = siemens;
+inline constexpr auto daS = deca<siemens>;
+inline constexpr auto hS = hecto<siemens>;
+inline constexpr auto kS = kilo<siemens>;
+inline constexpr auto MS = mega<siemens>;
+inline constexpr auto GS = giga<siemens>;
+inline constexpr auto TS = tera<siemens>;
+inline constexpr auto PS = peta<siemens>;
+inline constexpr auto ES = exa<siemens>;
+inline constexpr auto ZS = zetta<siemens>;
+inline constexpr auto YS = yotta<siemens>;
+
+inline constexpr auto yWb = yocto<weber>;
+inline constexpr auto zWb = zepto<weber>;
+inline constexpr auto aWb = atto<weber>;
+inline constexpr auto fWb = femto<weber>;
+inline constexpr auto pWb = pico<weber>;
+inline constexpr auto nWb = nano<weber>;
+inline constexpr auto uWb = micro<weber>;
+inline constexpr auto mWb = milli<weber>;
+inline constexpr auto cWb = centi<weber>;
+inline constexpr auto dWb = deci<weber>;
+inline constexpr auto Wb = weber;
+inline constexpr auto daWb = deca<weber>;
+inline constexpr auto hWb = hecto<weber>;
+inline constexpr auto kWb = kilo<weber>;
+inline constexpr auto MWb = mega<weber>;
+inline constexpr auto GWb = giga<weber>;
+inline constexpr auto TWb = tera<weber>;
+inline constexpr auto PWb = peta<weber>;
+inline constexpr auto EWb = exa<weber>;
+inline constexpr auto ZWb = zetta<weber>;
+inline constexpr auto YWb = yotta<weber>;
+
+inline constexpr auto yT = yocto<tesla>;
+inline constexpr auto zT = zepto<tesla>;
+inline constexpr auto aT = atto<tesla>;
+inline constexpr auto fT = femto<tesla>;
+inline constexpr auto pT = pico<tesla>;
+inline constexpr auto nT = nano<tesla>;
+inline constexpr auto uT = micro<tesla>;
+inline constexpr auto mT = milli<tesla>;
+inline constexpr auto cT = centi<tesla>;
+inline constexpr auto dT = deci<tesla>;
+inline constexpr auto T = tesla;
+inline constexpr auto daT = deca<tesla>;
+inline constexpr auto hT = hecto<tesla>;
+inline constexpr auto kT = kilo<tesla>;
+inline constexpr auto MT = mega<tesla>;
+inline constexpr auto GT = giga<tesla>;
+inline constexpr auto TT = tera<tesla>;
+inline constexpr auto PT = peta<tesla>;
+inline constexpr auto ET = exa<tesla>;
+inline constexpr auto ZT = zetta<tesla>;
+inline constexpr auto YT = yotta<tesla>;
+
+inline constexpr auto yH = yocto<henry>;
+inline constexpr auto zH = zepto<henry>;
+inline constexpr auto aH = atto<henry>;
+inline constexpr auto fH = femto<henry>;
+inline constexpr auto pH = pico<henry>;
+inline constexpr auto nH = nano<henry>;
+inline constexpr auto uH = micro<henry>;
+inline constexpr auto mH = milli<henry>;
+inline constexpr auto cH = centi<henry>;
+inline constexpr auto dH = deci<henry>;
+inline constexpr auto H = henry;
+inline constexpr auto daH = deca<henry>;
+inline constexpr auto hH = hecto<henry>;
+inline constexpr auto kH = kilo<henry>;
+inline constexpr auto MH = mega<henry>;
+inline constexpr auto GH = giga<henry>;
+inline constexpr auto TH = tera<henry>;
+inline constexpr auto PH = peta<henry>;
+inline constexpr auto EH = exa<henry>;
+inline constexpr auto ZH = zetta<henry>;
+inline constexpr auto YH = yotta<henry>;
+
+inline constexpr auto deg_C = degree_Celsius;
+
+inline constexpr auto ylm = yocto<lumen>;
+inline constexpr auto zlm = zepto<lumen>;
+inline constexpr auto alm = atto<lumen>;
+inline constexpr auto flm = femto<lumen>;
+inline constexpr auto plm = pico<lumen>;
+inline constexpr auto nlm = nano<lumen>;
+inline constexpr auto ulm = micro<lumen>;
+inline constexpr auto mlm = milli<lumen>;
+inline constexpr auto clm = centi<lumen>;
+inline constexpr auto dlm = deci<lumen>;
+inline constexpr auto lm = lumen;
+inline constexpr auto dalm = deca<lumen>;
+inline constexpr auto hlm = hecto<lumen>;
+inline constexpr auto klm = kilo<lumen>;
+inline constexpr auto Mlm = mega<lumen>;
+inline constexpr auto Glm = giga<lumen>;
+inline constexpr auto Tlm = tera<lumen>;
+inline constexpr auto Plm = peta<lumen>;
+inline constexpr auto Elm = exa<lumen>;
+inline constexpr auto Zlm = zetta<lumen>;
+inline constexpr auto Ylm = yotta<lumen>;
+
+inline constexpr auto ylx = yocto<lux>;
+inline constexpr auto zlx = zepto<lux>;
+inline constexpr auto alx = atto<lux>;
+inline constexpr auto flx = femto<lux>;
+inline constexpr auto plx = pico<lux>;
+inline constexpr auto nlx = nano<lux>;
+inline constexpr auto ulx = micro<lux>;
+inline constexpr auto mlx = milli<lux>;
+inline constexpr auto clx = centi<lux>;
+inline constexpr auto dlx = deci<lux>;
+inline constexpr auto lx = lux;
+inline constexpr auto dalx = deca<lux>;
+inline constexpr auto hlx = hecto<lux>;
+inline constexpr auto klx = kilo<lux>;
+inline constexpr auto Mlx = mega<lux>;
+inline constexpr auto Glx = giga<lux>;
+inline constexpr auto Tlx = tera<lux>;
+inline constexpr auto Plx = peta<lux>;
+inline constexpr auto Elx = exa<lux>;
+inline constexpr auto Zlx = zetta<lux>;
+inline constexpr auto Ylx = yotta<lux>;
+
+inline constexpr auto yBq = yocto<becquerel>;
+inline constexpr auto zBq = zepto<becquerel>;
+inline constexpr auto aBq = atto<becquerel>;
+inline constexpr auto fBq = femto<becquerel>;
+inline constexpr auto pBq = pico<becquerel>;
+inline constexpr auto nBq = nano<becquerel>;
+inline constexpr auto uBq = micro<becquerel>;
+inline constexpr auto mBq = milli<becquerel>;
+inline constexpr auto cBq = centi<becquerel>;
+inline constexpr auto dBq = deci<becquerel>;
+inline constexpr auto Bq = becquerel;
+inline constexpr auto daBq = deca<becquerel>;
+inline constexpr auto hBq = hecto<becquerel>;
+inline constexpr auto kBq = kilo<becquerel>;
+inline constexpr auto MBq = mega<becquerel>;
+inline constexpr auto GBq = giga<becquerel>;
+inline constexpr auto TBq = tera<becquerel>;
+inline constexpr auto PBq = peta<becquerel>;
+inline constexpr auto EBq = exa<becquerel>;
+inline constexpr auto ZBq = zetta<becquerel>;
+inline constexpr auto YBq = yotta<becquerel>;
+
+inline constexpr auto yGy = yocto<gray>;
+inline constexpr auto zGy = zepto<gray>;
+inline constexpr auto aGy = atto<gray>;
+inline constexpr auto fGy = femto<gray>;
+inline constexpr auto pGy = pico<gray>;
+inline constexpr auto nGy = nano<gray>;
+inline constexpr auto uGy = micro<gray>;
+inline constexpr auto mGy = milli<gray>;
+inline constexpr auto cGy = centi<gray>;
+inline constexpr auto dGy = deci<gray>;
+inline constexpr auto Gy = gray;
+inline constexpr auto daGy = deca<gray>;
+inline constexpr auto hGy = hecto<gray>;
+inline constexpr auto kGy = kilo<gray>;
+inline constexpr auto MGy = mega<gray>;
+inline constexpr auto GGy = giga<gray>;
+inline constexpr auto TGy = tera<gray>;
+inline constexpr auto PGy = peta<gray>;
+inline constexpr auto EGy = exa<gray>;
+inline constexpr auto ZGy = zetta<gray>;
+inline constexpr auto YGy = yotta<gray>;
+
+inline constexpr auto ySv = yocto<sievert>;
+inline constexpr auto zSv = zepto<sievert>;
+inline constexpr auto aSv = atto<sievert>;
+inline constexpr auto fSv = femto<sievert>;
+inline constexpr auto pSv = pico<sievert>;
+inline constexpr auto nSv = nano<sievert>;
+inline constexpr auto uSv = micro<sievert>;
+inline constexpr auto mSv = milli<sievert>;
+inline constexpr auto cSv = centi<sievert>;
+inline constexpr auto dSv = deci<sievert>;
+inline constexpr auto Sv = sievert;
+inline constexpr auto daSv = deca<sievert>;
+inline constexpr auto hSv = hecto<sievert>;
+inline constexpr auto kSv = kilo<sievert>;
+inline constexpr auto MSv = mega<sievert>;
+inline constexpr auto GSv = giga<sievert>;
+inline constexpr auto TSv = tera<sievert>;
+inline constexpr auto PSv = peta<sievert>;
+inline constexpr auto ESv = exa<sievert>;
+inline constexpr auto ZSv = zetta<sievert>;
+inline constexpr auto YSv = yotta<sievert>;
+
+inline constexpr auto ykat = yocto<katal>;
+inline constexpr auto zkat = zepto<katal>;
+inline constexpr auto akat = atto<katal>;
+inline constexpr auto fkat = femto<katal>;
+inline constexpr auto pkat = pico<katal>;
+inline constexpr auto nkat = nano<katal>;
+inline constexpr auto ukat = micro<katal>;
+inline constexpr auto mkat = milli<katal>;
+inline constexpr auto ckat = centi<katal>;
+inline constexpr auto dkat = deci<katal>;
+inline constexpr auto kat = katal;
+inline constexpr auto dakat = deca<katal>;
+inline constexpr auto hkat = hecto<katal>;
+inline constexpr auto kkat = kilo<katal>;
+inline constexpr auto Mkat = mega<katal>;
+inline constexpr auto Gkat = giga<katal>;
+inline constexpr auto Tkat = tera<katal>;
+inline constexpr auto Pkat = peta<katal>;
+inline constexpr auto Ekat = exa<katal>;
+inline constexpr auto Zkat = zetta<katal>;
+inline constexpr auto Ykat = yotta<katal>;
+
+inline constexpr auto min = minute;
+inline constexpr auto h = hour;
+inline constexpr auto d = day;
+inline constexpr auto au = astronomical_unit;
+inline constexpr auto a = are;
+inline constexpr auto ha = hectare;
+inline constexpr auto l = litre;
+inline constexpr auto t = tonne;
+inline constexpr auto Da = dalton;
+inline constexpr auto eV = electronvolt;
+
+}  // namespace units::si::unit_symbols
diff --git a/src/systems/si/include/units/si/units.h b/src/systems/si/include/units/si/units.h
new file mode 100644
index 00000000..2768c444
--- /dev/null
+++ b/src/systems/si/include/units/si/units.h
@@ -0,0 +1,88 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2018 Mateusz Pusz
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#pragma once
+
+#include <units/si/prefixes.h>
+#include <units/unit.h>
+
+namespace units::si {
+
+// clang-format off
+// base units
+inline constexpr struct second : named_unit<"s"> {} second;
+inline constexpr struct metre : named_unit<"m"> {} metre;
+inline constexpr struct gram : named_unit<"g"> {} gram;
+inline constexpr struct kilogram : decltype(kilo<gram>) {} kilogram;
+inline constexpr struct ampere : named_unit<"A"> {} ampere;
+inline constexpr struct kelvin : named_unit<"K"> {} kelvin;
+inline constexpr struct mole : named_unit<"mol"> {} mole;
+inline constexpr struct candela : named_unit<"cd"> {} candela;
+
+// derived named units
+inline constexpr struct radian : named_unit<"rad", metre / metre> {} radian;
+inline constexpr struct steradian : named_unit<"sr", square<metre> / square<metre>> {} steradian;
+inline constexpr struct hertz : named_unit<"Hz", 1 / second> {} hertz;
+inline constexpr struct newton : named_unit<"N", kilogram * metre / square<second>> {} newton;
+inline constexpr struct pascal : named_unit<"Pa", newton / square<metre>> {} pascal;
+inline constexpr struct joule : named_unit<"J", newton * metre> {} joule;
+inline constexpr struct watt : named_unit<"W", joule / second> {} watt;
+inline constexpr struct coulomb : named_unit<"C", ampere * second> {} coulomb;
+inline constexpr struct volt : named_unit<"V", watt / ampere> {} volt;
+inline constexpr struct farad : named_unit<"F", coulomb / volt> {} farad;
+inline constexpr struct ohm : named_unit<basic_symbol_text{"\u03A9", "ohm"}, volt / ampere> {} ohm;
+inline constexpr struct siemens : named_unit<"S", 1 / ohm> {} siemens;
+inline constexpr struct weber : named_unit<"Wb", volt * second> {} weber;
+inline constexpr struct tesla : named_unit<"T", weber / square<metre>> {} tesla;
+inline constexpr struct henry : named_unit<"H", weber / ampere> {} henry;
+inline constexpr struct degree_Celsius : named_unit<basic_symbol_text{"\u00B0C", "`C"}, kelvin> {} degree_Celsius;
+inline constexpr struct lumen : named_unit<"lm", candela * steradian> {} lumen;
+inline constexpr struct lux : named_unit<"lx", lumen / square<metre>> {} lux;
+inline constexpr struct becquerel : named_unit<"Bq", 1 / second> {} becquerel;
+inline constexpr struct gray : named_unit<"Gy", joule / kilogram> {} gray;
+inline constexpr struct sievert : named_unit<"Sv", joule / kilogram> {} sievert;
+inline constexpr struct katal : named_unit<"kat", mole / second> {} katal;
+
+// non-SI units accepted for use with the SI
+inline constexpr struct minute : named_unit<"min", mag<60> * second> {} minute;
+inline constexpr struct hour : named_unit<"h", mag<60> * minute> {} hour;
+inline constexpr struct day : named_unit<"d", mag<24> * hour> {} day;
+inline constexpr struct astronomical_unit : named_unit<"au", mag<149'597'870'700> * metre> {} astronomical_unit;
+inline constexpr struct degree : named_unit<basic_symbol_text{"°", "deg"}, mag_pi / mag<180> * radian> {} degree;
+// TODO how to disambiguate below angular units from time units
+// inline constexpr struct minute : named_unit<basic_symbol_text{"′", "'"}, mag<ratio{1, 60}> * degree> {} minute;
+// inline constexpr struct second : named_unit<basic_symbol_text{"″", "''"}, mag<ratio{1, 60}> * minute> {} second;
+inline constexpr struct are : named_unit<"a", square<deca<metre>>> {} are;
+inline constexpr struct hectare : decltype(hecto<are>) {} hectare;
+inline constexpr struct litre : named_unit<"l", cubic<deci<metre>>> {} litre;
+inline constexpr struct tonne : named_unit<"t", mag<1000> * kilogram> {} tonne;
+inline constexpr struct dalton : named_unit<"Da", mag<ratio{16'605'390'666'050, 10'000'000'000'000}> * mag_power<10, -27> * kilogram> {} dalton;
+// TODO A different value is provided in the SI Brochure and different in the ISO 80000
+inline constexpr struct electronvolt : named_unit<"eV", mag<ratio{1'602'176'634, 1'000'000'000}> * mag_power<10, -19> * joule> {} electronvolt;
+// TODO the below are logarithmic units - how to support those?
+// neper
+// bel
+// decibel
+
+// clang-format on
+
+}  // namespace units::si
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index b90032e9..e59fd801 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -22,6 +22,7 @@
 
 cmake_minimum_required(VERSION 3.2)
 
-add_subdirectory(unit_test/runtime)
+# add_subdirectory(unit_test/runtime)
 add_subdirectory(unit_test/static)
-#add_subdirectory(metabench)
+
+# add_subdirectory(metabench)
diff --git a/test/unit_test/runtime/CMakeLists.txt b/test/unit_test/runtime/CMakeLists.txt
index 61a67670..16cc33be 100644
--- a/test/unit_test/runtime/CMakeLists.txt
+++ b/test/unit_test/runtime/CMakeLists.txt
@@ -25,7 +25,9 @@ cmake_minimum_required(VERSION 3.2)
 find_package(Catch2 3 CONFIG REQUIRED)
 
 add_executable(
-    unit_tests_runtime math_test.cpp magnitude_test.cpp fmt_test.cpp fmt_units_test.cpp distribution_test.cpp
+    unit_tests_runtime
+    # math_test.cpp
+    magnitude_test.cpp # fmt_test.cpp fmt_units_test.cpp distribution_test.cpp
 )
 target_link_libraries(unit_tests_runtime PRIVATE mp-units::mp-units Catch2::Catch2WithMain)
 
diff --git a/test/unit_test/runtime/magnitude_test.cpp b/test/unit_test/runtime/magnitude_test.cpp
deleted file mode 100644
index dddd2785..00000000
--- a/test/unit_test/runtime/magnitude_test.cpp
+++ /dev/null
@@ -1,622 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2018 Mateusz Pusz
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#include <catch2/catch_test_macros.hpp>
-#include <units/magnitude.h>
-#include <units/ratio.h>
-#include <type_traits>
-
-using namespace units;
-using namespace units::detail;
-
-template<>
-inline constexpr std::optional<std::intmax_t> units::known_first_factor<9223372036854775783> = 9223372036854775783;
-
-namespace {
-
-// A set of non-standard bases for testing purposes.
-struct noninteger_base {
-  static constexpr long double value = 1.234L;
-};
-struct noncanonical_two_base {
-  static constexpr long double value = 2.0L;
-};
-struct other_noncanonical_two_base {
-  static constexpr long double value = 2.0L;
-};
-struct invalid_zero_base {
-  static constexpr long double value = 0.0L;
-};
-struct invalid_negative_base {
-  static constexpr long double value = -1.234L;
-};
-
-template<ratio Power>
-constexpr auto pi_to_the()
-{
-  return magnitude<base_power<pi_base>{Power}>{};
-}
-
-template<typename T, typename U>
-void check_same_type_and_value(T actual, U expected)
-{
-  CHECK(std::is_same_v<T, U>);
-  CHECK(actual == expected);
-}
-
-template<ratio R>
-void check_ratio_round_trip_is_identity()
-{
-  constexpr Magnitude auto m = mag<R>();
-  constexpr ratio round_trip = ratio{
-    get_value<std::intmax_t>(numerator(m)),
-    get_value<std::intmax_t>(denominator(m)),
-  };
-  CHECK(round_trip == R);
-}
-
-
-TEST_CASE("base_power")
-{
-  SECTION("base rep deducible for integral base")
-  {
-    CHECK(base_power{2} == base_power<std::intmax_t>{2, ratio{1}});
-    CHECK(base_power{2, 3} == base_power<std::intmax_t>{2, ratio{3}});
-    CHECK(base_power{2, ratio{3, 4}} == base_power<std::intmax_t>{2, ratio{3, 4}});
-  }
-
-  SECTION("get_base retrieves base for integral base")
-  {
-    CHECK(base_power{2}.get_base() == 2);
-    CHECK(base_power{3, 5}.get_base() == 3);
-    CHECK(base_power{5, ratio{1, 3}}.get_base() == 5);
-  }
-
-  SECTION("get_base retrieves member value for non-integer base")
-  {
-    CHECK(base_power<noninteger_base>{}.get_base() == 1.234L);
-    CHECK(base_power<noninteger_base>{2}.get_base() == 1.234L);
-    CHECK(base_power<noninteger_base>{ratio{5, 8}}.get_base() == 1.234L);
-  }
-
-  SECTION("same-base values not equal if types are different")
-  {
-    const auto a = base_power<noncanonical_two_base>{};
-    const auto b = base_power{2};
-    const auto c = base_power<other_noncanonical_two_base>{};
-
-    REQUIRE(a.get_base() == b.get_base());
-    CHECK(a != b);
-
-    REQUIRE(a.get_base() == c.get_base());
-    CHECK(a != c);
-  }
-
-  SECTION("same-type values not equal if bases are different")
-  {
-    CHECK(base_power{2} != base_power{3});
-    CHECK(base_power{2, ratio{5, 4}} != base_power{3, ratio{5, 4}});
-  }
-
-  SECTION("same-type, same-base values not equal if powers are different")
-  {
-    CHECK(base_power{2} != base_power{2, 2});
-    CHECK(base_power<pi_base>{} != base_power<pi_base>{ratio{1, 3}});
-  }
-
-  SECTION("product with inverse equals identity")
-  {
-    auto check_product_with_inverse_is_identity = [](auto x) { CHECK(x * pow<-1>(x) == mag<1>()); };
-
-    check_product_with_inverse_is_identity(mag<3>());
-    check_product_with_inverse_is_identity(mag<ratio{4, 17}>());
-    check_product_with_inverse_is_identity(pi_to_the<ratio{-22, 7}>());
-  }
-
-  SECTION("pow() multiplies exponent")
-  {
-    CHECK(pow(base_power{2}, 0) == base_power{2, 0});
-    CHECK(pow(base_power{2, 3}, ratio{-1, 2}) == base_power{2, ratio{-3, 2}});
-    CHECK(pow(base_power<pi_base>{ratio{3, 2}}, ratio{1, 3}) == base_power<pi_base>{ratio{1, 2}});
-  }
-}
-
-TEST_CASE("make_ratio performs prime factorization correctly")
-{
-  SECTION("Performs prime factorization when denominator is 1")
-  {
-    CHECK(mag<1>() == magnitude<>{});
-    CHECK(mag<2>() == magnitude<base_power{2}>{});
-    CHECK(mag<3>() == magnitude<base_power{3}>{});
-    CHECK(mag<4>() == magnitude<base_power{2, 2}>{});
-
-    CHECK(mag<792>() == magnitude<base_power{2, 3}, base_power{3, 2}, base_power{11}>{});
-  }
-
-  SECTION("Supports fractions") { CHECK(mag<ratio{5, 8}>() == magnitude<base_power{2, -3}, base_power{5}>{}); }
-
-  SECTION("Can handle prime factor which would be large enough to overflow int")
-  {
-    // This was taken from a case which failed when we used `int` for our base to store prime numbers.
-    // The failure was due to a prime factor which is larger than 2^31.
-    mag<ratio(16'605'390'666'050, 10'000'000'000'000)>();
-  }
-
-  SECTION("Can bypass computing primes by providing known_first_factor<N>")
-  {
-    // Sometimes, even wheel factorization isn't enough to handle the compilers' limits on constexpr steps and/or
-    // iterations.  To work around these cases, we can explicitly provide the correct answer directly to the compiler.
-    //
-    // In this case, we test that we can represent the largest prime that fits in a signed 64-bit int.  The reason this
-    // test can pass is that we have provided the answer, by specializing the `known_first_factor` variable template
-    // above in this file.
-    mag<9'223'372'036'854'775'783>();
-  }
-}
-
-TEST_CASE("magnitude converts to numerical value")
-{
-  SECTION("Positive integer powers of integer bases give integer values")
-  {
-    constexpr auto mag_412 = mag<412>();
-    check_same_type_and_value(get_value<int>(mag_412), 412);
-    check_same_type_and_value(get_value<std::size_t>(mag_412), std::size_t{412});
-    check_same_type_and_value(get_value<float>(mag_412), 412.0f);
-    check_same_type_and_value(get_value<double>(mag_412), 412.0);
-  }
-
-  SECTION("Negative integer powers of integer bases compute correct values")
-  {
-    constexpr auto mag_0p125 = mag<ratio{1, 8}>();
-    check_same_type_and_value(get_value<float>(mag_0p125), 0.125f);
-    check_same_type_and_value(get_value<double>(mag_0p125), 0.125);
-  }
-
-  SECTION("pi to the 1 supplies correct values")
-  {
-    check_same_type_and_value(get_value<float>(mag_pi), std::numbers::pi_v<float>);
-    check_same_type_and_value(get_value<double>(mag_pi), std::numbers::pi_v<double>);
-    check_same_type_and_value(get_value<long double>(mag_pi), std::numbers::pi_v<long double>);
-  }
-
-  SECTION("pi to arbitrary power performs computations in most accurate type at compile time")
-  {
-    if constexpr (sizeof(float) < sizeof(long double)) {
-      constexpr auto pi_cubed = pi_to_the<3>();
-
-      auto cube = [](auto x) { return x * x * x; };
-      constexpr auto via_float = cube(std::numbers::pi_v<float>);
-      constexpr auto via_long_double = static_cast<float>(cube(std::numbers::pi_v<long double>));
-
-      constexpr auto pi_cubed_value = get_value<float>(pi_cubed);
-      REQUIRE(pi_cubed_value != via_float);
-      CHECK(pi_cubed_value == via_long_double);
-    }
-  }
-
-  SECTION("Impossible requests are prevented at compile time")
-  {
-    // Naturally, we cannot actually write a test to verify a compiler error.  But any of these can
-    // be uncommented if desired to verify that it breaks the build.
-
-    // get_value<int8_t>(mag<412>());
-
-    // Would work for pow<62>:
-    // get_value<int64_t>(pow<63>(mag<2>()));
-
-    // Would work for pow<63>:
-    // get_value<uint64_t>(pow<64>(mag<2>()));
-
-    get_value<double>(pow<308>(mag<10>()));  // Compiles, correctly.
-    // get_value<double>(pow<309>(mag<10>()));
-    // get_value<double>(pow<3099>(mag<10>()));
-    // get_value<double>(pow<3099999>(mag<10>()));
-
-    auto sqrt_2 = pow<ratio{1, 2}>(mag<2>());
-    CHECK(!is_integral(sqrt_2));
-    // get_value<int>(sqrt_2);
-  }
-}
-
-TEST_CASE("Equality works for magnitudes")
-{
-  SECTION("Equivalent ratios are equal")
-  {
-    CHECK(mag<1>() == mag<1>());
-    CHECK(mag<3>() == mag<3>());
-    CHECK(mag<ratio{3, 4}>() == mag<ratio{9, 12}>());
-  }
-
-  SECTION("Different ratios are unequal")
-  {
-    CHECK(mag<3>() != mag<5>());
-    CHECK(mag<3>() != mag<ratio{3, 2}>());
-  }
-
-  SECTION("Supports constexpr")
-  {
-    constexpr auto eq = (mag<ratio{4, 5}>() == mag<ratio{4, 3}>());
-    CHECK(!eq);
-  }
-}
-
-TEST_CASE("Multiplication works for magnitudes")
-{
-  SECTION("Reciprocals reduce to null magnitude") { CHECK(mag<ratio{3, 4}>() * mag<ratio{4, 3}>() == mag<1>()); }
-
-  SECTION("Products work as expected") { CHECK(mag<ratio{4, 5}>() * mag<ratio{4, 3}>() == mag<ratio{16, 15}>()); }
-
-  SECTION("Products handle pi correctly")
-  {
-    CHECK(pi_to_the<1>() * mag<ratio{2, 3}>() * pi_to_the<ratio{-1, 2}>() ==
-          magnitude<base_power{2}, base_power{3, -1}, base_power<pi_base>{ratio{1, 2}}>{});
-  }
-
-  SECTION("Supports constexpr")
-  {
-    constexpr auto p = mag<ratio{4, 5}>() * mag<ratio{4, 3}>();
-    CHECK(p == mag<ratio{16, 15}>());
-  }
-}
-
-TEST_CASE("Common Magnitude")
-{
-  SECTION("Identity for identical magnitudes")
-  {
-    CHECK(common_magnitude(mag<1>(), mag<1>()) == mag<1>());
-    CHECK(common_magnitude(mag<15>(), mag<15>()) == mag<15>());
-    CHECK(common_magnitude(pi_to_the<ratio{3, 4}>(), pi_to_the<ratio{3, 4}>()) == pi_to_the<ratio{3, 4}>());
-  }
-
-  SECTION("Greatest Common Factor for integers")
-  {
-    CHECK(common_magnitude(mag<24>(), mag<36>()) == mag<12>());
-    CHECK(common_magnitude(mag<24>(), mag<37>()) == mag<1>());
-  }
-
-  SECTION("Handles fractions")
-  {
-    CHECK(common_magnitude(mag<ratio{3, 8}>(), mag<ratio{5, 6}>()) == mag<ratio{1, 24}>());
-  }
-}
-
-TEST_CASE("Division works for magnitudes")
-{
-  SECTION("Dividing anything by itself reduces to null magnitude")
-  {
-    CHECK(mag<ratio{3, 4}>() / mag<ratio{3, 4}>() == mag<1>());
-    CHECK(mag<15>() / mag<15>() == mag<1>());
-  }
-
-  SECTION("Quotients work as expected") { CHECK(mag<ratio{4, 5}>() / mag<ratio{4, 3}>() == mag<ratio{3, 5}>()); }
-
-  SECTION("Supports constexpr")
-  {
-    constexpr auto q = mag<ratio{4, 5}>() / mag<ratio{4, 3}>();
-    CHECK(q == mag<ratio{3, 5}>());
-  }
-}
-
-TEST_CASE("Can raise Magnitudes to rational powers")
-{
-  SECTION("Anything to the 0 is 1")
-  {
-    CHECK(pow<0>(mag<1>()) == mag<1>());
-    CHECK(pow<0>(mag<123>()) == mag<1>());
-    CHECK(pow<0>(mag<ratio{3, 4}>()) == mag<1>());
-    CHECK(pow<0>(pi_to_the<ratio{-1, 2}>()) == mag<1>());
-  }
-
-  SECTION("Anything to the 1 is itself")
-  {
-    CHECK(pow<1>(mag<1>()) == mag<1>());
-    CHECK(pow<1>(mag<123>()) == mag<123>());
-    CHECK(pow<1>(mag<ratio{3, 4}>()) == mag<ratio{3, 4}>());
-    CHECK(pow<1>(pi_to_the<ratio{-1, 2}>()) == pi_to_the<ratio{-1, 2}>());
-  }
-
-  SECTION("Can raise to arbitrary rational power")
-  {
-    CHECK(pow<ratio{-8, 3}>(pi_to_the<ratio{-1, 2}>()) == pi_to_the<ratio{4, 3}>());
-  }
-}
-
-TEST_CASE("can distinguish integral, rational, and irrational magnitudes")
-{
-  SECTION("Integer magnitudes are integral and rational")
-  {
-    auto check_rational_and_integral = [](Magnitude auto m) {
-      CHECK(is_integral(m));
-      CHECK(is_rational(m));
-    };
-    check_rational_and_integral(magnitude<>{});
-    check_rational_and_integral(mag<1>());
-    check_rational_and_integral(mag<3>());
-    check_rational_and_integral(mag<8>());
-    check_rational_and_integral(mag<412>());
-    check_rational_and_integral(mag<ratio{1, 1}>());
-  }
-
-  SECTION("Fractional magnitudes are rational, but not integral")
-  {
-    auto check_rational_but_not_integral = [](Magnitude auto m) {
-      CHECK(!is_integral(m));
-      CHECK(is_rational(m));
-    };
-    check_rational_but_not_integral(mag<ratio{1, 2}>());
-    check_rational_but_not_integral(mag<ratio{5, 8}>());
-  }
-}
-
-TEST_CASE("Constructing ratio from rational magnitude")
-{
-  SECTION("Round trip is identity")
-  {
-    // Note that not every Magnitude can be represented as a ratio.  However, if we _start_ with a
-    // ratio, we must guarantee to recover the same ratio in a round trip.
-    check_ratio_round_trip_is_identity<1>();
-    check_ratio_round_trip_is_identity<9>();
-    check_ratio_round_trip_is_identity<ratio{5, 8}>();
-  }
-
-  SECTION("Rational magnitude converts to ratio")
-  {
-    constexpr ratio r = as_ratio(mag<ratio{22, 7}>());
-    CHECK(r == ratio{22, 7});
-  }
-
-  SECTION("Irrational magnitude does not convert to ratio")
-  {
-    // The following code should not compile.
-    // as_ratio(pow<ratio{1, 2}>(mag<2>()));
-
-    // The following code should not compile.
-    // as_ratio(mag<180>() / pi_to_the<1>());
-  }
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Detail function tests below.
-
-TEST_CASE("int_power computes integer powers")
-{
-  SECTION("handles floating point")
-  {
-    check_same_type_and_value(int_power(0.123L, 0), 1.0L);
-    check_same_type_and_value(int_power(0.246f, 1), 0.246f);
-    check_same_type_and_value(int_power(0.5f, 3), 0.125f);
-    check_same_type_and_value(int_power(2.5, 4), 39.0625);
-
-    CHECK(std::is_same_v<long double, decltype(compute_base_power<double>(base_power{10, 20}))>);
-  }
-
-  SECTION("handles integral")
-  {
-    check_same_type_and_value(int_power(8, 0), 1);
-    check_same_type_and_value(int_power(9L, 1), 9L);
-    check_same_type_and_value(int_power(2, 10), 1024);
-  }
-}
-
-TEST_CASE("integer_part picks out integer part of single-basis magnitude")
-{
-  SECTION("integer_part of non-integer base is identity magnitude")
-  {
-    CHECK(integer_part(pi_to_the<1>()) == magnitude<>{});
-    CHECK(integer_part(pi_to_the<-8>()) == magnitude<>{});
-    CHECK(integer_part(pi_to_the<ratio{3, 4}>()) == magnitude<>{});
-  }
-
-  SECTION("integer_part of integer base to negative power is identity magnitude")
-  {
-    CHECK(integer_part(magnitude<base_power{2, -8}>{}) == magnitude<>{});
-    CHECK(integer_part(magnitude<base_power{11, -1}>{}) == magnitude<>{});
-  }
-
-  SECTION("integer_part of integer base to fractional power is identity magnitude")
-  {
-    CHECK(integer_part(magnitude<base_power{2, ratio{1, 2}}>{}) == magnitude<>{});
-  }
-
-  SECTION("integer_part of integer base to power at least one takes integer part")
-  {
-    CHECK(integer_part(magnitude<base_power{2, 1}>{}) == magnitude<base_power{2, 1}>{});
-    CHECK(integer_part(magnitude<base_power{2, ratio{19, 10}}>{}) == magnitude<base_power{2, 1}>{});
-    CHECK(integer_part(magnitude<base_power{11, ratio{97, 9}}>{}) == magnitude<base_power{11, 10}>{});
-  }
-}
-
-TEST_CASE("Prime helper functions")
-{
-  SECTION("multiplicity")
-  {
-    CHECK(multiplicity(2, 8) == 3);
-    CHECK(multiplicity(2, 1024) == 10);
-    CHECK(multiplicity(11, 6655) == 3);
-  }
-
-  SECTION("remove_power()")
-  {
-    CHECK(remove_power(17, 0, 5) == 5);
-    CHECK(remove_power(2, 3, 24) == 3);
-    CHECK(remove_power(11, 3, 6655) == 5);
-  }
-}
-
-TEST_CASE("Prime factorization")
-{
-  SECTION("1 factors into the null magnitude") { CHECK(prime_factorization_v<1> == magnitude<>{}); }
-
-  SECTION("Prime numbers factor into themselves")
-  {
-    CHECK(prime_factorization_v<2> == magnitude<base_power{2}>{});
-    CHECK(prime_factorization_v<3> == magnitude<base_power{3}>{});
-    CHECK(prime_factorization_v<5> == magnitude<base_power{5}>{});
-    CHECK(prime_factorization_v<7> == magnitude<base_power{7}>{});
-    CHECK(prime_factorization_v<11> == magnitude<base_power{11}>{});
-
-    CHECK(prime_factorization_v<41> == magnitude<base_power{41}>{});
-  }
-
-  SECTION("Prime factorization finds factors and multiplicities")
-  {
-    CHECK(prime_factorization_v<792> == magnitude<base_power{2, 3}, base_power{3, 2}, base_power{11}>{});
-  }
-}
-
-TEST_CASE("is_prime detects primes")
-{
-  SECTION("Non-positive numbers are not prime")
-  {
-    CHECK(!is_prime(-1328));
-    CHECK(!is_prime(-1));
-    CHECK(!is_prime(0));
-  }
-
-  SECTION("1 is not prime") { CHECK(!is_prime(1)); }
-
-  SECTION("Discriminates between primes and non-primes")
-  {
-    CHECK(is_prime(2));
-    CHECK(is_prime(3));
-    CHECK(!is_prime(4));
-    CHECK(is_prime(5));
-    CHECK(!is_prime(6));
-    CHECK(is_prime(7));
-    CHECK(!is_prime(8));
-    CHECK(!is_prime(9));
-
-    CHECK(is_prime(7919));
-  }
-}
-
-TEST_CASE("is_valid_base_power")
-{
-  SECTION("0 power is invalid")
-  {
-    REQUIRE(is_valid_base_power(base_power{2}));
-    CHECK(!is_valid_base_power(base_power{2, 0}));
-
-    REQUIRE(is_valid_base_power(base_power{41}));
-    CHECK(!is_valid_base_power(base_power{41, 0}));
-
-    REQUIRE(is_valid_base_power(base_power<pi_base>{}));
-    CHECK(!is_valid_base_power(base_power<pi_base>{0}));
-  }
-
-  SECTION("non-prime integers are invalid")
-  {
-    CHECK(!is_valid_base_power(base_power{-8}));
-    CHECK(!is_valid_base_power(base_power{0}));
-    CHECK(!is_valid_base_power(base_power{1}));
-
-    CHECK(is_valid_base_power(base_power{2}));
-    CHECK(is_valid_base_power(base_power{3}));
-
-    CHECK(!is_valid_base_power(base_power{4}));
-  }
-
-  SECTION("non-positive floating point bases are invalid")
-  {
-    CHECK(!is_valid_base_power(base_power<invalid_zero_base>{}));
-    CHECK(!is_valid_base_power(base_power<invalid_negative_base>{}));
-  }
-}
-
-TEST_CASE("pairwise_all evaluates all pairs")
-{
-  const auto all_pairs_return_true = pairwise_all{[](auto, auto) { return true; }};
-  const auto all_pairs_return_false = pairwise_all{[](auto, auto) { return false; }};
-  const auto all_increasing = pairwise_all{std::less{}};
-
-  SECTION("always true for empty tuples")
-  {
-    CHECK(all_pairs_return_true());
-    CHECK(all_pairs_return_false());
-  }
-
-  SECTION("always true for single-element tuples")
-  {
-    CHECK(all_pairs_return_true(1));
-    CHECK(all_pairs_return_false(3.14));
-    CHECK(all_pairs_return_true('x'));
-  }
-
-  SECTION("true for longer tuples iff true for all neighbouring pairs")
-  {
-    CHECK(all_increasing(1, 1.5));
-    CHECK(all_increasing(1, 1.5, 2));
-
-    CHECK(!all_increasing(1, 2.0, 2));
-    CHECK(!all_increasing(1, 2.5, 2));
-
-    CHECK(all_pairs_return_true('c', 1, 8.9, 42u));
-    CHECK(!all_pairs_return_false('c', 1, 8.9, 42u));
-  }
-}
-
-TEST_CASE("strictly_increasing")
-{
-  SECTION("Empty input is sorted") { CHECK(strictly_increasing()); }
-
-  SECTION("Single-element input is sorted")
-  {
-    CHECK(strictly_increasing(3));
-    CHECK(strictly_increasing(15.42));
-    CHECK(strictly_increasing('c'));
-  }
-
-  SECTION("Multi-value inputs compare correctly")
-  {
-    CHECK(strictly_increasing(3, 3.14));
-    CHECK(!strictly_increasing(3, 3.0));
-    CHECK(!strictly_increasing(4, 3.0));
-  }
-}
-
-TEST_CASE("extract_power_of_10")
-{
-  SECTION("Picks out positive powers")
-  {
-    CHECK(extract_power_of_10(mag<10>()) == 1);
-    CHECK(extract_power_of_10(mag<20>()) == 1);
-    CHECK(extract_power_of_10(mag<40>()) == 1);
-    CHECK(extract_power_of_10(mag<50>()) == 1);
-    CHECK(extract_power_of_10(mag<100>()) == 2);
-  }
-
-  SECTION("Picks out negative powers")
-  {
-    constexpr auto ONE = mag<1>();
-    CHECK(extract_power_of_10(ONE / mag<10>()) == -1);
-    CHECK(extract_power_of_10(ONE / mag<20>()) == -1);
-    CHECK(extract_power_of_10(ONE / mag<40>()) == -1);
-    CHECK(extract_power_of_10(ONE / mag<50>()) == -1);
-    CHECK(extract_power_of_10(ONE / mag<100>()) == -2);
-  }
-
-  SECTION("Zero if signs disagree") { CHECK(extract_power_of_10(mag<2>() / mag<5>()) == 0); }
-
-  SECTION("Handles rational powers") { CHECK(extract_power_of_10(sqrt(mag<1000>())) == 1); }
-}
-
-}  // namespace
diff --git a/test/unit_test/static/CMakeLists.txt b/test/unit_test/static/CMakeLists.txt
index 632592f8..6abc8d0a 100644
--- a/test/unit_test/static/CMakeLists.txt
+++ b/test/unit_test/static/CMakeLists.txt
@@ -22,48 +22,50 @@
 
 cmake_minimum_required(VERSION 3.2)
 
-add_library(unit_tests_static_truncating quantity_test.cpp)
+# add_library(unit_tests_static_truncating quantity_test.cpp)
 
-if(NOT ${projectPrefix}LIBCXX)
-    target_sources(unit_tests_static_truncating PRIVATE quantity_kind_test.cpp quantity_point_kind_test.cpp)
-endif()
-
-target_link_libraries(unit_tests_static_truncating PRIVATE mp-units::mp-units)
-target_compile_options(
-    unit_tests_static_truncating PRIVATE $<IF:$<CXX_COMPILER_ID:MSVC>,/wd4242 /wd4244,-Wno-conversion>
-)
+# if(NOT ${projectPrefix}LIBCXX)
+# target_sources(unit_tests_static_truncating PRIVATE quantity_kind_test.cpp quantity_point_kind_test.cpp)
+# endif()
 
+# target_link_libraries(unit_tests_static_truncating PRIVATE mp-units::mp-units)
+# target_compile_options(
+# unit_tests_static_truncating PRIVATE $<IF:$<CXX_COMPILER_ID:MSVC>,/wd4242 /wd4244,-Wno-conversion>
+# )
 add_library(
     unit_tests_static
-    angle_test.cpp
-    cgs_test.cpp
-    chrono_test.cpp
-    concepts_test.cpp
-    custom_rep_test_min_expl.cpp
-    custom_unit_test.cpp
-    dimension_op_test.cpp
-    dimensions_concepts_test.cpp
-    fixed_string_test.cpp
-    fps_test.cpp
-    iec80000_test.cpp
-    kind_test.cpp
-    math_test.cpp
-    point_origin_test.cpp
-    prime_test.cpp
-    ratio_test.cpp
-    references_test.cpp
-    si_test.cpp
-    si_cgs_test.cpp
-    si_fps_test.cpp
-    si_hep_test.cpp
-    symbol_text_test.cpp
-    type_list_test.cpp
-    unit_test.cpp
-    us_test.cpp
+    dimension_test.cpp
+    # angle_test.cpp
+    # cgs_test.cpp
+    # chrono_test.cpp
+    # concepts_test.cpp
+    # custom_rep_test_min_expl.cpp
+    # custom_unit_test.cpp
+    # dimension_op_test.cpp
+    # dimensions_concepts_test.cpp
+    # fixed_string_test.cpp
+    # fps_test.cpp
+    # iec80000_test.cpp
+    # kind_test.cpp
+    magnitude_test.cpp
+    # math_test.cpp
+    # point_origin_test.cpp
+    # prime_test.cpp
+    # ratio_test.cpp
+    # references_test.cpp
+    # si_test.cpp
+    # si_cgs_test.cpp
+    # si_fps_test.cpp
+    # si_hep_test.cpp
+    # symbol_text_test.cpp
+    # type_list_test.cpp
+    # unit_test.cpp
+    # us_test.cpp
 )
 
-if(NOT ${projectPrefix}LIBCXX)
-    target_sources(unit_tests_static PRIVATE custom_rep_test_min_impl.cpp quantity_point_test.cpp)
-endif()
+# if(NOT ${projectPrefix}LIBCXX)
+# target_sources(unit_tests_static PRIVATE custom_rep_test_min_impl.cpp quantity_point_test.cpp)
+# endif()
+target_link_libraries(unit_tests_static PRIVATE mp-units::mp-units)
 
-target_link_libraries(unit_tests_static PRIVATE unit_tests_static_truncating mp-units::mp-units)
+# target_link_libraries(unit_tests_static PRIVATE unit_tests_static_truncating mp-units::mp-units)
diff --git a/test/unit_test/static/dimension_test.cpp b/test/unit_test/static/dimension_test.cpp
index c2d3a62d..4cc2958e 100644
--- a/test/unit_test/static/dimension_test.cpp
+++ b/test/unit_test/static/dimension_test.cpp
@@ -105,32 +105,45 @@ static_assert(is_of_type<1 / (speed_dim * speed_dim) * length_dim,
 // comparisons of equivalent dimensions
 static_assert(length_dim / length_dim == one_dim);
 
-static_assert(1 / time_dim == frequency_dim);
+static_assert(1 / time_dim != frequency_dim);
+static_assert(equivalent(1 / time_dim, frequency_dim));
 static_assert(1 / frequency_dim == time_dim);
 static_assert(frequency_dim * time_dim == one_dim);
 
-static_assert(length_dim * length_dim == area_dim);
+static_assert(length_dim * length_dim != area_dim);
+static_assert(equivalent(length_dim * length_dim, area_dim));
 static_assert(length_dim * length_dim != volume_dim);
 static_assert(area_dim / length_dim == length_dim);
 
-static_assert(length_dim * length_dim * length_dim == volume_dim);
-static_assert(area_dim * length_dim == volume_dim);
-static_assert(volume_dim / length_dim == area_dim);
+static_assert(length_dim * length_dim * length_dim != volume_dim);
+static_assert(equivalent(length_dim * length_dim * length_dim, volume_dim));
+static_assert(area_dim * length_dim != volume_dim);
+static_assert(equivalent(area_dim * length_dim, volume_dim));
+static_assert(volume_dim / length_dim != area_dim);
+static_assert(equivalent(volume_dim / length_dim, area_dim));
 static_assert(volume_dim / length_dim / length_dim == length_dim);
-static_assert(area_dim * area_dim / length_dim == volume_dim);
-static_assert(area_dim * (area_dim / length_dim) == volume_dim);
+static_assert(area_dim * area_dim / length_dim != volume_dim);
+static_assert(equivalent(area_dim * area_dim / length_dim, volume_dim));
+static_assert(area_dim * (area_dim / length_dim) != volume_dim);
+static_assert(equivalent(area_dim * (area_dim / length_dim), volume_dim));
 static_assert(volume_dim / (length_dim * length_dim) == length_dim);
 
-static_assert(length_dim / time_dim == speed_dim);
+static_assert(length_dim / time_dim != speed_dim);
+static_assert(equivalent(length_dim / time_dim, speed_dim));
 static_assert(length_dim * time_dim != speed_dim);
 static_assert(length_dim / time_dim / time_dim != speed_dim);
 static_assert(length_dim / speed_dim == time_dim);
 static_assert(speed_dim * time_dim == length_dim);
 
-static_assert(length_dim / time_dim / time_dim == acceleration_dim);
-static_assert(length_dim / (time_dim * time_dim) == acceleration_dim);
-static_assert(speed_dim / time_dim == acceleration_dim);
+static_assert(length_dim / time_dim / time_dim != acceleration_dim);
+static_assert(equivalent(length_dim / time_dim / time_dim, acceleration_dim));
+static_assert(length_dim / (time_dim * time_dim) != acceleration_dim);
+static_assert(equivalent(length_dim / (time_dim * time_dim), acceleration_dim));
+static_assert(speed_dim / time_dim != acceleration_dim);
+static_assert(equivalent(speed_dim / time_dim, acceleration_dim));
 static_assert(speed_dim / acceleration_dim == time_dim);
-static_assert(acceleration_dim * time_dim == speed_dim);
+static_assert(acceleration_dim * time_dim != speed_dim);
+static_assert(equivalent(acceleration_dim * time_dim, speed_dim));
 static_assert(acceleration_dim * (time_dim * time_dim) == length_dim);
-static_assert(acceleration_dim / speed_dim == frequency_dim);
+static_assert(acceleration_dim / speed_dim != frequency_dim);
+static_assert(equivalent(acceleration_dim / speed_dim, frequency_dim));
diff --git a/test/unit_test/static/magnitude_test.cpp b/test/unit_test/static/magnitude_test.cpp
new file mode 100644
index 00000000..c986373e
--- /dev/null
+++ b/test/unit_test/static/magnitude_test.cpp
@@ -0,0 +1,648 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2018 Mateusz Pusz
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include <units/magnitude.h>
+#include <units/ratio.h>
+#include <type_traits>
+
+using namespace units;
+using namespace units::detail;
+
+template<>
+inline constexpr std::optional<std::intmax_t> units::known_first_factor<9223372036854775783> = 9223372036854775783;
+
+namespace {
+
+// A set of non-standard bases for testing purposes.
+// struct noninteger_base {
+//   static constexpr long double value = 1.234L;
+// };
+// struct noncanonical_two_base {
+//   static constexpr long double value = 2.0L;
+// };
+// struct other_noncanonical_two_base {
+//   static constexpr long double value = 2.0L;
+// };
+// struct invalid_zero_base {
+//   static constexpr long double value = 0.0L;
+// };
+// struct invalid_negative_base {
+//   static constexpr long double value = -1.234L;
+// };
+
+// template<typename T, typename U>
+// void check_same_type_and_value(T actual, U expected)
+// {
+//   CHECK(std::is_same_v<T, U>);
+//   CHECK(actual == expected);
+// }
+
+// template<ratio R>
+// void check_ratio_round_trip_is_identity()
+// {
+//   constexpr Magnitude auto m = mag<R>();
+//   constexpr ratio round_trip = ratio{
+//     get_value<std::intmax_t>(numerator(m)),
+//     get_value<std::intmax_t>(denominator(m)),
+//   };
+//   CHECK(round_trip == R);
+// }
+
+inline constexpr struct mag_2_ : magnitude<2> {
+} mag_2;
+// inline constexpr struct mag_2_other : magnitude<2> {
+// } mag_2_other;
+// inline constexpr struct mag_3 : magnitude<2> {
+// } mag_3;
+
+// concepts verification
+static_assert(Magnitude<decltype(mag<2>)>);
+static_assert(Magnitude<mag_2_>);
+
+// is_named_magnitude
+static_assert(!is_named_magnitude<std::remove_cvref_t<decltype(mag<2>)>>);
+static_assert(is_named_magnitude<mag_2_>);
+
+// power_v
+template<template<auto, int, int...> typename P>
+concept invalid_power_v = requires {
+                            requires !requires { typename P<123, 0>; };
+                            requires !requires { typename P<123, 0, 2>; };
+                            requires !requires { typename P<123, 1, 0>; };
+                            requires !requires { typename P<123, 0, 0>; };
+                            requires !requires { typename P<123, 1>; };
+                            requires !requires { typename P<123, 1, 1>; };
+                            requires !requires { typename P<123, 5, 5>; };
+                          };
+static_assert(invalid_power_v<power_v>);
+
+// get_base
+// get_base retrieves value for integral base
+static_assert(get_base(2) == 2);
+static_assert(get_base(power_v<3, 5>{}) == 3);
+static_assert(get_base(power_v<5, 1, 3>{}) == 5);
+
+// get_base retrieves value for integral base
+static_assert(get_base(2) == 2);
+static_assert(get_base(power_v<3, 5>{}) == 3);
+static_assert(get_base(power_v<5, 1, 3>{}) == 5);
+
+// get_base retrieves named magnitude for named base
+static_assert(std::is_same_v<decltype(get_base(mag_2)), mag_2_>);
+static_assert(std::is_same_v<decltype(get_base(power_v<mag_2, 2>{})), mag_2_>);
+static_assert(std::is_same_v<decltype(get_base(power_v<mag_2, 5, 8>{})), mag_2_>);
+
+
+// equality
+// static_assert(mag_2 == mag_2);
+// static_assert(mag_2 != mag_3);
+// static_assert(mag_2 != mag_2_other);
+
+// {
+//   const auto a = base_power<noncanonical_two_base>{};
+//   const auto b = base_power{2};
+//   const auto c = base_power<other_noncanonical_two_base>{};
+
+//   REQUIRE(a.get_base() == b.get_base());
+//   CHECK(a != b);
+
+//   REQUIRE(a.get_base() == c.get_base());
+//   CHECK(a != c);
+// }
+
+// SECTION("same-type values not equal if bases are different")
+// {
+//   CHECK(base_power{2} != base_power{3});
+//   CHECK(base_power{2, ratio{5, 4}} != base_power{3, ratio{5, 4}});
+// }
+
+// SECTION("same-type, same-base values not equal if powers are different")
+// {
+//   CHECK(base_power{2} != base_power{2, 2});
+//   CHECK(base_power<pi_base>{} != base_power<pi_base>{ratio{1, 3}});
+// }
+
+// SECTION("product with inverse equals identity")
+// {
+//   auto check_product_with_inverse_is_identity = [](auto x) { CHECK(x * pow<-1>(x) == mag<1>()); };
+
+//   check_product_with_inverse_is_identity(mag<3>());
+//   check_product_with_inverse_is_identity(mag<ratio{4, 17}>());
+//   check_product_with_inverse_is_identity(pi_to_the<ratio{-22, 7}>());
+// }
+
+// SECTION("pow() multiplies exponent")
+// {
+//   CHECK(pow(base_power{2}, 0) == base_power{2, 0});
+//   CHECK(pow(base_power{2, 3}, ratio{-1, 2}) == base_power{2, ratio{-3, 2}});
+//   CHECK(pow(base_power<pi_base>{ratio{3, 2}}, ratio{1, 3}) == base_power<pi_base>{ratio{1, 2}});
+// }
+
+// TEST_CASE("make_ratio performs prime factorization correctly")
+// {
+//   SECTION("Performs prime factorization when denominator is 1")
+//   {
+//     CHECK(mag<1>() == magnitude<>{});
+//     CHECK(mag<2>() == magnitude<base_power{2}>{});
+//     CHECK(mag<3>() == magnitude<base_power{3}>{});
+//     CHECK(mag<4>() == magnitude<base_power{2, 2}>{});
+
+//     CHECK(mag<792>() == magnitude<base_power{2, 3}, base_power{3, 2}, base_power{11}>{});
+//   }
+
+//   SECTION("Supports fractions") { CHECK(mag<ratio{5, 8}>() == magnitude<base_power{2, -3}, base_power{5}>{}); }
+
+//   SECTION("Can handle prime factor which would be large enough to overflow int")
+//   {
+//     // This was taken from a case which failed when we used `int` for our base to store prime numbers.
+//     // The failure was due to a prime factor which is larger than 2^31.
+//     mag<ratio(16'605'390'666'050, 10'000'000'000'000)>();
+//   }
+
+//   SECTION("Can bypass computing primes by providing known_first_factor<N>")
+//   {
+//     // Sometimes, even wheel factorization isn't enough to handle the compilers' limits on constexpr steps and/or
+//     // iterations.  To work around these cases, we can explicitly provide the correct answer directly to the
+//     compiler.
+//     //
+//     // In this case, we test that we can represent the largest prime that fits in a signed 64-bit int.  The reason
+//     this
+//     // test can pass is that we have provided the answer, by specializing the `known_first_factor` variable template
+//     // above in this file.
+//     mag<9'223'372'036'854'775'783>();
+//   }
+// }
+
+// TEST_CASE("magnitude converts to numerical value")
+// {
+//   SECTION("Positive integer powers of integer bases give integer values")
+//   {
+//     constexpr auto mag_412 = mag<412>();
+//     check_same_type_and_value(get_value<int>(mag_412), 412);
+//     check_same_type_and_value(get_value<std::size_t>(mag_412), std::size_t{412});
+//     check_same_type_and_value(get_value<float>(mag_412), 412.0f);
+//     check_same_type_and_value(get_value<double>(mag_412), 412.0);
+//   }
+
+//   SECTION("Negative integer powers of integer bases compute correct values")
+//   {
+//     constexpr auto mag_0p125 = mag<ratio{1, 8}>();
+//     check_same_type_and_value(get_value<float>(mag_0p125), 0.125f);
+//     check_same_type_and_value(get_value<double>(mag_0p125), 0.125);
+//   }
+
+//   SECTION("pi to the 1 supplies correct values")
+//   {
+//     check_same_type_and_value(get_value<float>(mag_pi), std::numbers::pi_v<float>);
+//     check_same_type_and_value(get_value<double>(mag_pi), std::numbers::pi_v<double>);
+//     check_same_type_and_value(get_value<long double>(mag_pi), std::numbers::pi_v<long double>);
+//   }
+
+//   SECTION("pi to arbitrary power performs computations in most accurate type at compile time")
+//   {
+//     if constexpr (sizeof(float) < sizeof(long double)) {
+//       constexpr auto pi_cubed = pi_to_the<3>();
+
+//       auto cube = [](auto x) { return x * x * x; };
+//       constexpr auto via_float = cube(std::numbers::pi_v<float>);
+//       constexpr auto via_long_double = static_cast<float>(cube(std::numbers::pi_v<long double>));
+
+//       constexpr auto pi_cubed_value = get_value<float>(pi_cubed);
+//       REQUIRE(pi_cubed_value != via_float);
+//       CHECK(pi_cubed_value == via_long_double);
+//     }
+//   }
+
+//   SECTION("Impossible requests are prevented at compile time")
+//   {
+//     // Naturally, we cannot actually write a test to verify a compiler error.  But any of these can
+//     // be uncommented if desired to verify that it breaks the build.
+
+//     // get_value<int8_t>(mag<412>());
+
+//     // Would work for pow<62>:
+//     // get_value<int64_t>(pow<63>(mag<2>()));
+
+//     // Would work for pow<63>:
+//     // get_value<uint64_t>(pow<64>(mag<2>()));
+
+//     get_value<double>(pow<308>(mag<10>()));  // Compiles, correctly.
+//     // get_value<double>(pow<309>(mag<10>()));
+//     // get_value<double>(pow<3099>(mag<10>()));
+//     // get_value<double>(pow<3099999>(mag<10>()));
+
+//     auto sqrt_2 = pow<ratio{1, 2}>(mag<2>());
+//     CHECK(!is_integral(sqrt_2));
+//     // get_value<int>(sqrt_2);
+//   }
+// }
+
+// TEST_CASE("Equality works for magnitudes")
+// {
+//   SECTION("Equivalent ratios are equal")
+//   {
+//     CHECK(mag<1>() == mag<1>());
+//     CHECK(mag<3>() == mag<3>());
+//     CHECK(mag<ratio{3, 4}>() == mag<ratio{9, 12}>());
+//   }
+
+//   SECTION("Different ratios are unequal")
+//   {
+//     CHECK(mag<3>() != mag<5>());
+//     CHECK(mag<3>() != mag<ratio{3, 2}>());
+//   }
+
+//   SECTION("Supports constexpr")
+//   {
+//     constexpr auto eq = (mag<ratio{4, 5}>() == mag<ratio{4, 3}>());
+//     CHECK(!eq);
+//   }
+// }
+
+// TEST_CASE("Multiplication works for magnitudes")
+// {
+//   SECTION("Reciprocals reduce to null magnitude") { CHECK(mag<ratio{3, 4}>() * mag<ratio{4, 3}>() == mag<1>()); }
+
+//   SECTION("Products work as expected") { CHECK(mag<ratio{4, 5}>() * mag<ratio{4, 3}>() == mag<ratio{16, 15}>()); }
+
+//   SECTION("Products handle pi correctly")
+//   {
+//     CHECK(pi_to_the<1>() * mag<ratio{2, 3}>() * pi_to_the<ratio{-1, 2}>() ==
+//           magnitude<base_power{2}, base_power{3, -1}, base_power<pi_base>{ratio{1, 2}}>{});
+//   }
+
+//   SECTION("Supports constexpr")
+//   {
+//     constexpr auto p = mag<ratio{4, 5}>() * mag<ratio{4, 3}>();
+//     CHECK(p == mag<ratio{16, 15}>());
+//   }
+// }
+
+// TEST_CASE("Common Magnitude")
+// {
+//   SECTION("Identity for identical magnitudes")
+//   {
+//     CHECK(common_magnitude(mag<1>(), mag<1>()) == mag<1>());
+//     CHECK(common_magnitude(mag<15>(), mag<15>()) == mag<15>());
+//     CHECK(common_magnitude(pi_to_the<ratio{3, 4}>(), pi_to_the<ratio{3, 4}>()) == pi_to_the<ratio{3, 4}>());
+//   }
+
+//   SECTION("Greatest Common Factor for integers")
+//   {
+//     CHECK(common_magnitude(mag<24>(), mag<36>()) == mag<12>());
+//     CHECK(common_magnitude(mag<24>(), mag<37>()) == mag<1>());
+//   }
+
+//   SECTION("Handles fractions")
+//   {
+//     CHECK(common_magnitude(mag<ratio{3, 8}>(), mag<ratio{5, 6}>()) == mag<ratio{1, 24}>());
+//   }
+// }
+
+// TEST_CASE("Division works for magnitudes")
+// {
+//   SECTION("Dividing anything by itself reduces to null magnitude")
+//   {
+//     CHECK(mag<ratio{3, 4}>() / mag<ratio{3, 4}>() == mag<1>());
+//     CHECK(mag<15>() / mag<15>() == mag<1>());
+//   }
+
+//   SECTION("Quotients work as expected") { CHECK(mag<ratio{4, 5}>() / mag<ratio{4, 3}>() == mag<ratio{3, 5}>()); }
+
+//   SECTION("Supports constexpr")
+//   {
+//     constexpr auto q = mag<ratio{4, 5}>() / mag<ratio{4, 3}>();
+//     CHECK(q == mag<ratio{3, 5}>());
+//   }
+// }
+
+// TEST_CASE("Can raise Magnitudes to rational powers")
+// {
+//   SECTION("Anything to the 0 is 1")
+//   {
+//     CHECK(pow<0>(mag<1>()) == mag<1>());
+//     CHECK(pow<0>(mag<123>()) == mag<1>());
+//     CHECK(pow<0>(mag<ratio{3, 4}>()) == mag<1>());
+//     CHECK(pow<0>(pi_to_the<ratio{-1, 2}>()) == mag<1>());
+//   }
+
+//   SECTION("Anything to the 1 is itself")
+//   {
+//     CHECK(pow<1>(mag<1>()) == mag<1>());
+//     CHECK(pow<1>(mag<123>()) == mag<123>());
+//     CHECK(pow<1>(mag<ratio{3, 4}>()) == mag<ratio{3, 4}>());
+//     CHECK(pow<1>(pi_to_the<ratio{-1, 2}>()) == pi_to_the<ratio{-1, 2}>());
+//   }
+
+//   SECTION("Can raise to arbitrary rational power")
+//   {
+//     CHECK(pow<ratio{-8, 3}>(pi_to_the<ratio{-1, 2}>()) == pi_to_the<ratio{4, 3}>());
+//   }
+// }
+
+// TEST_CASE("can distinguish integral, rational, and irrational magnitudes")
+// {
+//   SECTION("Integer magnitudes are integral and rational")
+//   {
+//     auto check_rational_and_integral = [](Magnitude auto m) {
+//       CHECK(is_integral(m));
+//       CHECK(is_rational(m));
+//     };
+//     check_rational_and_integral(magnitude<>{});
+//     check_rational_and_integral(mag<1>());
+//     check_rational_and_integral(mag<3>());
+//     check_rational_and_integral(mag<8>());
+//     check_rational_and_integral(mag<412>());
+//     check_rational_and_integral(mag<ratio{1, 1}>());
+//   }
+
+//   SECTION("Fractional magnitudes are rational, but not integral")
+//   {
+//     auto check_rational_but_not_integral = [](Magnitude auto m) {
+//       CHECK(!is_integral(m));
+//       CHECK(is_rational(m));
+//     };
+//     check_rational_but_not_integral(mag<ratio{1, 2}>());
+//     check_rational_but_not_integral(mag<ratio{5, 8}>());
+//   }
+// }
+
+// TEST_CASE("Constructing ratio from rational magnitude")
+// {
+//   SECTION("Round trip is identity")
+//   {
+//     // Note that not every Magnitude can be represented as a ratio.  However, if we _start_ with a
+//     // ratio, we must guarantee to recover the same ratio in a round trip.
+//     check_ratio_round_trip_is_identity<1>();
+//     check_ratio_round_trip_is_identity<9>();
+//     check_ratio_round_trip_is_identity<ratio{5, 8}>();
+//   }
+
+//   SECTION("Rational magnitude converts to ratio")
+//   {
+//     constexpr ratio r = as_ratio(mag<ratio{22, 7}>());
+//     CHECK(r == ratio{22, 7});
+//   }
+
+//   SECTION("Irrational magnitude does not convert to ratio")
+//   {
+//     // The following code should not compile.
+//     // as_ratio(pow<ratio{1, 2}>(mag<2>()));
+
+//     // The following code should not compile.
+//     // as_ratio(mag<180>() / pi_to_the<1>());
+//   }
+// }
+
+// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// // Detail function tests below.
+
+// TEST_CASE("int_power computes integer powers")
+// {
+//   SECTION("handles floating point")
+//   {
+//     check_same_type_and_value(int_power(0.123L, 0), 1.0L);
+//     check_same_type_and_value(int_power(0.246f, 1), 0.246f);
+//     check_same_type_and_value(int_power(0.5f, 3), 0.125f);
+//     check_same_type_and_value(int_power(2.5, 4), 39.0625);
+
+//     CHECK(std::is_same_v<long double, decltype(compute_base_power<double>(base_power{10, 20}))>);
+//   }
+
+//   SECTION("handles integral")
+//   {
+//     check_same_type_and_value(int_power(8, 0), 1);
+//     check_same_type_and_value(int_power(9L, 1), 9L);
+//     check_same_type_and_value(int_power(2, 10), 1024);
+//   }
+// }
+
+// TEST_CASE("integer_part picks out integer part of single-basis magnitude")
+// {
+//   SECTION("integer_part of non-integer base is identity magnitude")
+//   {
+//     CHECK(integer_part(pi_to_the<1>()) == magnitude<>{});
+//     CHECK(integer_part(pi_to_the<-8>()) == magnitude<>{});
+//     CHECK(integer_part(pi_to_the<ratio{3, 4}>()) == magnitude<>{});
+//   }
+
+//   SECTION("integer_part of integer base to negative power is identity magnitude")
+//   {
+//     CHECK(integer_part(magnitude<base_power{2, -8}>{}) == magnitude<>{});
+//     CHECK(integer_part(magnitude<base_power{11, -1}>{}) == magnitude<>{});
+//   }
+
+//   SECTION("integer_part of integer base to fractional power is identity magnitude")
+//   {
+//     CHECK(integer_part(magnitude<base_power{2, ratio{1, 2}}>{}) == magnitude<>{});
+//   }
+
+//   SECTION("integer_part of integer base to power at least one takes integer part")
+//   {
+//     CHECK(integer_part(magnitude<base_power{2, 1}>{}) == magnitude<base_power{2, 1}>{});
+//     CHECK(integer_part(magnitude<base_power{2, ratio{19, 10}}>{}) == magnitude<base_power{2, 1}>{});
+//     CHECK(integer_part(magnitude<base_power{11, ratio{97, 9}}>{}) == magnitude<base_power{11, 10}>{});
+//   }
+// }
+
+// TEST_CASE("Prime helper functions")
+// {
+//   SECTION("multiplicity")
+//   {
+//     CHECK(multiplicity(2, 8) == 3);
+//     CHECK(multiplicity(2, 1024) == 10);
+//     CHECK(multiplicity(11, 6655) == 3);
+//   }
+
+//   SECTION("remove_power()")
+//   {
+//     CHECK(remove_power(17, 0, 5) == 5);
+//     CHECK(remove_power(2, 3, 24) == 3);
+//     CHECK(remove_power(11, 3, 6655) == 5);
+//   }
+// }
+
+// TEST_CASE("Prime factorization")
+// {
+//   SECTION("1 factors into the null magnitude") { CHECK(prime_factorization_v<1> == magnitude<>{}); }
+
+//   SECTION("Prime numbers factor into themselves")
+//   {
+//     CHECK(prime_factorization_v<2> == magnitude<base_power{2}>{});
+//     CHECK(prime_factorization_v<3> == magnitude<base_power{3}>{});
+//     CHECK(prime_factorization_v<5> == magnitude<base_power{5}>{});
+//     CHECK(prime_factorization_v<7> == magnitude<base_power{7}>{});
+//     CHECK(prime_factorization_v<11> == magnitude<base_power{11}>{});
+
+//     CHECK(prime_factorization_v<41> == magnitude<base_power{41}>{});
+//   }
+
+//   SECTION("Prime factorization finds factors and multiplicities")
+//   {
+//     CHECK(prime_factorization_v<792> == magnitude<base_power{2, 3}, base_power{3, 2}, base_power{11}>{});
+//   }
+// }
+
+// TEST_CASE("is_prime detects primes")
+// {
+//   SECTION("Non-positive numbers are not prime")
+//   {
+//     CHECK(!is_prime(-1328));
+//     CHECK(!is_prime(-1));
+//     CHECK(!is_prime(0));
+//   }
+
+//   SECTION("1 is not prime") { CHECK(!is_prime(1)); }
+
+//   SECTION("Discriminates between primes and non-primes")
+//   {
+//     CHECK(is_prime(2));
+//     CHECK(is_prime(3));
+//     CHECK(!is_prime(4));
+//     CHECK(is_prime(5));
+//     CHECK(!is_prime(6));
+//     CHECK(is_prime(7));
+//     CHECK(!is_prime(8));
+//     CHECK(!is_prime(9));
+
+//     CHECK(is_prime(7919));
+//   }
+// }
+
+// TEST_CASE("is_valid_base_power")
+// {
+//   SECTION("0 power is invalid")
+//   {
+//     REQUIRE(is_valid_base_power(base_power{2}));
+//     CHECK(!is_valid_base_power(base_power{2, 0}));
+
+//     REQUIRE(is_valid_base_power(base_power{41}));
+//     CHECK(!is_valid_base_power(base_power{41, 0}));
+
+//     REQUIRE(is_valid_base_power(base_power<pi_base>{}));
+//     CHECK(!is_valid_base_power(base_power<pi_base>{0}));
+//   }
+
+//   SECTION("non-prime integers are invalid")
+//   {
+//     CHECK(!is_valid_base_power(base_power{-8}));
+//     CHECK(!is_valid_base_power(base_power{0}));
+//     CHECK(!is_valid_base_power(base_power{1}));
+
+//     CHECK(is_valid_base_power(base_power{2}));
+//     CHECK(is_valid_base_power(base_power{3}));
+
+//     CHECK(!is_valid_base_power(base_power{4}));
+//   }
+
+//   SECTION("non-positive floating point bases are invalid")
+//   {
+//     CHECK(!is_valid_base_power(base_power<invalid_zero_base>{}));
+//     CHECK(!is_valid_base_power(base_power<invalid_negative_base>{}));
+//   }
+// }
+
+// TEST_CASE("pairwise_all evaluates all pairs")
+// {
+//   const auto all_pairs_return_true = pairwise_all{[](auto, auto) { return true; }};
+//   const auto all_pairs_return_false = pairwise_all{[](auto, auto) { return false; }};
+//   const auto all_increasing = pairwise_all{std::less{}};
+
+//   SECTION("always true for empty tuples")
+//   {
+//     CHECK(all_pairs_return_true());
+//     CHECK(all_pairs_return_false());
+//   }
+
+//   SECTION("always true for single-element tuples")
+//   {
+//     CHECK(all_pairs_return_true(1));
+//     CHECK(all_pairs_return_false(3.14));
+//     CHECK(all_pairs_return_true('x'));
+//   }
+
+//   SECTION("true for longer tuples iff true for all neighbouring pairs")
+//   {
+//     CHECK(all_increasing(1, 1.5));
+//     CHECK(all_increasing(1, 1.5, 2));
+
+//     CHECK(!all_increasing(1, 2.0, 2));
+//     CHECK(!all_increasing(1, 2.5, 2));
+
+//     CHECK(all_pairs_return_true('c', 1, 8.9, 42u));
+//     CHECK(!all_pairs_return_false('c', 1, 8.9, 42u));
+//   }
+// }
+
+// TEST_CASE("strictly_increasing")
+// {
+//   SECTION("Empty input is sorted") { CHECK(strictly_increasing()); }
+
+//   SECTION("Single-element input is sorted")
+//   {
+//     CHECK(strictly_increasing(3));
+//     CHECK(strictly_increasing(15.42));
+//     CHECK(strictly_increasing('c'));
+//   }
+
+//   SECTION("Multi-value inputs compare correctly")
+//   {
+//     CHECK(strictly_increasing(3, 3.14));
+//     CHECK(!strictly_increasing(3, 3.0));
+//     CHECK(!strictly_increasing(4, 3.0));
+//   }
+// }
+
+// TEST_CASE("extract_power_of_10")
+// {
+//   SECTION("Picks out positive powers")
+//   {
+//     CHECK(extract_power_of_10(mag<10>()) == 1);
+//     CHECK(extract_power_of_10(mag<20>()) == 1);
+//     CHECK(extract_power_of_10(mag<40>()) == 1);
+//     CHECK(extract_power_of_10(mag<50>()) == 1);
+//     CHECK(extract_power_of_10(mag<100>()) == 2);
+//   }
+
+//   SECTION("Picks out negative powers")
+//   {
+//     constexpr auto ONE = mag<1>();
+//     CHECK(extract_power_of_10(ONE / mag<10>()) == -1);
+//     CHECK(extract_power_of_10(ONE / mag<20>()) == -1);
+//     CHECK(extract_power_of_10(ONE / mag<40>()) == -1);
+//     CHECK(extract_power_of_10(ONE / mag<50>()) == -1);
+//     CHECK(extract_power_of_10(ONE / mag<100>()) == -2);
+//   }
+
+//   SECTION("Zero if signs disagree") { CHECK(extract_power_of_10(mag<2>() / mag<5>()) == 0); }
+
+//   SECTION("Handles rational powers") { CHECK(extract_power_of_10(sqrt(mag<1000>())) == 1); }
+// }
+
+}  // namespace
+
+
+// mag<2> * Constant<2> * Constant<3> * Constant<2> * mag<3> * mag<2> * mag<2> * Constant<2> -> pow<Constant<2>, 3>,
+// pow<mag<2>, 3>, Constant<3>, mag<3>
+
+// mag_A * mag<2> * magA
+// mag<2> * mag_A * magAA * magA -> the same value different name
diff --git a/test/unit_test/static/unit_test.cpp b/test/unit_test/static/unit_test.cpp
index ded5edad..4c3c4569 100644
--- a/test/unit_test/static/unit_test.cpp
+++ b/test/unit_test/static/unit_test.cpp
@@ -30,6 +30,83 @@
 
 namespace {
 
+// clang-format off
+// base units
+inline constexpr struct second_ : named_unit<"s"> {} second;
+inline constexpr struct metre_ : named_unit<"m"> {} metre;
+inline constexpr struct gram_ : named_unit<"g"> {} gram;
+inline constexpr struct kilogram_ : decltype(kilo<gram>) {} kilogram;
+
+// derived named units
+inline constexpr struct radian_ : named_unit<"rad", metre / metre> {} radian;
+inline constexpr struct steradian_ : named_unit<"sr", square<metre> / square<metre>> {} steradian;
+inline constexpr struct hertz_ : named_unit<"Hz", 1 / second> {} hertz;
+inline constexpr struct becquerel : named_unit<"Bq", 1 / second> {} becquerel;
+inline constexpr struct newton_ : named_unit<"N", kilogram * metre / square<second>> {} newton;
+inline constexpr struct pascal_ : named_unit<"Pa", newton / square<metre>> {} pascal;
+inline constexpr struct joule_ : named_unit<"J", newton * metre> {} joule;
+inline constexpr struct watt_ : named_unit<"W", joule / second> {} watt;
+
+inline constexpr struct minute_ : named_unit<"min", mag<60> * second> {} minute;
+inline constexpr struct hour_ : named_unit<"h", mag<60> * minute> {} hour;
+inline constexpr struct day_ : named_unit<"d", mag<24> * hour> {} day;
+inline constexpr struct astronomical_unit_ : named_unit<"au", mag<149'597'870'700> * metre> {} astronomical_unit;
+inline constexpr struct degree_ : named_unit<basic_symbol_text{"°", "deg"}, mag_pi / mag<180> * radian> {} degree;
+inline constexpr struct are_ : named_unit<"a", square<deca<metre>>> {} are;
+inline constexpr struct hectare_ : decltype(hecto<are>) {} hectare;
+inline constexpr struct litre_ : named_unit<"l", cubic<deci<metre>>> {} litre;
+inline constexpr struct tonne_ : named_unit<"t", mag<1000> * kilogram> {} tonne;
+inline constexpr struct dalton_ : named_unit<"Da", mag<ratio{16'605'390'666'050, 10'000'000'000'000}> * mag_power<10, -27> * kilogram> {} dalton;
+inline constexpr struct electronvolt_ : named_unit<"eV", mag<ratio{1'602'176'634, 1'000'000'000}> * mag_power<10, -19> * joule> {} electronvolt;
+
+inline constexpr struct kilometre_ : decltype(kilo<metre>) {} kilometre;
+// clang-format on
+
+}
+
+// concepts verification
+static_assert(Unit<metre_>);
+static_assert(Unit<kilogram_>);
+static_assert(Unit<hertz_>);
+static_assert(Unit<newton_>);
+static_assert(Unit<minute_>);
+static_assert(Unit<decltype(kilo<gram>)>);
+static_assert(Unit<decltype(square<metre>)>);
+static_assert(Unit<decltype(cubic<metre>)>);
+static_assert(Unit<decltype(mag<60> * second)>);
+static_assert(Unit<kilometre_>);
+
+static_assert(NamedUnit<metre_>);
+static_assert(NamedUnit<kilogram_>);
+static_assert(NamedUnit<hertz_>);
+static_assert(NamedUnit<newton_>);
+static_assert(NamedUnit<minute_>);
+static_assert(!NamedUnit<decltype(kilo<gram>)>);
+static_assert(!NamedUnit<decltype(square<metre>)>);
+static_assert(!NamedUnit<decltype(cubic<metre>)>);
+static_assert(!NamedUnit<decltype(mag<60> * second)>);
+static_assert(!NamedUnit<kilometre_>);
+
+
+static_assert(kilo<metre> == kilometre);
+static_assert(mag<1000> * metre == kilo<metre>);
+static_assert(mag<1000> * metre == kilometre);
+static_assert(equivalent<kilo<metre>, kilometre>);
+static_assert(equivalent<mag<1000> * metre, kilo<metre>>);
+static_assert(equivalent<mag<1000> * metre, kilometre>);
+
+static_assert(metre != kilometre);
+static_assert(mag<100> * metre != kilometre);
+static_assert(milli<metre> != kilometre);
+static_assert(!equivalent<metre, kilometre>);
+static_assert(!equivalent<mag<100> * metre, kilometre>);
+static_assert(!equivalent<milli<metre>, kilometre>);
+
+static_assert(1 / second != hertz);
+static_assert(becquerel != hertz);
+static_assert(equivalent<1 / second, hertz>);
+static_assert(!equivalent<becquerel, hertz>);
+
 using namespace units;
 using namespace units::isq;