mpusz/mp-units
1
0
Fork 1
mirror of https://github.com/mpusz/mp-units.git synced 2025-08-01 11:24:27 +02:00
Code Issues Packages Projects Releases Wiki Activity

refactor: MP_UNITS_NONCONST_TYPE introduced to benefit from the C++23 feature

Browse Source
This commit is contained in:
Mateusz Pusz
2024-11-13 21:13:22 +01:00
parent 5cd07bc621
commit 2590aa4b80
17 changed files with 64 additions and 59 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
test/static/concepts_test.cpp
View File

@@ -55,7 +55,7 @@ static_assert(!detail::BaseDimension<decltype(isq::dim_length / isq::dim_time)>)
static_assert(!detail::BaseDimension<decltype(inverse(isq::dim_time))>);
static_assert(!detail::BaseDimension<decltype(pow<2>(isq::dim_length))>);
static_assert(!detail::BaseDimension<derived_dimension<struct isq::dim_length, per<struct isq::dim_time>>>);
static_assert(!detail::BaseDimension<std::remove_const_t<decltype(dim_speed)>>);
static_assert(!detail::BaseDimension<MP_UNITS_NONCONST_TYPE(dim_speed)>);
static_assert(!detail::BaseDimension<base_dimension<"L">>);
static_assert(!detail::BaseDimension<struct si::metre>);
static_assert(!detail::BaseDimension<int>);
@@ -67,7 +67,7 @@ static_assert(Dimension<decltype(inverse(isq::dim_time))>);
static_assert(Dimension<decltype(pow<2>(isq::dim_length))>);
static_assert(Dimension<derived_dimension<struct isq::dim_length, per<struct isq::dim_time>>>);
static_assert(Dimension<struct dimension_one>);
static_assert(Dimension<std::remove_const_t<decltype(dim_speed)>>);
static_assert(Dimension<MP_UNITS_NONCONST_TYPE(dim_speed)>);
static_assert(!Dimension<base_dimension<"L">>);
static_assert(!Dimension<struct si::metre>);
static_assert(!Dimension<int>);
@@ -85,7 +85,7 @@ static_assert(QuantitySpec<kind_of_<struct isq::length>>);
static_assert(QuantitySpec<decltype(isq::length / isq::time)>);
static_assert(QuantitySpec<decltype(pow<2>(isq::length))>);
static_assert(QuantitySpec<struct dimensionless>);
static_assert(QuantitySpec<std::remove_const_t<decltype(speed)>>);
static_assert(QuantitySpec<MP_UNITS_NONCONST_TYPE(speed)>);
static_assert(!QuantitySpec<struct isq::dim_length>);
static_assert(!QuantitySpec<int>);
@@ -97,7 +97,7 @@ static_assert(!detail::NamedQuantitySpec<kind_of_<struct isq::length>>);
static_assert(!detail::NamedQuantitySpec<decltype(isq::length / isq::time)>);
static_assert(!detail::NamedQuantitySpec<decltype(pow<2>(isq::length))>);
static_assert(detail::NamedQuantitySpec<struct dimensionless>);
static_assert(!detail::NamedQuantitySpec<std::remove_const_t<decltype(speed)>>);
static_assert(!detail::NamedQuantitySpec<MP_UNITS_NONCONST_TYPE(speed)>);
static_assert(!detail::NamedQuantitySpec<struct isq::dim_length>);
static_assert(!detail::NamedQuantitySpec<int>);
@@ -109,7 +109,7 @@ static_assert(!detail::DerivedQuantitySpec<struct isq::speed>);
static_assert(detail::DerivedQuantitySpec<decltype(isq::length / isq::time)>);
static_assert(detail::DerivedQuantitySpec<decltype(pow<2>(isq::length))>);
static_assert(!detail::DerivedQuantitySpec<struct dimensionless>);
static_assert(detail::DerivedQuantitySpec<std::remove_const_t<decltype(speed)>>);
static_assert(detail::DerivedQuantitySpec<MP_UNITS_NONCONST_TYPE(speed)>);
static_assert(!detail::DerivedQuantitySpec<struct isq::dim_length>);
static_assert(!detail::DerivedQuantitySpec<int>);
@@ -121,7 +121,7 @@ static_assert(!detail::QuantityKindSpec<struct isq::speed>);
static_assert(!detail::QuantityKindSpec<decltype(isq::length / isq::time)>);
static_assert(!detail::QuantityKindSpec<decltype(pow<2>(isq::length))>);
static_assert(!detail::QuantityKindSpec<struct dimensionless>);
static_assert(!detail::QuantityKindSpec<std::remove_const_t<decltype(speed)>>);
static_assert(!detail::QuantityKindSpec<MP_UNITS_NONCONST_TYPE(speed)>);
static_assert(!detail::QuantityKindSpec<struct isq::dim_length>);
static_assert(!detail::QuantityKindSpec<int>);
@@ -130,7 +130,7 @@ static_assert(!detail::QuantityKindSpec<int>);
// Unit
static_assert(Unit<struct si::metre>);
static_assert(Unit<std::remove_const_t<decltype(si::kilogram)>>);
static_assert(Unit<MP_UNITS_NONCONST_TYPE(si::kilogram)>);
static_assert(Unit<si::kilo_<struct si::gram>>);
static_assert(Unit<struct natural::electronvolt>);
static_assert(Unit<decltype(si::metre / si::second)>);
@@ -156,7 +156,7 @@ static_assert(!Unit<std::chrono::seconds>);
// PrefixableUnit
static_assert(PrefixableUnit<struct si::metre>);
static_assert(PrefixableUnit<struct natural::electronvolt>);
static_assert(!PrefixableUnit<std::remove_const_t<decltype(si::kilogram)>>);
static_assert(!PrefixableUnit<MP_UNITS_NONCONST_TYPE(si::kilogram)>);
static_assert(!PrefixableUnit<si::kilo_<struct si::gram>>);
static_assert(!PrefixableUnit<decltype(si::metre / si::second)>);
static_assert(!PrefixableUnit<decltype(inverse(si::second))>);
@@ -181,7 +181,7 @@ static_assert(!PrefixableUnit<std::chrono::seconds>);
// AssociatedUnit
static_assert(AssociatedUnit<struct si::metre>);
static_assert(!AssociatedUnit<struct natural::electronvolt>);
static_assert(AssociatedUnit<std::remove_const_t<decltype(si::kilogram)>>);
static_assert(AssociatedUnit<MP_UNITS_NONCONST_TYPE(si::kilogram)>);
static_assert(AssociatedUnit<si::kilo_<struct si::gram>>);
static_assert(AssociatedUnit<decltype(si::metre / si::second)>);
static_assert(AssociatedUnit<decltype(inverse(si::second))>);
@@ -206,7 +206,7 @@ static_assert(!AssociatedUnit<std::chrono::seconds>);
// UnitOf
static_assert(UnitOf<struct si::metre, isq::length>);
static_assert(UnitOf<struct si::metre, isq::radius>);
static_assert(UnitOf<std::remove_const_t<decltype(si::kilogram)>, isq::mass>);
static_assert(UnitOf<MP_UNITS_NONCONST_TYPE(si::kilogram), isq::mass>);
static_assert(UnitOf<struct si::hertz, isq::frequency>);
static_assert(UnitOf<struct si::hertz, inverse(isq::time)>);
static_assert(UnitOf<struct one, dimensionless>);

