feedc0de/mp-units
1
0
Fork 0
forked from mpusz/mp-units
Code Pull Requests Activity

UDL naming refactored

Browse Source
This commit is contained in:
Mateusz Pusz
2020-03-10 20:53:53 +01:00
parent d67eabf310
commit 6a5f25750d
22 changed files with 93 additions and 93 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
README.md
View File

@@ -38,9 +38,9 @@ static_assert(1q_km + 1q_m == 1001q_m);
static_assert(2q_m * 3q_m == 6q_m2);
static_assert(10q_km / 5q_km == 2);
static_assert(1000 / 1q_s == 1q_kHz);
static_assert(1q_km / 1q_s == 1000q_mps);
static_assert(2q_kmph * 2q_h == 4q_km);
static_assert(2q_km / 2q_kmph == 1q_h);
static_assert(1q_km / 1q_s == 1000q_m_per_s);
static_assert(2q_km_per_h * 2q_h == 4q_km);
static_assert(2q_km / 2q_km_per_h == 1q_h);
```
_Try it on the [Compiler Explorer](???)._

8
docs/DESIGN.md
View File

@@ -18,9 +18,9 @@ static_assert(1q_h == 3600q_s);
static_assert(1q_km + 1q_m == 1001q_m);
// dimension conversions
static_assert(1q_km / 1q_s == 1000q_mps);
static_assert(2q_kmph * 2q_h == 4q_km);
static_assert(2q_km / 2q_kmph == 1q_h);
static_assert(1q_km / 1q_s == 1000q_m_per_s);
static_assert(2q_km_per_h * 2q_h == 4q_km);
static_assert(2q_km / 2q_km_per_h == 1q_h);
static_assert(1000 / 1q_s == 1q_kHz);
@@ -574,7 +574,7 @@ If the `units-specs` is omitted, the `quantity` object is formatted as if by str
additional padding and adjustments as specified by the format specifiers.
```cpp
std::string s = fmt::format("{:=>12}", 120q_kmph); // value of s is "====120 km/h"
std::string s = fmt::format("{:=>12}", 120q_km_per_h); // value of s is "====120 km/h"
```

6
docs/quick_start.rst
View File

@@ -14,9 +14,9 @@ Here is a small example of possible operations::
static_assert(2q_m * 3q_m == 6q_m2);
static_assert(10q_km / 5q_km == 2);
static_assert(1000 / 1q_s == 1q_kHz);
static_assert(1q_km / 1q_s == 1000q_mps);
static_assert(2q_kmph * 2q_h == 4q_km);
static_assert(2q_km / 2q_kmph == 1q_h);
static_assert(1q_km / 1q_s == 1000q_m_per_s);
static_assert(2q_km_per_h * 2q_h == 4q_km);
static_assert(2q_km / 2q_km_per_h == 1q_h);
.. admonition:: Try it on Compiler Explorer

2
example/alternative_namespaces/box_example.cpp
View File

@@ -102,7 +102,7 @@ using namespace units::si::literals;
int main()
{
auto box = Box{1000.0q_mm, 500.0q_mm, 200.0q_mm};
box.set_contents_density(1000.0q_kgpm3);
box.set_contents_density(1000.0q_kg_per_m3);
auto fill_time = 200.0q_s; // time since starting fill
auto measured_mass = 20.0q_kg; // measured mass at fill_time

4
example/box_example.cpp
View File

@@ -25,7 +25,7 @@ inline constexpr auto g = si::standard_gravity;
} // namespace
struct Box {
static constexpr auto air_density = 1.225q_kgpm3;
static constexpr auto air_density = 1.225q_kg_per_m3;
si::length<m> length;
si::length<m> width;
@@ -66,7 +66,7 @@ struct Box {
int main()
{
auto box = Box(1000.0q_mm, 500.0q_mm, 200.0q_mm);
box.set_contents_density(1000.0q_kgpm3);
box.set_contents_density(1000.0q_kg_per_m3);
const auto fill_time = 200.0q_s; // time since starting fill
const auto measured_mass = 20.0q_kg; // measured mass at fill_time

2
example/kalman_filter-alpha_beta_filter_example2.cpp
View File

@@ -65,7 +65,7 @@ int main()
if(track.size() > 0) {
// We need an initial estimate of track[0] as there is no previous state to get a prediction from
track[0].range.estimated_current_state = 30'000q_m;
track[0].speed.estimated_current_state = 40.0q_mps;
track[0].speed.estimated_current_state = 40.0q_m_per_s;
}
for (auto n = 0U; n < num_measurements; ++n) {

4
src/include/units/physical/cgs/power.h
View File

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

4
src/include/units/physical/cgs/velocity.h
View File

@@ -38,8 +38,8 @@ using velocity = quantity<dim_velocity, U, Rep>;
inline namespace literals {
// cmps
constexpr auto operator"" q_cmps(unsigned long long l) { return velocity<centimetre_per_second, std::int64_t>(l); }
constexpr auto operator"" q_cmps(long double l) { return velocity<centimetre_per_second, long double>(l); }
constexpr auto operator"" q_cm_per_s(unsigned long long l) { return velocity<centimetre_per_second, std::int64_t>(l); }
constexpr auto operator"" q_cm_per_s(long double l) { return velocity<centimetre_per_second, long double>(l); }
} // namespace literals

4
src/include/units/physical/international/velocity.h
View File

@@ -32,8 +32,8 @@ struct mile_per_hour : deduced_unit<mile_per_hour, si::dim_velocity, internation
inline namespace literals {
// mph
constexpr auto operator"" q_mph(unsigned long long l) { return si::velocity<mile_per_hour, std::int64_t>(l); }
constexpr auto operator"" q_mph(long double l) { return si::velocity<mile_per_hour, long double>(l); }
constexpr auto operator"" q_mi_per_h(unsigned long long l) { return si::velocity<mile_per_hour, std::int64_t>(l); }
constexpr auto operator"" q_mi_per_h(long double l) { return si::velocity<mile_per_hour, long double>(l); }
} // namespace literals

4
src/include/units/physical/si/acceleration.h
View File

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

4
src/include/units/physical/si/constants.h
View File

@@ -37,10 +37,10 @@ inline constexpr auto reduced_planck_constant = 6.582119569e-10q_GeV * 1q_s;
inline constexpr auto elementary_charge = 1.602176634e-19q_C;
inline constexpr auto boltzmann_constant = 1.380649e-23q_J / 1q_K;
inline constexpr auto avogadro_constant = 6.02214076e23 / 1q_mol;
inline constexpr auto speed_of_light = 299792458q_mps;
inline constexpr auto speed_of_light = 299792458q_m_per_s;
inline constexpr auto hyperfine_structure_transition_frequency = 9192631770q_Hz;
// inline constexpr auto luminous_efficacy = 683q_lm / 1q_W;
inline constexpr auto standard_gravity = 9.80665q_mps2;
inline constexpr auto standard_gravity = 9.80665q_m_per_s2;
} // namespace units::si

4
src/include/units/physical/si/density.h
View File

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

4
src/include/units/physical/si/momentum.h
View File

@@ -38,8 +38,8 @@ using momentum = quantity<dim_momentum, U, Rep>;
inline namespace literals {
// kgmps
constexpr auto operator"" q_kgmps(unsigned long long l) { return momentum<kilogram_metre_per_second, std::int64_t>(l); }
constexpr auto operator"" q_kgmps(long double l) { return momentum<kilogram_metre_per_second, long double>(l); }
constexpr auto operator"" q_kg_m_per_s(unsigned long long l) { return momentum<kilogram_metre_per_second, std::int64_t>(l); }
constexpr auto operator"" q_kg_m_per_s(long double l) { return momentum<kilogram_metre_per_second, long double>(l); }
} // namespace literals

4
src/include/units/physical/si/surface_tension.h
View File

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

8
src/include/units/physical/si/velocity.h
View File

@@ -40,12 +40,12 @@ using velocity = quantity<dim_velocity, U, Rep>;
inline namespace literals {
// mps
constexpr auto operator"" q_mps(unsigned long long l) { return velocity<metre_per_second, std::int64_t>(l); }
constexpr auto operator"" q_mps(long double l) { return velocity<metre_per_second, long double>(l); }
constexpr auto operator"" q_m_per_s(unsigned long long l) { return velocity<metre_per_second, std::int64_t>(l); }
constexpr auto operator"" q_m_per_s(long double l) { return velocity<metre_per_second, long double>(l); }
// kmph
constexpr auto operator"" q_kmph(unsigned long long l) { return velocity<kilometre_per_hour, std::int64_t>(l); }
constexpr auto operator"" q_kmph(long double l) { return velocity<kilometre_per_hour, long double>(l); }
constexpr auto operator"" q_km_per_h(unsigned long long l) { return velocity<kilometre_per_hour, std::int64_t>(l); }
constexpr auto operator"" q_km_per_h(long double l) { return velocity<kilometre_per_hour, long double>(l); }
} // namespace literals

16
test/unit_test/runtime/fmt_test.cpp
View File

@@ -662,7 +662,7 @@ TEST_CASE("format string with only %Q should print quantity value only", "[text]
{
SECTION("positive value")
{
CHECK(fmt::format("{:%Q}", 123q_kmph) == "123");
CHECK(fmt::format("{:%Q}", 123q_km_per_h) == "123");
}
SECTION("negative value")
@@ -702,39 +702,39 @@ TEST_CASE("format string with only %Q should print quantity value only", "[text]
TEST_CASE("format string with only %q should print quantity unit symbol only", "[text][fmt]")
{
CHECK(fmt::format("{:%q}", 123q_kmph) == "km/h");
CHECK(fmt::format("{:%q}", 123q_km_per_h) == "km/h");
}
TEST_CASE("%q an %Q can be put anywhere in a format string", "[text][fmt]")
{
SECTION("no space")
{
CHECK(fmt::format("{:%Q%q}", 123q_kmph) == "123km/h");
CHECK(fmt::format("{:%Q%q}", 123q_km_per_h) == "123km/h");
}
SECTION("separator")
{
CHECK(fmt::format("{:%Q###%q}", 123q_kmph) == "123###km/h");
CHECK(fmt::format("{:%Q###%q}", 123q_km_per_h) == "123###km/h");
}
SECTION("opposite order")
{
CHECK(fmt::format("{:%q %Q}", 123q_kmph) == "km/h 123");
CHECK(fmt::format("{:%q %Q}", 123q_km_per_h) == "km/h 123");
}
SECTION("tabulator")
{
CHECK(fmt::format("{:%Q%t%q}", 123q_kmph) == "123\tkm/h");
CHECK(fmt::format("{:%Q%t%q}", 123q_km_per_h) == "123\tkm/h");
}
SECTION("new line")
{
CHECK(fmt::format("{:%Q%n%q}", 123q_kmph) == "123\nkm/h");
CHECK(fmt::format("{:%Q%n%q}", 123q_km_per_h) == "123\nkm/h");
}
SECTION("% sign")
{
CHECK(fmt::format("{:%Q%% %q}", 123q_kmph) == "123% km/h");
CHECK(fmt::format("{:%Q%% %q}", 123q_km_per_h) == "123% km/h");
}
}

14
test/unit_test/runtime/fmt_units_test.cpp
View File

@@ -102,7 +102,7 @@ TEST_CASE("fmt::format on synthesized unit symbols", "[text][fmt]")
SECTION("density")
{
CHECK(fmt::format("{}", 1q_kgpm3) == "1 kg/m³");
CHECK(fmt::format("{}", 1q_kg_per_m3) == "1 kg/m³");
}
SECTION("resistance")
@@ -142,19 +142,19 @@ TEST_CASE("fmt::format on synthesized unit symbols", "[text][fmt]")
SECTION("velocity")
{
CHECK(fmt::format("{}", 1q_mps) == "1 m/s");
CHECK(fmt::format("{}", 1q_kmph) == "1 km/h");
CHECK(fmt::format("{}", 1q_mph) == "1 mi/h");
CHECK(fmt::format("{}", 1q_m_per_s) == "1 m/s");
CHECK(fmt::format("{}", 1q_km_per_h) == "1 km/h");
CHECK(fmt::format("{}", 1q_mi_per_h) == "1 mi/h");
}
SECTION("acceleration")
{
CHECK(fmt::format("{}", 1q_mps2) == "1 m/s²");
CHECK(fmt::format("{}", 1q_m_per_s2) == "1 m/s²");
}
SECTION("momentum")
{
CHECK(fmt::format("{}", 1q_kgmps) == "1 kg⋅m/s");
CHECK(fmt::format("{}", 1q_kg_m_per_s) == "1 kg⋅m/s");
}
SECTION("energy")
@@ -175,7 +175,7 @@ TEST_CASE("fmt::format on synthesized unit symbols", "[text][fmt]")
SECTION("surface tension")
{
CHECK(fmt::format("{}", 1q_Npm) == "1 N/m");
CHECK(fmt::format("{}", 1q_N_per_m) == "1 N/m");
}
SECTION("addition with common ratio")

18
test/unit_test/static/cgs_test.cpp
View File

@@ -50,9 +50,9 @@ static_assert(centimetre::symbol == "cm");
// velocity
static_assert(10q_cm / 5q_s == 2q_cmps);
static_assert(10q_cm / 2q_cmps == 5q_s);
static_assert(10q_cm == 2q_cmps * 5q_s);
static_assert(10q_cm / 5q_s == 2q_cm_per_s);
static_assert(10q_cm / 2q_cm_per_s == 5q_s);
static_assert(10q_cm == 2q_cm_per_s * 5q_s);
static_assert(detail::unit_text<dim_velocity, centimetre_per_second>() == "cm/s");
@@ -68,9 +68,9 @@ static_assert(detail::unit_text<dim_area, square_centimetre>() == "cm²");
// acceleration
static_assert(10q_cmps / 10q_s == 1q_Gal);
static_assert(10q_cmps / 1q_Gal == 10q_s);
static_assert(1q_Gal * 10q_s == 10q_cmps);
static_assert(10q_cm_per_s / 10q_s == 1q_Gal);
static_assert(10q_cm_per_s / 1q_Gal == 10q_s);
static_assert(1q_Gal * 10q_s == 10q_cm_per_s);
// force
@@ -94,9 +94,9 @@ static_assert(100q_erg / 10q_dyn == 10q_cm);
// power
static_assert(10q_erg / 10q_s == 1q_ergps);
static_assert(1q_ergps * 10q_s == 10q_erg);
static_assert(10q_erg / 1q_ergps == 10q_s);
static_assert(10q_erg / 10q_s == 1q_erg_per_s);
static_assert(1q_erg_per_s * 10q_s == 10q_erg);
static_assert(10q_erg / 1q_erg_per_s == 10q_s);
static_assert(detail::unit_text<dim_power, erg_per_second>() == "erg/s");

10
test/unit_test/static/quantity_test.cpp
View File

@@ -340,11 +340,11 @@ static_assert(10q_km / 2 == 5q_km);
// velocity
static_assert(10q_m / 5q_s == 2q_mps);
static_assert(10 / 5q_s * 1q_m == 2q_mps);
static_assert(1q_km / 1q_s == 1000q_mps);
static_assert(2q_kmph * 2q_h == 4q_km);
static_assert(2q_km / 2q_kmph == 1q_h);
static_assert(10q_m / 5q_s == 2q_m_per_s);
static_assert(10 / 5q_s * 1q_m == 2q_m_per_s);
static_assert(1q_km / 1q_s == 1000q_m_per_s);
static_assert(2q_km_per_h * 2q_h == 4q_km);
static_assert(2q_km / 2q_km_per_h == 1q_h);
static_assert(std::is_same_v<decltype(pow<2>(2q_m)), decltype(4q_m2)>);

14
test/unit_test/static/si_cgs_test.cpp
View File

@@ -64,8 +64,8 @@ using namespace units::si::literals;
static_assert(cgs::length<cgs::centimetre>(100) == 1q_m);
static_assert(cgs::mass<cgs::gram>(1'000) == 1q_kg);
static_assert(cgs::time<cgs::second>(1) == 1q_s);
static_assert(cgs::velocity<cgs::centimetre_per_second>(100) == 1q_mps);
static_assert(cgs::acceleration<cgs::gal>(100) == 1q_mps2);
static_assert(cgs::velocity<cgs::centimetre_per_second>(100) == 1q_m_per_s);
static_assert(cgs::acceleration<cgs::gal>(100) == 1q_m_per_s2);
static_assert(cgs::force<cgs::dyne>(100'000) == 1q_N);
static_assert(cgs::energy<cgs::erg>(10'000'000) == 1q_J);
static_assert(cgs::power<cgs::erg_per_second>(10'000'000) == 1q_W);
@@ -80,11 +80,11 @@ using namespace units::cgs::literals;
static_assert(100q_cm == si::length<si::metre>(1));
static_assert(1'000q_g == si::mass<si::kilogram>(1));
static_assert(1q_s == si::time<si::second>(1));
static_assert(100q_cmps == si::velocity<si::metre_per_second>(1));
static_assert(100q_cm_per_s == si::velocity<si::metre_per_second>(1));
static_assert(100q_Gal == si::acceleration<si::metre_per_second_sq>(1));
static_assert(100'000q_dyn == si::force<si::newton>(1));
static_assert(10'000'000q_erg == si::energy<si::joule>(1));
static_assert(10'000'000q_ergps == si::power<si::watt>(1));
static_assert(10'000'000q_erg_per_s == si::power<si::watt>(1));
static_assert(10q_Ba == si::pressure<si::pascal>(1));
}
@@ -97,11 +97,11 @@ using namespace units::cgs::literals;
// static_assert(100q_cm == 1q_m); // ambiguous
// static_assert(1'000q_g == 1q_kg); // ambiguous
static_assert(1q_s == 1q_s);
static_assert(100q_cmps == 1q_mps);
static_assert(100q_Gal == 1q_mps2);
static_assert(100q_cm_per_s == 1q_m_per_s);
static_assert(100q_Gal == 1q_m_per_s2);
static_assert(100'000q_dyn == 1q_N);
static_assert(10'000'000q_erg == 1q_J);
static_assert(10'000'000q_ergps == 1q_W);
static_assert(10'000'000q_erg_per_s == 1q_W);
static_assert(10q_Ba == quantity_cast<double>(1q_Pa));
}

44
test/unit_test/static/si_test.cpp
View File

@@ -122,9 +122,9 @@ static_assert(10q_Hz * 1q_min == 600);
static_assert(2 / 1q_Hz == 2q_s);
// force
static_assert(10q_kg * 10q_mps2 == 100q_N);
static_assert(100q_N / 1q_mps2 == 100q_kg);
static_assert(100q_N / 1q_kg == 100q_mps2);
static_assert(10q_kg * 10q_m_per_s2 == 100q_N);
static_assert(100q_N / 1q_m_per_s2 == 100q_kg);
static_assert(100q_N / 1q_kg == 100q_m_per_s2);
// pressure
@@ -194,30 +194,30 @@ static_assert(10q_V * 1q_F == 10q_C);
static_assert(std::is_same_v<decltype(1q_km / 1q_s), velocity<scaled_unit<ratio<1, 1, 3>, metre_per_second>, std::int64_t>>);
static_assert(10q_m / 5q_s == 2q_mps);
static_assert(10 / 5q_s * 1q_m == 2q_mps);
static_assert(1q_km / 1q_s == 1000q_mps);
// static_assert(1q_km / 1q_h == 1q_kmph); // should not compile
static_assert(1.0q_km / 1q_h == 1q_kmph);
static_assert(1000.0q_m / 3600.0q_s == 1q_kmph);
static_assert(10q_m / 5q_s == 2q_m_per_s);
static_assert(10 / 5q_s * 1q_m == 2q_m_per_s);
static_assert(1q_km / 1q_s == 1000q_m_per_s);
// static_assert(1q_km / 1q_h == 1q_km_per_h); // should not compile
static_assert(1.0q_km / 1q_h == 1q_km_per_h);
static_assert(1000.0q_m / 3600.0q_s == 1q_km_per_h);
static_assert(2q_kmph * 2q_h == 4q_km);
// static_assert(2q_kmph * 15q_min == 500q_m); // should not compile
static_assert(2q_kmph * 15.0q_min == 500q_m);
static_assert(2.0q_kmph * 15q_min == 500q_m);
static_assert(2q_km_per_h * 2q_h == 4q_km);
// static_assert(2q_km_per_h * 15q_min == 500q_m); // should not compile
static_assert(2q_km_per_h * 15.0q_min == 500q_m);
static_assert(2.0q_km_per_h * 15q_min == 500q_m);
static_assert(2q_km / 2q_kmph == 1q_h);
// static_assert(2000q_m / 2q_kmph == 1q_h); // should not compile
static_assert(quantity_cast<kilometre>(2000q_m) / 2q_kmph == 1q_h);
static_assert(2q_km / 2q_km_per_h == 1q_h);
// static_assert(2000q_m / 2q_km_per_h == 1q_h); // should not compile
static_assert(quantity_cast<kilometre>(2000q_m) / 2q_km_per_h == 1q_h);
static_assert(detail::unit_text<dim_velocity, metre_per_second>() == "m/s");
static_assert(kilometre_per_hour::symbol == "km/h");
// acceleration
static_assert(10q_mps / 10q_s == 1q_mps2);
static_assert(10q_mps / 1q_mps2 == 10q_s);
static_assert(1q_mps2 * 10q_s == 10q_mps);
static_assert(10q_m_per_s / 10q_s == 1q_m_per_s2);
static_assert(10q_m_per_s / 1q_m_per_s2 == 10q_s);
static_assert(1q_m_per_s2 * 10q_s == 10q_m_per_s);
static_assert(detail::unit_text<dim_acceleration, metre_per_second_sq>() == "m/s²");
@@ -244,9 +244,9 @@ static_assert(detail::unit_text<dim_volume, cubic_metre>() == "m³");
/* ************** DERIVED DIMENSIONS IN TERMS OF OTHER UNITS **************** */
static_assert(10q_N / 2q_m == 5q_Npm);
static_assert(10q_N / 5q_Npm == 2q_m);
static_assert(2q_m * 5q_Npm == 10q_N);
static_assert(10q_N / 2q_m == 5q_N_per_m);
static_assert(10q_N / 5q_N_per_m == 2q_m);
static_assert(2q_m * 5q_N_per_m == 10q_N);
static_assert(detail::unit_text<dim_surface_tension, newton_per_metre>() == "N/m");

2
test/unit_test/static/us_test.cpp
View File

@@ -54,7 +54,7 @@ static_assert(5q_in + 8q_cm == 207q_mm);
// velocity
static_assert(10.0q_mi / 2q_h == 5q_mph);
static_assert(10.0q_mi / 2q_h == 5q_mi_per_h);
static_assert(mile_per_hour::symbol == "mi/h");