From 3e9d5ca189ad8ec1c21b8ce75128fd4a639711c1 Mon Sep 17 00:00:00 2001 From: Mateusz Pusz Date: Wed, 9 Sep 2020 11:20:55 +0200 Subject: [PATCH] refactor: :recycle: `unitless` renamed to `one` Resolves #27 --- docs/framework/constants.rst | 2 +- docs/framework/conversions_and_casting.rst | 16 +++---- docs/framework/quantities.rst | 6 +-- src/include/units/dimensionless.h | 6 +-- .../units/physical/natural/constants.h | 2 +- .../units/physical/natural/dimensions.h | 2 +- src/include/units/physical/natural/units.h | 1 - src/include/units/quantity.h | 2 +- test/unit_test/runtime/fmt_test.cpp | 4 +- test/unit_test/static/quantity_test.cpp | 46 +++++++++---------- test/unit_test/static/si_test.cpp | 8 ++-- 11 files changed, 47 insertions(+), 48 deletions(-) diff --git a/docs/framework/constants.rst b/docs/framework/constants.rst index dfc070f3..0b19539f 100644 --- a/docs/framework/constants.rst +++ b/docs/framework/constants.rst @@ -28,6 +28,6 @@ The same constant defined for natural units may be provided as:: namespace natural { template - inline constexpr auto speed_of_light = speed(1); + inline constexpr auto speed_of_light = speed(1); } diff --git a/docs/framework/conversions_and_casting.rst b/docs/framework/conversions_and_casting.rst index 04855279..5e0eaeca 100644 --- a/docs/framework/conversions_and_casting.rst +++ b/docs/framework/conversions_and_casting.rst @@ -110,16 +110,16 @@ represent numbers it would be highly uncomfortable to every time type:: const auto d1 = 10q_km; const auto d2 = 3q_km; - if(d1 / d2 > dimensionless) { + if(d1 / d2 > dimensionless) { // ... } or:: const auto fill_time_left = (box.height / box.fill_level(measured_mass) - - dimensionless) * fill_time; + dimensionless) * fill_time; -This is why it was decided to allow the ``dimensionless`` quantity of any +This is why it was decided to allow the ``dimensionless`` quantity of any representation type to be implicitly constructible from this representation type. With that the above examples can be rewritten as follows:: @@ -133,7 +133,7 @@ and:: const auto fill_time_left = (box.height / box.fill_level(measured_mass) - 1) * fill_time; -The above is true only for dimensionless quantities of `unitless` unit. If our quantity have a unit with +The above is true only for dimensionless quantities of `one` unit. If our quantity have a unit with ratio different than ``1`` the implicit conversion will not happen. This is to prevent cases were the code could be ambiguous. For example:: @@ -148,14 +148,14 @@ either change the type of the resulting unit to the one having ``ratio(1)`` (:te Dimensionless auto foo(Length auto d1, Length auto d2) { - return quantity_cast(d1 / d2) + 1; + return quantity_cast(d1 / d2) + 1; } -or to explicitly state what is the unit of our dimensionless value, e.g. `unitless`, `percent`, etc:: +or to explicitly state what is the unit of our dimensionless value, e.g. `one`, `percent`, etc:: Dimensionless auto foo(Length auto d1, Length auto d2) { - return d1 / d2 + dimensionless(1); + return d1 / d2 + dimensionless(1); } There is one more important point to note here. As the the dimensionless quantity is more than just @@ -166,7 +166,7 @@ code will not compile:: To make it compile fine we have to either explicitly get the value stored in the quantity:: - auto v = std::exp(quantity_cast(10q_m / 5q_m).count()); + auto v = std::exp(quantity_cast(10q_m / 5q_m).count()); or use a mathematical wrapper function from `units` namespace:: diff --git a/docs/framework/quantities.rst b/docs/framework/quantities.rst index 2e2e6fd0..ebb1b167 100644 --- a/docs/framework/quantities.rst +++ b/docs/framework/quantities.rst @@ -167,7 +167,7 @@ Whenever we divide two quantities of the same dimension we end up with a :term:`dimensionless quantity` otherwise known as :term:`quantity of dimension one`:: static_assert(10q_km / 5q_km == 2); - static_assert(std::is_same_v>); + static_assert(std::is_same_v>); According to the official ISO definition `dim_one` is a dimension "for which all the exponents of the factors corresponding to the base quantities in its quantity dimension @@ -189,10 +189,10 @@ are provided:: There are two special units provided for usage with such a quantity: -- `unitless` which is the :ref:`coherent unit` of dimensionless quantity and does not +- `one` which is the :ref:`coherent unit` of dimensionless quantity and does not provide any textual symbol (according to the ISO definition "the measurement units and values of quantities of dimension one are numbers"), -- `percent` which has the symbol ``%`` and ``ratio(1, 100)`` of the `unitless` unit. +- `percent` which has the symbol ``%`` and ``ratio(1, 100)`` of the `one` unit. For example the following code:: diff --git a/src/include/units/dimensionless.h b/src/include/units/dimensionless.h index 02e36307..14aba730 100644 --- a/src/include/units/dimensionless.h +++ b/src/include/units/dimensionless.h @@ -26,8 +26,8 @@ namespace units { -struct unitless : named_unit {}; -struct percent : named_scaled_unit {}; +struct one : named_unit {}; +struct percent : named_scaled_unit {}; /** * @brief Dimension one @@ -35,7 +35,7 @@ struct percent : named_scaled_unit {}; +struct dim_one : derived_dimension {}; template concept Dimensionless = QuantityOf; diff --git a/src/include/units/physical/natural/constants.h b/src/include/units/physical/natural/constants.h index 20c37379..fa19049f 100644 --- a/src/include/units/physical/natural/constants.h +++ b/src/include/units/physical/natural/constants.h @@ -27,6 +27,6 @@ namespace units::physical::natural { template -inline constexpr auto speed_of_light = speed(1); +inline constexpr auto speed_of_light = speed(1); } // namespace units::physical::natural diff --git a/src/include/units/physical/natural/dimensions.h b/src/include/units/physical/natural/dimensions.h index 1881f1bb..d4291bda 100644 --- a/src/include/units/physical/natural/dimensions.h +++ b/src/include/units/physical/natural/dimensions.h @@ -40,7 +40,7 @@ struct dim_mass : physical::dim_mass {}; template using mass = quantity; -struct dim_speed : physical::dim_speed {}; +struct dim_speed : physical::dim_speed {}; template using speed = quantity; diff --git a/src/include/units/physical/natural/units.h b/src/include/units/physical/natural/units.h index 3d7c71c4..ec42e1f0 100644 --- a/src/include/units/physical/natural/units.h +++ b/src/include/units/physical/natural/units.h @@ -27,7 +27,6 @@ namespace units::physical::natural { -struct unitless : named_unit {}; struct electronvolt : named_unit {}; struct gigaelectronvolt : prefixed_unit {}; struct inverted_gigaelectronvolt : named_unit {}; diff --git a/src/include/units/quantity.h b/src/include/units/quantity.h index ef7fec71..437299f6 100644 --- a/src/include/units/quantity.h +++ b/src/include/units/quantity.h @@ -73,7 +73,7 @@ public: template requires detail::safe_convertible - constexpr explicit(!(std::is_same_v && std::is_same_v)) quantity(const Value& v) : value_{static_cast(v)} {} + constexpr explicit(!(std::is_same_v && std::is_same_v)) quantity(const Value& v) : value_{static_cast(v)} {} template requires equivalent_dim && diff --git a/test/unit_test/runtime/fmt_test.cpp b/test/unit_test/runtime/fmt_test.cpp index f03cc87c..01502f6a 100644 --- a/test/unit_test/runtime/fmt_test.cpp +++ b/test/unit_test/runtime/fmt_test.cpp @@ -423,7 +423,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]") SECTION("dimensionless quantity") { - SECTION("unitless with ratio == 1") + SECTION("one with ratio == 1") { const auto q = 4q_m / 2q_m; os << q; @@ -444,7 +444,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]") } } - SECTION("unitless with ratio.exp != 0") + SECTION("one with ratio.exp != 0") { const auto q = 4q_km / 2q_m; os << q; diff --git a/test/unit_test/static/quantity_test.cpp b/test/unit_test/static/quantity_test.cpp index db046b65..7080c65a 100644 --- a/test/unit_test/static/quantity_test.cpp +++ b/test/unit_test/static/quantity_test.cpp @@ -168,8 +168,8 @@ static_assert(is_same_v()), physical::si::tim static_assert(is_same_v()), quantity>, scaled_unit>>); static_assert(is_same_v() / 1.0), length>); -static_assert(is_same_v() / length()), dimensionless>); -static_assert(is_same_v() / length()), dimensionless, double>>); +static_assert(is_same_v() / length()), dimensionless>); +static_assert(is_same_v() / length()), dimensionless, double>>); static_assert( is_same_v() / physical::si::time()), speed>); static_assert( @@ -195,16 +195,16 @@ static_assert((7q_km % 2000q_m).count() == 1000); static_assert((10q_km2 * 10q_km2) / 50q_km2 == 2q_km2); constexpr auto q1 = 10q_km / 5q_m; -static_assert(std::is_same_v, std::int64_t>>); +static_assert(std::is_same_v, std::int64_t>>); static_assert(q1.count() == 2); -constexpr dimensionless q2 = q1; +constexpr dimensionless q2 = q1; static_assert(q2.count() == 2000); -static_assert(quantity_cast(q1).count() == 2000); +static_assert(quantity_cast(q1).count() == 2000); constexpr auto q3 = 10q_s * 2q_kHz; -static_assert(std::is_same_v, std::int64_t>>); +static_assert(std::is_same_v, std::int64_t>>); static_assert(q3.count() == 20); // comparators @@ -279,32 +279,32 @@ static_assert(quantity_cast(1.23q_m).count() == 1); // dimensionless -static_assert(std::is_convertible_v>); -static_assert(std::is_convertible_v>); -static_assert(!std::is_convertible_v>); -static_assert(std::is_convertible_v>); +static_assert(std::is_convertible_v>); +static_assert(std::is_convertible_v>); +static_assert(!std::is_convertible_v>); +static_assert(std::is_convertible_v>); -static_assert(!std::is_convertible_v>>); -static_assert(std::is_constructible_v>, double>); +static_assert(!std::is_convertible_v>>); +static_assert(std::is_constructible_v>, double>); -static_assert(dimensionless(1.23) + dimensionless(1.23) == dimensionless(2.46)); -static_assert(dimensionless(1.23) + dimensionless(1.23) == 2.46); -static_assert(dimensionless(1.23) + 1.23 == 2.46); -static_assert(1.23 + dimensionless(1.23) == 2.46); -static_assert(dimensionless(1) + 1 == 2); -static_assert(dimensionless(1) + 1 == 2); +static_assert(dimensionless(1.23) + dimensionless(1.23) == dimensionless(2.46)); +static_assert(dimensionless(1.23) + dimensionless(1.23) == 2.46); +static_assert(dimensionless(1.23) + 1.23 == 2.46); +static_assert(1.23 + dimensionless(1.23) == 2.46); +static_assert(dimensionless(1) + 1 == 2); +static_assert(dimensionless(1) + 1 == 2); template concept invalid_dimensionless_operation = requires() { - !requires(dimensionless d) { d + 1.23; }; - !requires(dimensionless d) { 1.23 + d; }; - !requires(dimensionless, Rep> d) { 1 + d; }; - !requires(dimensionless, Rep> d) { d + 1; }; + !requires(dimensionless d) { d + 1.23; }; + !requires(dimensionless d) { 1.23 + d; }; + !requires(dimensionless, Rep> d) { 1 + d; }; + !requires(dimensionless, Rep> d) { d + 1; }; }; static_assert(invalid_dimensionless_operation); -static_assert(std::is_same_v>); +static_assert(std::is_same_v>); static_assert(quantity_cast(50.q_m / 100.q_m).count() == 50); static_assert(50.q_m / 100.q_m == dimensionless(50)); diff --git a/test/unit_test/static/si_test.cpp b/test/unit_test/static/si_test.cpp index 16e9196c..6c12779a 100644 --- a/test/unit_test/static/si_test.cpp +++ b/test/unit_test/static/si_test.cpp @@ -41,8 +41,8 @@ static_assert(1q_au == 149'597'870'700q_m); static_assert(1q_km + 1q_m == 1001q_m); static_assert(10q_km / 5q_km == 2); static_assert(10q_km / 5q_km < 3); -static_assert(100q_mm / 5q_cm == dimensionless>(20)); -static_assert(100q_mm / 5q_cm == dimensionless(2)); +static_assert(100q_mm / 5q_cm == dimensionless>(20)); +static_assert(100q_mm / 5q_cm == dimensionless(2)); static_assert(10q_km / 2 == 5q_km); static_assert(millimetre::symbol == "mm"); @@ -105,8 +105,8 @@ static_assert(1000 / 1q_s == 1q_kHz); static_assert(1 / 1q_ms == 1q_kHz); static_assert(3.2q_GHz == 3'200'000'000q_Hz); static_assert((10q_Hz * 1q_min).count() == 10); -static_assert(10q_Hz * 1q_min == dimensionless>(10)); -static_assert(10q_Hz * 1q_min == dimensionless(600)); +static_assert(10q_Hz * 1q_min == dimensionless>(10)); +static_assert(10q_Hz * 1q_min == dimensionless(600)); static_assert(2 / 1q_Hz == 2q_s); // force