4
test/static/dimension_test.cpp
View File

@@ -65,9 +65,9 @@ inline constexpr auto energy = force * length;
// concepts verification
static_assert(detail::BaseDimension<length_>);
static_assert(!detail::BaseDimension<std::remove_const_t<decltype(frequency)>>);
static_assert(!detail::BaseDimension<MP_UNITS_NONCONST_TYPE(frequency)>);
static_assert(Dimension<length_>);
static_assert(Dimension<std::remove_const_t<decltype(frequency)>>);
static_assert(Dimension<MP_UNITS_NONCONST_TYPE(frequency)>);
static_assert(detail::BaseDimension<decltype(speed * time)>); // length

8
test/static/quantity_point_test.cpp
View File

@@ -888,9 +888,9 @@ static_assert(invalid_unit_conversion<quantity_point>);
/////////
static_assert(std::is_same_v<decltype(quantity_point{123 * m})::rep, int>);
static_assert(std::is_same_v<std::remove_const_t<decltype(quantity_point{123 * m}.point_origin)>,
static_assert(std::is_same_v<MP_UNITS_NONCONST_TYPE(quantity_point{123 * m}.point_origin),
zeroth_point_origin_<kind_of<isq::length>>>);
static_assert(std::is_same_v<std::remove_const_t<decltype(quantity_point{123 * m}.absolute_point_origin)>,
static_assert(std::is_same_v<MP_UNITS_NONCONST_TYPE(quantity_point{123 * m}.absolute_point_origin),
zeroth_point_origin_<kind_of<isq::length>>>);
static_assert(quantity_point{123 * m}.unit == si::metre);
static_assert(quantity_point{123 * m}.quantity_spec == kind_of<isq::length>);
@@ -914,9 +914,9 @@ static_assert(quantity_point{delta<deg_C>(20)}.quantity_spec == kind_of<isq::the
#if MP_UNITS_HOSTED
using namespace std::chrono_literals;
static_assert(std::is_same_v<decltype(quantity_point{sys_seconds{123s}})::rep, std::chrono::seconds::rep>);
static_assert(std::is_same_v<std::remove_const_t<decltype(quantity_point{sys_seconds{123s}}.point_origin)>,
static_assert(std::is_same_v<MP_UNITS_NONCONST_TYPE(quantity_point{sys_seconds{123s}}.point_origin),
chrono_point_origin_<std::chrono::system_clock>>);
static_assert(std::is_same_v<std::remove_const_t<decltype(quantity_point{sys_seconds{123s}}.absolute_point_origin)>,
static_assert(std::is_same_v<MP_UNITS_NONCONST_TYPE(quantity_point{sys_seconds{123s}}.absolute_point_origin),
chrono_point_origin_<std::chrono::system_clock>>);
static_assert(quantity_point{sys_seconds{24h}}.unit == si::second);
static_assert(quantity_point{sys_seconds{24h}}.quantity_spec == kind_of<isq::time>);

17
test/static/reference_test.cpp
View File

@@ -195,7 +195,7 @@ static_assert(is_of_type<2 * m_per_s, quantity<reference<speed_, derived_unit<me
static_assert(is_of_type<120 * length[kilometre] / (2 * time[hour]),
quantity<reference<derived_quantity_spec<length_, per<time_>>,
derived_unit<std::remove_const_t<decltype(si::kilo<metre>)>, per<hour_>>>{},
derived_unit<MP_UNITS_NONCONST_TYPE(si::kilo<metre>), per<hour_>>>{},
int>>);
static_assert(120 * length[kilometre] / (2 * time[hour]) == 60 * speed[kilometre / hour]);
static_assert(is_of_type<[] {
@@ -204,15 +204,15 @@ static_assert(is_of_type<[] {
return distance * length[kilometre] / (duration * time[hour]);
}(),
quantity<reference<derived_quantity_spec<length_, per<time_>>,
derived_unit<std::remove_const_t<decltype(si::kilo<metre>)>, per<hour_>>>{},
derived_unit<MP_UNITS_NONCONST_TYPE(si::kilo<metre>), per<hour_>>>{},
int>>);
static_assert(is_of_type<std::int64_t{120} * length[kilometre] / (2 * time[hour]),
quantity<reference<derived_quantity_spec<length_, per<time_>>,
derived_unit<std::remove_const_t<decltype(si::kilo<metre>)>, per<hour_>>>{},
derived_unit<MP_UNITS_NONCONST_TYPE(si::kilo<metre>), per<hour_>>>{},
std::int64_t>>);
static_assert(is_of_type<120.L * length[kilometre] / (2 * time[hour]),
quantity<reference<derived_quantity_spec<length_, per<time_>>,
derived_unit<std::remove_const_t<decltype(si::kilo<metre>)>, per<hour_>>>{},
derived_unit<MP_UNITS_NONCONST_TYPE(si::kilo<metre>), per<hour_>>>{},
long double>>);
static_assert(is_of_type<1. / 4 * area[square(metre)], decltype(1. * area[square(metre)] / 4)>);
@@ -229,10 +229,11 @@ static_assert(is_of_type<42 * nu::length[nu::second] / (42 * nu::time[nu::second
quantity<reference<derived_quantity_spec<length_, per<time_>>, one_>{}, int>>);
static_assert(is_of_type<42 * nu::speed[nu::second / nu::second], quantity<reference<speed_, one_>{}, int>>);
static_assert(is_of_type<42 * nu::speed[one], quantity<reference<speed_, one_>{}, int>>);
static_assert(is_of_type<42 * mass[kilogram] * (1 * nu::length[nu::second]) / (1 * nu::time[nu::second]),
quantity<reference<derived_quantity_spec<length_, mass_, per<time_>>,
std::remove_const_t<decltype(si::kilo<gram>)>>{},
int>>);
static_assert(
is_of_type<
42 * mass[kilogram] * (1 * nu::length[nu::second]) / (1 * nu::time[nu::second]),
quantity<reference<derived_quantity_spec<length_, mass_, per<time_>>, MP_UNITS_NONCONST_TYPE(si::kilo<gram>)>{},
int>>);
template<auto dim, auto unit>
concept invalid_nu_unit = !requires { dim[unit]; };

15
test/static/unit_test.cpp
View File

@@ -89,7 +89,7 @@ inline constexpr struct speed_of_light_in_vacuum_ final : named_unit<"c", mag<29
static_assert(Unit<metre_>);
static_assert(Unit<second_>);
static_assert(Unit<nu_second_>);
static_assert(Unit<std::remove_const_t<decltype(kilogram)>>);
static_assert(Unit<MP_UNITS_NONCONST_TYPE(kilogram)>);
static_assert(Unit<hertz_>);
static_assert(Unit<newton_>);
static_assert(Unit<minute_>);
@@ -101,20 +101,20 @@ static_assert(Unit<decltype(second * second)>);
static_assert(Unit<decltype(nu_second * nu_second)>);
static_assert(Unit<decltype(metre / second)>);
static_assert(Unit<decltype(nu_second / nu_second)>);
static_assert(Unit<std::remove_const_t<decltype(kilometre)>>);
static_assert(Unit<MP_UNITS_NONCONST_TYPE(kilometre)>);
static_assert(PrefixableUnit<metre_>);
static_assert(PrefixableUnit<hertz_>);
static_assert(PrefixableUnit<newton_>);
static_assert(PrefixableUnit<minute_>);
static_assert(PrefixableUnit<radian_>);
static_assert(!PrefixableUnit<std::remove_const_t<decltype(kilogram)>>);
static_assert(!PrefixableUnit<MP_UNITS_NONCONST_TYPE(kilogram)>);
static_assert(!PrefixableUnit<decltype(kilojoule)>);
static_assert(!PrefixableUnit<si::kilo_<struct gram_>>);
static_assert(!PrefixableUnit<decltype(square(metre))>);
static_assert(!PrefixableUnit<decltype(cubic(metre))>);
static_assert(!PrefixableUnit<decltype(mag<60> * second)>);
static_assert(!PrefixableUnit<std::remove_const_t<decltype(kilometre)>>);
static_assert(!PrefixableUnit<MP_UNITS_NONCONST_TYPE(kilometre)>);
// named unit
static_assert(is_of_type<metre, metre_>);
@@ -194,14 +194,14 @@ static_assert(standard_gravity != metre / square(second)); // magnitude is diff
static_assert(standard_gravity._symbol_ == symbol_text{u8"g₀", "g_0"});
// prefixed_unit
static_assert(is_of_type<kilometre, std::remove_const_t<decltype(kilo<metre>)>>);
static_assert(is_of_type<kilometre, MP_UNITS_NONCONST_TYPE(kilo<metre>)>);
static_assert(is_of_type<get_canonical_unit(kilometre).reference_unit, metre_>);
static_assert(get_canonical_unit(kilometre).mag == mag<1000>);
static_assert(convertible(kilometre, metre));
static_assert(kilometre != metre);
static_assert(kilometre._symbol_ == "km");
static_assert(is_of_type<kilojoule, std::remove_const_t<decltype(kilo<joule>)>>);
static_assert(is_of_type<kilojoule, MP_UNITS_NONCONST_TYPE(kilo<joule>)>);
static_assert(is_of_type<get_canonical_unit(kilojoule).reference_unit,
derived_unit<gram_, power<metre_, 2>, per<power<second_, 2>>>>);
static_assert(get_canonical_unit(kilojoule).mag == mag<1'000'000>);
@@ -212,8 +212,7 @@ static_assert(kilojoule._symbol_ == "kJ");
static_assert(is_of_type<kilo<metre>, kilo_<metre_>>);
static_assert(is_of_type<kilo<joule>, kilo_<joule_>>);
static_assert(
is_of_type<kilometre / metre, derived_unit<std::remove_const_t<decltype(kilo<metre>)>, per<metre_>>>); // !!!
static_assert(is_of_type<kilometre / metre, derived_unit<MP_UNITS_NONCONST_TYPE(kilo<metre>), per<metre_>>>); // !!!
// prefixes