diff --git a/example/avg_speed.cpp b/example/avg_speed.cpp index dc2d24d2..11072bb3 100644 --- a/example/avg_speed.cpp +++ b/example/avg_speed.cpp @@ -45,26 +45,26 @@ namespace { using namespace mp_units; -constexpr quantity fixed_int_si_avg_speed(quantity d, - quantity t) +constexpr quantity fixed_int_si_avg_speed(quantity<(si::metre), int> d, + quantity<(si::second), int> t) { return d / t; } -constexpr quantity fixed_double_si_avg_speed(quantity d, quantity t) +constexpr quantity fixed_double_si_avg_speed(quantity<(si::metre)> d, quantity<(si::second)> t) { return d / t; } -constexpr QuantityOf auto avg_speed(QuantityOf auto d, QuantityOf auto t) +constexpr QuantityOf<(isq::speed)> auto avg_speed(QuantityOf<(isq::length)> auto d, QuantityOf<(isq::time)> auto t) { return d / t; } -template D, QuantityOf T, QuantityOf V> +template D, QuantityOf<(isq::time)> T, QuantityOf<(isq::speed)> V> void print_result(D distance, T duration, V speed) { - const auto result_in_kmph = speed.force_in(si::kilo / non_si::hour); + const auto result_in_kmph = speed.force_in((si::kilo<(si::metre)> / non_si::hour)); std::cout << "Average speed of a car that makes " << distance << " in " << duration << " is " << result_in_kmph << ".\n"; } diff --git a/example/capacitor_time_curve.cpp b/example/capacitor_time_curve.cpp index 4cf363fe..2f2f7fdb 100644 --- a/example/capacitor_time_curve.cpp +++ b/example/capacitor_time_curve.cpp @@ -48,7 +48,7 @@ int main() constexpr auto RR = isq::resistance(4.7 * si::kilo); for (auto tt = 0 * ms; tt <= 50 * ms; ++tt) { - const QuantityOf auto Vt = V0 * exp(dimensionless(-tt / (RR * CC))); + const QuantityOf<(isq::voltage)> auto Vt = V0 * exp(dimensionless(-tt / (RR * CC))); // TODO try to make the below work instead // const QuantityOf auto Vt = V0 * exp(-tt / (RR * CC)); diff --git a/example/clcpp_response.cpp b/example/clcpp_response.cpp index 42ed6d0b..9a74de52 100644 --- a/example/clcpp_response.cpp +++ b/example/clcpp_response.cpp @@ -44,8 +44,8 @@ void simple_quantities() using namespace mp_units::si; using namespace mp_units::international; - using distance = quantity]>; - using duration = quantity; + using distance = quantity<(isq::distance[kilo])>; + using duration = quantity<(isq::duration[second])>; constexpr distance km = 1. * kilo; constexpr distance miles = 1. * mile; diff --git a/example/glide_computer_lib/include/glide_computer_lib.h b/example/glide_computer_lib/include/glide_computer_lib.h index 5e2ac4db..e8fafbf3 100644 --- a/example/glide_computer_lib/include/glide_computer_lib.h +++ b/example/glide_computer_lib/include/glide_computer_lib.h @@ -90,7 +90,7 @@ struct glider { std::array polar; }; -constexpr mp_units::QuantityOf auto glide_ratio(const glider::polar_point& polar) +constexpr mp_units::QuantityOf<(mp_units::dimensionless)> auto glide_ratio(const glider::polar_point& polar) { return polar.v / -polar.climb; } diff --git a/example/hello_units.cpp b/example/hello_units.cpp index e635bc25..95b5e6d6 100644 --- a/example/hello_units.cpp +++ b/example/hello_units.cpp @@ -45,7 +45,7 @@ import mp_units; using namespace mp_units; -constexpr QuantityOf auto avg_speed(QuantityOf auto d, QuantityOf auto t) +constexpr QuantityOf<(isq::speed)> auto avg_speed(QuantityOf<(isq::length)> auto d, QuantityOf<(isq::time)> auto t) { return d / t; } diff --git a/example/include/geographic.h b/example/include/geographic.h index ba26b3f1..4f7ca94a 100644 --- a/example/include/geographic.h +++ b/example/include/geographic.h @@ -79,10 +79,10 @@ inline constexpr struct prime_meridian final : mp_units::absolute_point_origin -using latitude = mp_units::quantity_point>; +using latitude = mp_units::quantity_point<(mp_units::si::degree), equator, ranged_representation>; template -using longitude = mp_units::quantity_point>; +using longitude = mp_units::quantity_point<(mp_units::si::degree), prime_meridian, ranged_representation>; template std::basic_ostream& operator<<(std::basic_ostream& os, const latitude& lat) @@ -176,7 +176,7 @@ template distance spherical_distance(position from, position to) { using namespace mp_units; - constexpr quantity earth_radius = 6'371 * isq::radius[si::kilo]; + constexpr quantity earth_radius = 6'371 * isq::radius[si::kilo<(si::metre)>]; using si::sin, si::cos, si::asin, si::acos; @@ -193,7 +193,7 @@ distance spherical_distance(position from, position to) // const auto central_angle = 2 * asin(sqrt(0.5 - cos(to_lat - from_lat) / 2 + cos(from_lat) * cos(to_lat) * (1 // - cos(lon2_rad - from_lon)) / 2)); - return quantity_cast(earth_radius * central_angle); + return quantity_cast<(isq::distance)>(earth_radius * central_angle); } else { // the haversine formula const quantity sin_lat = sin((to_lat - from_lat) / 2); diff --git a/example/kalman_filter/kalman.h b/example/kalman_filter/kalman.h index 6e629477..e959e3d3 100644 --- a/example/kalman_filter/kalman.h +++ b/example/kalman_filter/kalman.h @@ -116,15 +116,15 @@ template } // state update -template K> +template K> requires(implicitly_convertible(QM::quantity_spec, QP::quantity_spec)) [[nodiscard]] constexpr system_state state_update(const system_state& predicted, QM measured, K gain) { return system_state{get<0>(predicted) + gain * (measured - get<0>(predicted))}; } -template K, - mp_units::QuantityOf T> +template K, + mp_units::QuantityOf<(mp_units::isq::time)> T> requires(implicitly_convertible(QM::quantity_spec, QP1::quantity_spec)) [[nodiscard]] constexpr system_state state_update(const system_state& predicted, QM measured, std::array gain, T interval) @@ -135,7 +135,7 @@ template K, mp_units::QuantityOf T> + mp_units::QuantityOf<(mp_units::dimensionless)> K, mp_units::QuantityOf<(mp_units::isq::time)> T> requires(implicitly_convertible(QM::quantity_spec, QP1::quantity_spec)) [[nodiscard]] constexpr system_state state_update(const system_state& predicted, QM measured, std::array gain, T interval) @@ -147,13 +147,13 @@ template K> +template K> [[nodiscard]] constexpr Q covariance_update(Q uncertainty, K gain) { return (1 * mp_units::one - gain) * uncertainty; } -template K> +template K> [[nodiscard]] constexpr system_state_estimate state_estimate_update( const system_state_estimate& previous, QP measurement, K gain) { @@ -162,7 +162,7 @@ template T> +template T> [[nodiscard]] constexpr system_state state_extrapolation(const system_state& estimated, T interval) { auto to_quantity = [](const auto& qp) { return qp.quantity_ref_from(qp.point_origin); }; @@ -171,7 +171,7 @@ template T return system_state{qp1, qp2}; } -template T> +template T> [[nodiscard]] constexpr system_state state_extrapolation(const system_state& estimated, T interval) { diff --git a/example/spectroscopy_units.cpp b/example/spectroscopy_units.cpp index 3fce6a8b..d618b3b3 100644 --- a/example/spectroscopy_units.cpp +++ b/example/spectroscopy_units.cpp @@ -54,8 +54,8 @@ constexpr auto h = 1 * si::si2019::planck_constant; constexpr auto kb = 1 * si::si2019::boltzmann_constant; // prints quantities in the resulting unit -template T1, QuantityOf T2, QuantityOf T3, - QuantityOf T4, QuantityOf T5> +template T1, QuantityOf<(isq::wavenumber)> T2, QuantityOf<(isq::frequency)> T3, + QuantityOf<(isq::thermodynamic_temperature)> T4, QuantityOf<(isq::wavelength)> T5> void print_line(const std::tuple& t) { std::cout << MP_UNITS_STD_FMT::format( @@ -65,8 +65,8 @@ void print_line(const std::tuple& t) // prints quantities in semi-SI units // (eV is not an official SI unit) -template T1, QuantityOf T2, QuantityOf T3, - QuantityOf T4, QuantityOf T5> +template T1, QuantityOf<(isq::wavenumber)> T2, QuantityOf<(isq::frequency)> T3, + QuantityOf<(isq::thermodynamic_temperature)> T4, QuantityOf<(isq::wavelength)> T5> void print_line_si(const std::tuple& t) { std::cout << MP_UNITS_STD_FMT::format( diff --git a/example/storage_tank.cpp b/example/storage_tank.cpp index ad9f7580..9e2c1020 100644 --- a/example/storage_tank.cpp +++ b/example/storage_tank.cpp @@ -77,10 +77,10 @@ public: density_ = density; } - [[nodiscard]] constexpr QuantityOf auto filled_weight() const + [[nodiscard]] constexpr QuantityOf<(isq::weight)> auto filled_weight() const { const auto volume = isq::volume(base_ * height_); // TODO check if we can remove that cast - const QuantityOf auto mass = density_ * volume; + const QuantityOf<(isq::mass)> auto mass = density_ * volume; return isq::weight(mass * g); } @@ -130,9 +130,9 @@ int main() const quantity spare_capacity = tank.spare_capacity(measured_mass); const quantity filled_weight = tank.filled_weight(); - const QuantityOf auto input_flow_rate = measured_mass / fill_time; - const QuantityOf auto float_rise_rate = fill_level / fill_time; - const QuantityOf auto fill_time_left = (height / fill_level - 1 * one) * fill_time; + const QuantityOf<(isq::mass_change_rate)> auto input_flow_rate = measured_mass / fill_time; + const QuantityOf<(isq::speed)> auto float_rise_rate = fill_level / fill_time; + const QuantityOf<(isq::time)> auto fill_time_left = (height / fill_level - 1 * one) * fill_time; const quantity fill_ratio = fill_level / height; diff --git a/example/total_energy.cpp b/example/total_energy.cpp index bcd149d6..95d23f31 100644 --- a/example/total_energy.cpp +++ b/example/total_energy.cpp @@ -45,8 +45,8 @@ namespace { using namespace mp_units; -QuantityOf auto total_energy(QuantityOf auto p, QuantityOf auto m, - QuantityOf auto c) +QuantityOf<(isq::mechanical_energy)> auto total_energy(QuantityOf<(isq::momentum)> auto p, QuantityOf<(isq::mass)> auto m, + QuantityOf<(isq::speed)> auto c) { return isq::mechanical_energy(sqrt(pow<2>(p * c) + pow<2>(m * pow<2>(c)))); } diff --git a/src/systems/include/mp-units/systems/si/chrono.h b/src/systems/include/mp-units/systems/si/chrono.h index fa878269..0fad31e1 100644 --- a/src/systems/include/mp-units/systems/si/chrono.h +++ b/src/systems/include/mp-units/systems/si/chrono.h @@ -127,13 +127,13 @@ namespace detail { } // namespace detail -template Q> +template Q> [[nodiscard]] constexpr auto to_chrono_duration(const Q& q) { return std::chrono::duration{q}; } -template QP> +template QP> requires is_specialization_of, chrono_point_origin_> [[nodiscard]] constexpr auto to_chrono_time_point(const QP& qp) { diff --git a/src/systems/include/mp-units/systems/si/math.h b/src/systems/include/mp-units/systems/si/math.h index b3d9b483..202ea76d 100644 --- a/src/systems/include/mp-units/systems/si/math.h +++ b/src/systems/include/mp-units/systems/si/math.h @@ -43,7 +43,7 @@ import std; MP_UNITS_EXPORT namespace mp_units::si { -template auto R, typename Rep> +template auto R, typename Rep> requires requires(Rep v) { sin(v); } || requires(Rep v) { std::sin(v); } [[nodiscard]] inline QuantityOf auto sin(const quantity& q) noexcept { @@ -57,7 +57,7 @@ template auto R, typename Rep> return quantity{sin(q.numerical_value_in(radian)), one}; } -template auto R, typename Rep> +template auto R, typename Rep> requires requires(Rep v) { cos(v); } || requires(Rep v) { std::cos(v); } [[nodiscard]] inline QuantityOf auto cos(const quantity& q) noexcept { @@ -71,7 +71,7 @@ template auto R, typename Rep> return quantity{cos(q.numerical_value_in(radian)), one}; } -template auto R, typename Rep> +template auto R, typename Rep> requires requires(Rep v) { tan(v); } || requires(Rep v) { std::tan(v); } [[nodiscard]] inline QuantityOf auto tan(const quantity& q) noexcept { @@ -87,7 +87,7 @@ template auto R, typename Rep> template auto R, typename Rep> requires requires(Rep v) { asin(v); } || requires(Rep v) { std::asin(v); } -[[nodiscard]] inline QuantityOf auto asin(const quantity& q) noexcept +[[nodiscard]] inline QuantityOf<(isq::angular_measure)> auto asin(const quantity& q) noexcept { using std::asin; if constexpr (!treat_as_floating_point) { @@ -101,7 +101,7 @@ template auto R, typename Rep> template auto R, typename Rep> requires requires(Rep v) { acos(v); } || requires(Rep v) { std::acos(v); } -[[nodiscard]] inline QuantityOf auto acos(const quantity& q) noexcept +[[nodiscard]] inline QuantityOf<(isq::angular_measure)> auto acos(const quantity& q) noexcept { using std::acos; if constexpr (!treat_as_floating_point) { @@ -115,7 +115,7 @@ template auto R, typename Rep> template auto R, typename Rep> requires requires(Rep v) { atan(v); } || requires(Rep v) { std::atan(v); } -[[nodiscard]] inline QuantityOf auto atan(const quantity& q) noexcept +[[nodiscard]] inline QuantityOf<(isq::angular_measure)> auto atan(const quantity& q) noexcept { using std::atan; if constexpr (!treat_as_floating_point) { @@ -132,7 +132,7 @@ template common_reference(R1, R2); requires requires { atan2(v1, v2); } || requires { std::atan2(v1, v2); }; } -[[nodiscard]] inline QuantityOf auto atan2(const quantity& y, +[[nodiscard]] inline QuantityOf<(isq::angular_measure)> auto atan2(const quantity& y, const quantity& x) noexcept { constexpr auto ref = common_reference(R1, R2); diff --git a/test/static/chrono_test.cpp b/test/static/chrono_test.cpp index 9f3b1901..a3a0d489 100644 --- a/test/static/chrono_test.cpp +++ b/test/static/chrono_test.cpp @@ -57,41 +57,41 @@ static_assert(!QuantityPoint); // construction - same rep type static_assert( - std::constructible_from, std::chrono::seconds>); -static_assert(std::convertible_to>); -static_assert(std::constructible_from, std::chrono::hours>); -static_assert(std::convertible_to>); -static_assert(std::constructible_from, std::chrono::hours>); -static_assert(std::convertible_to>); -static_assert(!std::constructible_from, std::chrono::seconds>); -static_assert(!std::convertible_to>); + std::constructible_from, std::chrono::seconds>); +static_assert(std::convertible_to>); +static_assert(std::constructible_from, std::chrono::hours>); +static_assert(std::convertible_to>); +static_assert(std::constructible_from, std::chrono::hours>); +static_assert(std::convertible_to>); +static_assert(!std::constructible_from, std::chrono::seconds>); +static_assert(!std::convertible_to>); static_assert( - std::constructible_from, sys_seconds>); + std::constructible_from, sys_seconds>); static_assert( - !std::constructible_from, sys_seconds>); -static_assert(std::convertible_to>); -static_assert(std::constructible_from, sys_days>); -static_assert(!std::constructible_from, sys_days>); -static_assert(std::convertible_to>); -static_assert(std::constructible_from, sys_days>); -static_assert(!std::constructible_from, sys_days>); -static_assert(std::convertible_to>); -static_assert(!std::constructible_from, sys_seconds>); -static_assert(!std::convertible_to>); + !std::constructible_from, sys_seconds>); +static_assert(std::convertible_to>); +static_assert(std::constructible_from, sys_days>); +static_assert(!std::constructible_from, sys_days>); +static_assert(std::convertible_to>); +static_assert(std::constructible_from, sys_days>); +static_assert(!std::constructible_from, sys_days>); +static_assert(std::convertible_to>); +static_assert(!std::constructible_from, sys_seconds>); +static_assert(!std::convertible_to>); // construction - different rep type (integral to a floating-point) -static_assert(std::constructible_from, std::chrono::seconds>); -static_assert(std::convertible_to>); -static_assert(std::constructible_from, std::chrono::hours>); -static_assert(std::convertible_to>); -static_assert(std::constructible_from, std::chrono::seconds>); -static_assert(std::convertible_to>); -static_assert(std::constructible_from, sys_seconds>); -static_assert(std::convertible_to>); -static_assert(std::constructible_from, sys_days>); -static_assert(std::convertible_to>); -static_assert(std::constructible_from, sys_seconds>); -static_assert(std::convertible_to>); +static_assert(std::constructible_from, std::chrono::seconds>); +static_assert(std::convertible_to>); +static_assert(std::constructible_from, std::chrono::hours>); +static_assert(std::convertible_to>); +static_assert(std::constructible_from, std::chrono::seconds>); +static_assert(std::convertible_to>); +static_assert(std::constructible_from, sys_seconds>); +static_assert(std::convertible_to>); +static_assert(std::constructible_from, sys_days>); +static_assert(std::convertible_to>); +static_assert(std::constructible_from, sys_seconds>); +static_assert(std::convertible_to>); static_assert(quantity{1s} == 1 * s); static_assert(quantity{1s} == 1 * s); diff --git a/test/static/concepts_test.cpp b/test/static/concepts_test.cpp index 06b20699..a419d8d4 100644 --- a/test/static/concepts_test.cpp +++ b/test/static/concepts_test.cpp @@ -83,7 +83,7 @@ inline constexpr auto speed = isq::length / isq::time; static_assert(QuantitySpec); static_assert(QuantitySpec); static_assert(QuantitySpec); -static_assert(QuantitySpec)>); +static_assert(QuantitySpec)>); static_assert(QuantitySpec); static_assert(QuantitySpec(isq::length))>); static_assert(QuantitySpec); @@ -95,7 +95,7 @@ static_assert(!QuantitySpec); static_assert(detail::NamedQuantitySpec); static_assert(detail::NamedQuantitySpec); static_assert(detail::NamedQuantitySpec); -static_assert(!detail::NamedQuantitySpec)>>); +static_assert(!detail::NamedQuantitySpec)>>); static_assert(!detail::NamedQuantitySpec); static_assert(!detail::NamedQuantitySpec(isq::length))>); static_assert(detail::NamedQuantitySpec); @@ -106,7 +106,7 @@ static_assert(!detail::NamedQuantitySpec); // DerivedQuantitySpec static_assert(!detail::DerivedQuantitySpec); static_assert(!detail::DerivedQuantitySpec); -static_assert(!detail::DerivedQuantitySpec)>); +static_assert(!detail::DerivedQuantitySpec)>); static_assert(!detail::DerivedQuantitySpec); static_assert(detail::DerivedQuantitySpec); static_assert(detail::DerivedQuantitySpec(isq::length))>); @@ -118,7 +118,7 @@ static_assert(!detail::DerivedQuantitySpec); // QuantityKindSpec static_assert(!detail::QuantityKindSpec); static_assert(!detail::QuantityKindSpec); -static_assert(detail::QuantityKindSpec)>>); +static_assert(detail::QuantityKindSpec)>>); static_assert(!detail::QuantityKindSpec); static_assert(!detail::QuantityKindSpec); static_assert(!detail::QuantityKindSpec(isq::length))>); @@ -133,7 +133,7 @@ static_assert(!detail::QuantityKindSpec); // Unit static_assert(Unit); static_assert(Unit); -static_assert(Unit)>); +static_assert(Unit)>); static_assert(Unit); static_assert(Unit); static_assert(Unit); @@ -144,22 +144,47 @@ static_assert(Unit); static_assert(Unit, struct si::second>>); static_assert(Unit>>); static_assert(Unit); -static_assert(!Unit>>); +static_assert(!Unit>>); static_assert(!Unit>); static_assert(!Unit>); -static_assert(!Unit>>); -static_assert(!Unit, si::second>>); +static_assert(!Unit>>); +static_assert(!Unit, (si::second)>>); static_assert(!Unit); static_assert(!Unit); #if MP_UNITS_HOSTED static_assert(!Unit); #endif +// NamedUnit +static_assert(detail::NamedUnit); +static_assert(detail::NamedUnit); +static_assert(!detail::NamedUnit); +static_assert(!detail::NamedUnit))>); +static_assert(!detail::NamedUnit); +static_assert(!detail::NamedUnit); +static_assert(!detail::NamedUnit * si::second)>); +static_assert(!detail::NamedUnit); +static_assert(!detail::NamedUnit(si::metre))>); +static_assert(detail::NamedUnit); +static_assert(!detail::NamedUnit, struct si::second>>); +static_assert(!detail::NamedUnit>>); +static_assert(!detail::NamedUnit); +static_assert(!detail::NamedUnit>>); +static_assert(!detail::NamedUnit>); +static_assert(!detail::NamedUnit>); +static_assert(!detail::NamedUnit>>); +static_assert(!detail::NamedUnit, (si::second)>>); +static_assert(!detail::NamedUnit); +static_assert(!detail::NamedUnit); +#if MP_UNITS_HOSTED +static_assert(!detail::NamedUnit); +#endif + // PrefixableUnit static_assert(PrefixableUnit); static_assert(PrefixableUnit); static_assert(!PrefixableUnit); -static_assert(!PrefixableUnit)>); +static_assert(!PrefixableUnit)>); static_assert(!PrefixableUnit); static_assert(!PrefixableUnit); static_assert(!PrefixableUnit * si::second)>); @@ -169,11 +194,11 @@ static_assert(PrefixableUnit); static_assert(!PrefixableUnit, struct si::second>>); static_assert(!PrefixableUnit>>); static_assert(!PrefixableUnit); -static_assert(!PrefixableUnit>>); +static_assert(!PrefixableUnit>>); static_assert(!PrefixableUnit>); static_assert(!PrefixableUnit>); -static_assert(!PrefixableUnit>>); -static_assert(!PrefixableUnit, si::second>>); +static_assert(!PrefixableUnit>>); +static_assert(!PrefixableUnit, (si::second)>>); static_assert(!PrefixableUnit); static_assert(!PrefixableUnit); #if MP_UNITS_HOSTED @@ -184,7 +209,7 @@ static_assert(!PrefixableUnit); static_assert(AssociatedUnit); static_assert(!AssociatedUnit); static_assert(AssociatedUnit); -static_assert(AssociatedUnit)>); +static_assert(AssociatedUnit)>); static_assert(AssociatedUnit); static_assert(AssociatedUnit); static_assert(AssociatedUnit * si::second)>); @@ -194,11 +219,11 @@ static_assert(AssociatedUnit); static_assert(AssociatedUnit, struct si::second>>); static_assert(AssociatedUnit>>); static_assert(AssociatedUnit); -static_assert(!AssociatedUnit>>); +static_assert(!AssociatedUnit>>); static_assert(!AssociatedUnit>); static_assert(!AssociatedUnit>); -static_assert(!AssociatedUnit>>); -static_assert(!AssociatedUnit, si::second>>); +static_assert(!AssociatedUnit>>); +static_assert(!AssociatedUnit, (si::second)>>); static_assert(!AssociatedUnit); static_assert(!AssociatedUnit); #if MP_UNITS_HOSTED @@ -206,19 +231,19 @@ static_assert(!AssociatedUnit); #endif // UnitOf -static_assert(UnitOf); -static_assert(UnitOf); -static_assert(UnitOf); -static_assert(UnitOf); +static_assert(UnitOf); +static_assert(UnitOf); +static_assert(UnitOf); +static_assert(UnitOf); static_assert(UnitOf); static_assert(UnitOf); static_assert(UnitOf); -static_assert(UnitOf); -static_assert(UnitOf); -static_assert(UnitOf); +static_assert(UnitOf); +static_assert(UnitOf); +static_assert(UnitOf); static_assert(!UnitOf); -static_assert(!UnitOf); -static_assert(!UnitOf); +static_assert(!UnitOf); +static_assert(!UnitOf); // Reference static_assert(Reference); @@ -228,32 +253,32 @@ static_assert(Reference); static_assert(Reference); static_assert(!Reference); static_assert(!Reference); -static_assert(!Reference)>); +static_assert(!Reference)>); static_assert(!Reference); static_assert(!Reference); // ReferenceOf -static_assert(ReferenceOf); -static_assert(ReferenceOf); -static_assert(!ReferenceOf); -static_assert(ReferenceOf); -static_assert(!ReferenceOf); -static_assert(ReferenceOf); -static_assert(ReferenceOf); -static_assert(!ReferenceOf); +static_assert(ReferenceOf); +static_assert(ReferenceOf); +static_assert(!ReferenceOf); +static_assert(ReferenceOf); +static_assert(!ReferenceOf); +static_assert(ReferenceOf); +static_assert(ReferenceOf); +static_assert(!ReferenceOf); static_assert(ReferenceOf); static_assert(ReferenceOf); -static_assert(ReferenceOf); +static_assert(ReferenceOf); static_assert(ReferenceOf); -static_assert(ReferenceOf); +static_assert(ReferenceOf); static_assert(!ReferenceOf); -static_assert(ReferenceOf); +static_assert(ReferenceOf); static_assert(!ReferenceOf); -static_assert(ReferenceOf); -static_assert(ReferenceOf); -static_assert(!ReferenceOf); -static_assert(!ReferenceOf); +static_assert(ReferenceOf); +static_assert(ReferenceOf); +static_assert(!ReferenceOf); +static_assert(!ReferenceOf); // Representation static_assert(Representation); @@ -278,57 +303,57 @@ static_assert(!RepresentationOf); #endif // Quantity -static_assert(Quantity>); -static_assert(Quantity>); -static_assert(Quantity>); -static_assert(Quantity>); +static_assert(Quantity>); +static_assert(Quantity>); +static_assert(Quantity>); +static_assert(Quantity>); #if MP_UNITS_HOSTED static_assert(!Quantity); #endif -static_assert(!Quantity>); +static_assert(!Quantity>); static_assert(!Quantity); // QuantityOf -static_assert(QuantityOf, isq::length>); -static_assert(QuantityOf, isq::radius>); -static_assert(!QuantityOf, isq::length>); -static_assert(QuantityOf, isq::length>); -static_assert(!QuantityOf, isq::radius>); -static_assert(QuantityOf, isq::length>); -static_assert(QuantityOf, isq::radius>); -static_assert(!QuantityOf, isq::dim_length>); +static_assert(QuantityOf, (isq::length)>); +static_assert(QuantityOf, (isq::radius)>); +static_assert(!QuantityOf, (isq::length)>); +static_assert(QuantityOf, (isq::length)>); +static_assert(!QuantityOf, (isq::radius)>); +static_assert(QuantityOf, (isq::length)>); +static_assert(QuantityOf, (isq::radius)>); +static_assert(!QuantityOf, (isq::dim_length)>); static_assert(QuantityOf, dimensionless>); static_assert(QuantityOf, dimensionless>); -static_assert(QuantityOf, isq::rotation>); -static_assert(QuantityOf, dimensionless>); -static_assert(QuantityOf, isq::angular_measure>); -static_assert(!QuantityOf, dimensionless>); -static_assert(QuantityOf, isq::angular_measure>); -static_assert(!QuantityOf, dimensionless>); -static_assert(QuantityOf, isq::rotation>); -static_assert(QuantityOf, isq::angular_measure>); -static_assert(!QuantityOf, isq::rotation>); -static_assert(!QuantityOf, isq::angular_measure>); +static_assert(QuantityOf, (isq::rotation)>); +static_assert(QuantityOf, dimensionless>); +static_assert(QuantityOf, (isq::angular_measure)>); +static_assert(!QuantityOf, dimensionless>); +static_assert(QuantityOf, (isq::angular_measure)>); +static_assert(!QuantityOf, dimensionless>); +static_assert(QuantityOf, (isq::rotation)>); +static_assert(QuantityOf, (isq::angular_measure)>); +static_assert(!QuantityOf, (isq::rotation)>); +static_assert(!QuantityOf, (isq::angular_measure)>); // QuantityLike #if MP_UNITS_HOSTED static_assert(QuantityLike); static_assert(QuantityLike); #endif -static_assert(!QuantityLike>); -static_assert(!QuantityLike>); +static_assert(!QuantityLike>); +static_assert(!QuantityLike>); static_assert(!QuantityLike); // QuantityPoint -static_assert(QuantityPoint>); -static_assert(QuantityPoint>); -static_assert(QuantityPoint>); -static_assert(QuantityPoint>); -static_assert(QuantityPoint>); -static_assert(QuantityPoint>); +static_assert(QuantityPoint>); +static_assert(QuantityPoint>); +static_assert(QuantityPoint>); +static_assert(QuantityPoint>); +static_assert(QuantityPoint>); +static_assert(QuantityPoint>); static_assert(!QuantityPoint); -static_assert(!QuantityPoint>); +static_assert(!QuantityPoint>); static_assert(!QuantityPoint); static_assert(!QuantityPoint); #if MP_UNITS_HOSTED @@ -338,35 +363,35 @@ static_assert(!QuantityPoint> static_assert(!QuantityPoint); // QuantityPointOf -static_assert(QuantityPointOf, isq::length>); -static_assert(QuantityPointOf, isq::radius>); -static_assert(QuantityPointOf, isq::length>); -static_assert(!QuantityPointOf, isq::radius>); -static_assert(QuantityPointOf, isq::length>); -static_assert(QuantityPointOf, isq::radius>); -static_assert(QuantityPointOf, isq::length>); -static_assert(QuantityPointOf, isq::radius>); -static_assert(QuantityPointOf, my_origin>); -static_assert(QuantityPointOf, my_relative_origin>); -static_assert(QuantityPointOf, my_relative_origin>); -static_assert(QuantityPointOf, my_origin>); -static_assert(QuantityPointOf, my_origin>); -static_assert(QuantityPointOf, my_relative_origin>); -static_assert(QuantityPointOf, my_relative_origin>); -static_assert(QuantityPointOf, my_origin>); -static_assert(QuantityPointOf, my_origin>); -static_assert(QuantityPointOf, my_relative_origin>); -static_assert(QuantityPointOf, my_relative_origin>); -static_assert(QuantityPointOf, my_origin>); +static_assert(QuantityPointOf, (isq::length)>); +static_assert(QuantityPointOf, (isq::radius)>); +static_assert(QuantityPointOf, (isq::length)>); +static_assert(!QuantityPointOf, (isq::radius)>); +static_assert(QuantityPointOf, (isq::length)>); +static_assert(QuantityPointOf, (isq::radius)>); +static_assert(QuantityPointOf, (isq::length)>); +static_assert(QuantityPointOf, (isq::radius)>); +static_assert(QuantityPointOf, my_origin>); +static_assert(QuantityPointOf, my_relative_origin>); +static_assert(QuantityPointOf, my_relative_origin>); +static_assert(QuantityPointOf, my_origin>); +static_assert(QuantityPointOf, my_origin>); +static_assert(QuantityPointOf, my_relative_origin>); +static_assert(QuantityPointOf, my_relative_origin>); +static_assert(QuantityPointOf, my_origin>); +static_assert(QuantityPointOf, my_origin>); +static_assert(QuantityPointOf, my_relative_origin>); +static_assert(QuantityPointOf, my_relative_origin>); +static_assert(QuantityPointOf, my_origin>); // PointOrigin static_assert(PointOrigin); static_assert(PointOrigin); -static_assert(!PointOrigin>); +static_assert(!PointOrigin>); static_assert(!PointOrigin>); -static_assert(!PointOrigin>); -static_assert(!PointOrigin>); -static_assert(!PointOrigin>); +static_assert(!PointOrigin>); +static_assert(!PointOrigin>); +static_assert(!PointOrigin>); static_assert(!PointOrigin); #if MP_UNITS_HOSTED static_assert(!PointOrigin); @@ -375,38 +400,38 @@ static_assert(!PointOrigin>); static_assert(!PointOrigin); // PointOriginFor -static_assert(PointOriginFor); -static_assert(PointOriginFor); -static_assert(!PointOriginFor); -static_assert(PointOriginFor); -static_assert(PointOriginFor); -static_assert(!PointOriginFor); -static_assert(!PointOriginFor, isq::length>); -static_assert(!PointOriginFor, isq::radius>); -static_assert(!PointOriginFor, isq::time>); -static_assert(!PointOriginFor, isq::length>); -static_assert(!PointOriginFor, isq::radius>); -static_assert(!PointOriginFor, isq::time>); -static_assert(!PointOriginFor, isq::length>); -static_assert(!PointOriginFor, isq::radius>); -static_assert(!PointOriginFor, isq::time>); -static_assert(!PointOriginFor, isq::length>); -static_assert(!PointOriginFor, isq::radius>); -static_assert(!PointOriginFor, isq::time>); -static_assert(!PointOriginFor); +static_assert(PointOriginFor); +static_assert(PointOriginFor); +static_assert(!PointOriginFor); +static_assert(PointOriginFor); +static_assert(PointOriginFor); +static_assert(!PointOriginFor); +static_assert(!PointOriginFor, (isq::length)>); +static_assert(!PointOriginFor, (isq::radius)>); +static_assert(!PointOriginFor, (isq::time)>); +static_assert(!PointOriginFor, (isq::length)>); +static_assert(!PointOriginFor, (isq::radius)>); +static_assert(!PointOriginFor, (isq::time)>); +static_assert(!PointOriginFor, (isq::length)>); +static_assert(!PointOriginFor, (isq::radius)>); +static_assert(!PointOriginFor, (isq::time)>); +static_assert(!PointOriginFor, (isq::length)>); +static_assert(!PointOriginFor, (isq::radius)>); +static_assert(!PointOriginFor, (isq::time)>); +static_assert(!PointOriginFor); #if MP_UNITS_HOSTED -static_assert(!PointOriginFor); -static_assert(!PointOriginFor, isq::length>); +static_assert(!PointOriginFor); +static_assert(!PointOriginFor, (isq::length)>); #endif -static_assert(!PointOriginFor); +static_assert(!PointOriginFor); // QuantityPointLike #if MP_UNITS_HOSTED static_assert(QuantityPointLike>); static_assert(!QuantityPointLike); #endif -static_assert(!QuantityPointLike>); -static_assert(!QuantityPointLike>); +static_assert(!QuantityPointLike>); +static_assert(!QuantityPointLike>); static_assert(!QuantityPointLike); } // namespace diff --git a/test/static/custom_rep_test_min_impl.cpp b/test/static/custom_rep_test_min_impl.cpp index 8e8c3b7c..ccff6080 100644 --- a/test/static/custom_rep_test_min_impl.cpp +++ b/test/static/custom_rep_test_min_impl.cpp @@ -78,18 +78,18 @@ static_assert(Representation>); static_assert(Representation>); // construction from a value is not allowed -static_assert(!std::constructible_from>, min_impl>); -static_assert(!std::convertible_to, quantity>>); +static_assert(!std::constructible_from>, min_impl>); +static_assert(!std::convertible_to, quantity<(si::metre), min_impl>>); -static_assert(!std::constructible_from>, min_impl>); -static_assert(!std::convertible_to, quantity>>); +static_assert(!std::constructible_from>, min_impl>); +static_assert(!std::convertible_to, quantity<(si::metre), min_impl>>); // multiply syntax should work template concept creates_quantity = Unit && requires { T{} * U; }; -static_assert(creates_quantity, si::metre>); -static_assert(creates_quantity, si::metre>); +static_assert(creates_quantity, (si::metre)>); +static_assert(creates_quantity, (si::metre)>); // multiply syntax static_assert(creates_quantity, one>); @@ -99,46 +99,46 @@ static_assert(creates_quantity, percent>); // construction from a quantity // min_impl -> min_impl -static_assert(std::constructible_from>, quantity>>); -static_assert(std::convertible_to>, quantity>>); +static_assert(std::constructible_from>, quantity<(si::metre), min_impl>>); +static_assert(std::convertible_to>, quantity<(si::metre), min_impl>>); -static_assert(std::constructible_from>, quantity>>); -static_assert(std::convertible_to>, quantity>>); +static_assert(std::constructible_from>, quantity<(si::metre), min_impl>>); +static_assert(std::convertible_to>, quantity<(si::metre), min_impl>>); -static_assert(std::constructible_from>, quantity>>); -static_assert(std::convertible_to>, quantity>>); +static_assert(std::constructible_from>, quantity<(si::metre), min_impl>>); +static_assert(std::convertible_to>, quantity<(si::metre), min_impl>>); -static_assert(!std::constructible_from>, - quantity>>); // narrowing conversion -static_assert(!std::convertible_to>, quantity>>); +static_assert(!std::constructible_from>, + quantity<(si::metre), min_impl>>); // narrowing conversion +static_assert(!std::convertible_to>, quantity<(si::metre), min_impl>>); // T -> min_impl -static_assert(std::constructible_from>, quantity>); -static_assert(std::convertible_to, quantity>>); +static_assert(std::constructible_from>, quantity<(si::metre), int>>); +static_assert(std::convertible_to, quantity<(si::metre), min_impl>>); -static_assert(std::constructible_from>, quantity>); -static_assert(std::convertible_to, quantity>>); +static_assert(std::constructible_from>, quantity<(si::metre), double>>); +static_assert(std::convertible_to, quantity<(si::metre), min_impl>>); -static_assert(std::constructible_from>, quantity>); -static_assert(std::convertible_to, quantity>>); +static_assert(std::constructible_from>, quantity<(si::metre), int>>); +static_assert(std::convertible_to, quantity<(si::metre), min_impl>>); static_assert( - !std::constructible_from>, quantity>); // narrowing conversion -static_assert(!std::convertible_to, quantity>>); + !std::constructible_from>, quantity<(si::metre), double>>); // narrowing conversion +static_assert(!std::convertible_to, quantity<(si::metre), min_impl>>); // min_impl -> T -static_assert(std::constructible_from, quantity>>); -static_assert(std::convertible_to>, quantity>); +static_assert(std::constructible_from, quantity<(si::metre), min_impl>>); +static_assert(std::convertible_to>, quantity<(si::metre), int>>); -static_assert(std::constructible_from, quantity>>); -static_assert(std::convertible_to>, quantity>); +static_assert(std::constructible_from, quantity<(si::metre), min_impl>>); +static_assert(std::convertible_to>, quantity<(si::metre), double>>); -static_assert(std::constructible_from, quantity>>); -static_assert(std::convertible_to>, quantity>); +static_assert(std::constructible_from, quantity<(si::metre), min_impl>>); +static_assert(std::convertible_to>, quantity<(si::metre), double>>); static_assert( - !std::constructible_from, quantity>>); // narrowing conversion -static_assert(!std::convertible_to>, quantity>); + !std::constructible_from, quantity<(si::metre), min_impl>>); // narrowing conversion +static_assert(!std::convertible_to>, quantity<(si::metre), int>>); // arithmetic operators diff --git a/test/static/quantity_point_test.cpp b/test/static/quantity_point_test.cpp index 06ad1f16..64254d3e 100644 --- a/test/static/quantity_point_test.cpp +++ b/test/static/quantity_point_test.cpp @@ -58,24 +58,24 @@ inline constexpr struct mean_sea_level final : absolute_point_origin { +inline constexpr struct same_mean_sea_level final : relative_point_origin { } same_mean_sea_level; -inline constexpr struct ground_level final : relative_point_origin { +inline constexpr struct ground_level final : relative_point_origin { } ground_level; inline constexpr auto my_ground_level = ground_level; -inline constexpr struct same_ground_level1 final : relative_point_origin { +inline constexpr struct same_ground_level1 final : relative_point_origin { } same_ground_level1; -inline constexpr struct same_ground_level2 final : relative_point_origin { +inline constexpr struct same_ground_level2 final : relative_point_origin { } same_ground_level2; -inline constexpr struct tower_peak final : relative_point_origin { +inline constexpr struct tower_peak final : relative_point_origin { } tower_peak; -inline constexpr struct other_ground_level final : relative_point_origin { +inline constexpr struct other_ground_level final : relative_point_origin { } other_ground_level; inline constexpr struct other_absolute_level final : absolute_point_origin { @@ -152,10 +152,10 @@ static_assert(zeroth_point_origin != zeroth_point_origin) == sizeof(double)); -static_assert(sizeof(quantity_point) == sizeof(double)); -static_assert(sizeof(quantity_point) == sizeof(short)); -static_assert(sizeof(quantity_point) == sizeof(short)); +static_assert(sizeof(quantity_point<(si::metre), mean_sea_level>) == sizeof(double)); +static_assert(sizeof(quantity_point<(isq::height[m]), mean_sea_level>) == sizeof(double)); +static_assert(sizeof(quantity_point<(si::metre), ground_level, short>) == sizeof(short)); +static_assert(sizeof(quantity_point<(isq::height[m]), ground_level, short>) == sizeof(short)); template typename QP> concept invalid_types = requires { @@ -188,15 +188,15 @@ static_assert(invalid_types); template typename QP> concept valid_types = requires { - typename QP; - typename QP; - typename QP; - typename QP; - typename QP; - typename QP; - typename QP, int>; - typename QP>, int>; - typename QP, int>; + typename QP<(si::metre), mean_sea_level, int>; + typename QP<(isq::height[m]), mean_sea_level, int>; + typename QP<(special_height[m]), mean_sea_level, int>; + typename QP<(si::metre), ground_level, int>; + typename QP<(isq::height[m]), ground_level, int>; + typename QP<(special_height[m]), ground_level, int>; + typename QP<(isq::height[m]), zeroth_point_origin<(isq::length)>, int>; + typename QP<(isq::height[m]), zeroth_point_origin>, int>; + typename QP<(si::metre), zeroth_point_origin<(isq::height)>, int>; }; static_assert(valid_types); @@ -217,14 +217,14 @@ static_assert(std::is_nothrow_destructible_v>); static_assert(std::is_standard_layout_v>); -static_assert(std::default_initializable>); -static_assert(std::move_constructible>); -static_assert(std::copy_constructible>); -static_assert(std::equality_comparable>); -static_assert(std::totally_ordered>); -static_assert(std::regular>); +static_assert(std::default_initializable>); +static_assert(std::move_constructible>); +static_assert(std::copy_constructible>); +static_assert(std::equality_comparable>); +static_assert(std::totally_ordered>); +static_assert(std::regular>); -static_assert(std::three_way_comparable>); +static_assert(std::three_way_comparable>); ////////////////// @@ -235,51 +235,51 @@ static_assert(quantity_point::reference == si::metre); static_assert(quantity_point::quantity_spec == kind_of); static_assert(quantity_point::dimension == isq::dim_length); static_assert(quantity_point::unit == si::metre); -static_assert(is_of_type::point_origin, zeroth_point_origin_>>); -static_assert(is_of_type::absolute_point_origin, zeroth_point_origin_>>); +static_assert(is_of_type::point_origin, zeroth_point_origin_>>); +static_assert(is_of_type::absolute_point_origin, zeroth_point_origin_>>); static_assert(quantity_point::reference == isq::height[m]); static_assert(quantity_point::quantity_spec == isq::height); static_assert(quantity_point::dimension == isq::dim_length); static_assert(quantity_point::unit == si::metre); -static_assert(is_of_type::point_origin, zeroth_point_origin_>); -static_assert(is_of_type::absolute_point_origin, zeroth_point_origin_>); +static_assert(is_of_type::point_origin, zeroth_point_origin_>); +static_assert(is_of_type::absolute_point_origin, zeroth_point_origin_>); static_assert(quantity_point::reference == si::metre); static_assert(quantity_point::quantity_spec == kind_of); static_assert(quantity_point::dimension == isq::dim_length); static_assert(quantity_point::unit == si::metre); -static_assert(is_of_type::point_origin, struct mean_sea_level>); -static_assert(is_of_type::absolute_point_origin, struct mean_sea_level>); +static_assert(is_of_type::point_origin, struct mean_sea_level>); +static_assert(is_of_type::absolute_point_origin, struct mean_sea_level>); static_assert(quantity_point::reference == isq::height[m]); static_assert(quantity_point::quantity_spec == isq::height); static_assert(quantity_point::dimension == isq::dim_length); static_assert(quantity_point::unit == si::metre); -static_assert(is_of_type::point_origin, struct mean_sea_level>); -static_assert(is_of_type::absolute_point_origin, struct mean_sea_level>); +static_assert(is_of_type::point_origin, struct mean_sea_level>); +static_assert(is_of_type::absolute_point_origin, struct mean_sea_level>); static_assert(quantity_point::reference == isq::height[m]); static_assert(quantity_point::quantity_spec == isq::height); static_assert(quantity_point::dimension == isq::dim_length); static_assert(quantity_point::unit == si::metre); -static_assert(is_of_type::point_origin, struct ground_level>); -static_assert(is_of_type::absolute_point_origin, struct mean_sea_level>); +static_assert(is_of_type::point_origin, struct ground_level>); +static_assert(is_of_type::absolute_point_origin, struct mean_sea_level>); static_assert(quantity_point::reference == isq::height[m]); static_assert(quantity_point::quantity_spec == isq::height); static_assert(quantity_point::dimension == isq::dim_length); static_assert(quantity_point::unit == si::metre); -static_assert(is_of_type::point_origin, struct tower_peak>); -static_assert(is_of_type::absolute_point_origin, struct mean_sea_level>); +static_assert(is_of_type::point_origin, struct tower_peak>); +static_assert(is_of_type::absolute_point_origin, struct mean_sea_level>); static_assert(quantity_point::reference == si::kelvin); static_assert(quantity_point::quantity_spec == kind_of); static_assert(quantity_point::dimension == isq::dim_thermodynamic_temperature); static_assert(quantity_point::unit == si::kelvin); -static_assert(is_of_type::point_origin, struct si::absolute_zero>); +static_assert(is_of_type::point_origin, struct si::absolute_zero>); static_assert( - is_of_type::absolute_point_origin, struct si::absolute_zero>); + is_of_type::absolute_point_origin, struct si::absolute_zero>); static_assert(quantity_point::reference == isq::thermodynamic_temperature[si::kelvin]); @@ -288,10 +288,10 @@ static_assert(quantity_point::dimension == isq::dim_thermodynamic_temperature); static_assert(quantity_point::unit == si::kelvin); -static_assert(is_of_type::point_origin, +static_assert(is_of_type::point_origin, struct si::absolute_zero>); static_assert( - is_of_type::absolute_point_origin, + is_of_type::absolute_point_origin, struct si::absolute_zero>); static_assert(quantity_point::reference == @@ -301,9 +301,9 @@ static_assert(quantity_point::dimension == isq::dim_thermodynamic_temperature); static_assert(quantity_point::unit == si::kelvin); -static_assert(is_of_type::point_origin, +static_assert(is_of_type::point_origin, struct si::absolute_zero>); -static_assert(is_of_type::absolute_point_origin, +static_assert(is_of_type::absolute_point_origin, struct si::absolute_zero>); static_assert(quantity_point::reference == si::degree_Celsius); @@ -311,9 +311,9 @@ static_assert(quantity_point::quantity_spec = kind_of); static_assert(quantity_point::dimension == isq::dim_thermodynamic_temperature); static_assert(quantity_point::unit == si::degree_Celsius); -static_assert(is_of_type::point_origin, struct si::ice_point>); +static_assert(is_of_type::point_origin, struct si::ice_point>); static_assert( - is_of_type::absolute_point_origin, struct si::absolute_zero>); + is_of_type::absolute_point_origin, struct si::absolute_zero>); static_assert(quantity_point::reference == isq::Celsius_temperature[si::degree_Celsius]); @@ -322,10 +322,10 @@ static_assert(quantity_point::dimension == isq::dim_thermodynamic_temperature); static_assert(quantity_point::unit == si::degree_Celsius); -static_assert(is_of_type::point_origin, +static_assert(is_of_type::point_origin, struct si::ice_point>); static_assert( - is_of_type::absolute_point_origin, + is_of_type::absolute_point_origin, struct si::absolute_zero>); @@ -333,18 +333,18 @@ static_assert( // member types ////////////////// -static_assert(is_same_v::rep, double>); -static_assert(is_same_v::quantity_type, quantity>); +static_assert(is_same_v::rep, double>); +static_assert(is_same_v::quantity_type, quantity>); -static_assert(is_same_v::rep, int>); -static_assert(is_same_v::quantity_type, quantity>); +static_assert(is_same_v::rep, int>); +static_assert(is_same_v::quantity_type, quantity>); -static_assert(is_same_v::rep, double>); -static_assert(is_same_v::quantity_type, quantity>); +static_assert(is_same_v::rep, double>); +static_assert(is_same_v::quantity_type, quantity>); -static_assert(is_same_v::rep, int>); +static_assert(is_same_v::rep, int>); static_assert( - is_same_v::quantity_type, quantity>); + is_same_v::quantity_type, quantity>); //////////////////////////// @@ -371,11 +371,11 @@ static_assert( ////////////////////////////// // there is no construction from a value -static_assert(!std::constructible_from, double>); -static_assert(!std::convertible_to>); +static_assert(!std::constructible_from, double>); +static_assert(!std::convertible_to>); -static_assert(!std::constructible_from, int>); -static_assert(!std::convertible_to>); +static_assert(!std::constructible_from, int>); +static_assert(!std::convertible_to>); static_assert(!std::constructible_from, double>); static_assert(!std::convertible_to>); @@ -396,135 +396,135 @@ static_assert(!std::convertible_to, quantity>); -static_assert(!std::convertible_to, quantity_point>); +static_assert(std::constructible_from, quantity<(si::metre)>>); +static_assert(!std::convertible_to, quantity_point<(si::metre)>>); -static_assert(std::constructible_from, quantity>); -static_assert(!std::convertible_to, quantity_point>); +static_assert(std::constructible_from, quantity<(isq::height[m])>>); +static_assert(!std::convertible_to, quantity_point<(isq::height[m])>>); -static_assert(std::constructible_from, quantity>); -static_assert(!std::convertible_to, quantity_point>); +static_assert(std::constructible_from, quantity<(si::metre)>>); +static_assert(!std::convertible_to, quantity_point<(isq::height[m])>>); -static_assert(std::constructible_from, quantity>); -static_assert(!std::convertible_to, quantity_point>); +static_assert(std::constructible_from, quantity<(isq::height[m])>>); +static_assert(!std::convertible_to, quantity_point<(si::metre)>>); -static_assert(std::constructible_from, quantity>); -static_assert(!std::convertible_to, quantity_point>); +static_assert(std::constructible_from, quantity<(isq::speed[m / s])>>); +static_assert(!std::convertible_to, quantity_point>); -static_assert(std::constructible_from, quantity>); -static_assert(!std::convertible_to, quantity_point>); +static_assert(std::constructible_from, quantity>); +static_assert(!std::convertible_to, quantity_point<(isq::speed[m / s])>>); -static_assert(std::constructible_from, quantity>); -static_assert(!std::convertible_to, quantity_point>); +static_assert(std::constructible_from, quantity<(isq::speed[m / s])>>); +static_assert(!std::convertible_to, quantity_point<(isq::length[m] / isq::time[s])>>); -static_assert(std::constructible_from, quantity>); -static_assert(!std::convertible_to, quantity_point>); +static_assert(std::constructible_from, quantity<(isq::length[m] / isq::time[s])>>); +static_assert(!std::convertible_to, quantity_point<(isq::speed[m / s])>>); -static_assert(std::constructible_from, quantity>); -static_assert(!std::convertible_to, quantity_point>); +static_assert(std::constructible_from, quantity>); +static_assert(!std::convertible_to, quantity_point<(isq::speed[m / s])>>); static_assert(std::constructible_from, quantity>); static_assert(!std::convertible_to, quantity_point>); // different dimensions -static_assert(!std::constructible_from, quantity>); -static_assert(!std::convertible_to, quantity_point>); +static_assert(!std::constructible_from, quantity<(si::second)>>); +static_assert(!std::convertible_to, quantity_point<(isq::height[m])>>); // convertible but different quantity_specs -static_assert(std::constructible_from, quantity>); -static_assert(!std::convertible_to, quantity_point>); +static_assert(std::constructible_from, quantity<(isq::height[m])>>); +static_assert(!std::convertible_to, quantity_point<(isq::length[m])>>); -static_assert(std::constructible_from, quantity>); -static_assert(!std::convertible_to, quantity_point>); +static_assert(std::constructible_from, quantity<(special_height[m])>>); +static_assert(!std::convertible_to, quantity_point<(isq::height[m])>>); // quantity_specs with common_quantity_spec -static_assert(!std::constructible_from, quantity>); -static_assert(!std::convertible_to, quantity_point>); +static_assert(!std::constructible_from, quantity<(isq::height[m])>>); +static_assert(!std::convertible_to, quantity_point<(isq::width[m])>>); -static_assert(!std::constructible_from, quantity>); -static_assert(!std::convertible_to, quantity_point>); +static_assert(!std::constructible_from, quantity<(isq::width[m])>>); +static_assert(!std::convertible_to, quantity_point<(isq::height[m])>>); // non-convertible quantity_specs -static_assert(!std::constructible_from, quantity>); -static_assert(!std::convertible_to, quantity_point>); +static_assert(!std::constructible_from, quantity<(isq::length[m])>>); +static_assert(!std::convertible_to, quantity_point<(isq::height[m])>>); -static_assert(!std::constructible_from, quantity>); -static_assert(!std::convertible_to, quantity_point>); +static_assert(!std::constructible_from, quantity<(isq::height[m])>>); +static_assert(!std::convertible_to, quantity_point<(isq::height[m])>>); #if MP_UNITS_HOSTED // quantity-like -static_assert(!std::constructible_from, std::chrono::seconds>); -static_assert(!std::convertible_to>); +static_assert(!std::constructible_from, std::chrono::seconds>); +static_assert(!std::convertible_to>); -static_assert(!std::constructible_from, std::chrono::seconds>); -static_assert(!std::convertible_to>); +static_assert(!std::constructible_from, std::chrono::seconds>); +static_assert(!std::convertible_to>); -static_assert(!std::constructible_from, std::chrono::seconds>); -static_assert(!std::convertible_to>); +static_assert(!std::constructible_from, std::chrono::seconds>); +static_assert(!std::convertible_to>); #endif // ---------------------- // explicit point origins // ---------------------- -static_assert(!std::constructible_from, quantity>); -static_assert(!std::convertible_to, quantity_point>); +static_assert(!std::constructible_from, quantity<(si::metre)>>); +static_assert(!std::convertible_to, quantity_point<(si::metre), mean_sea_level>>); -static_assert(!std::constructible_from, quantity>); -static_assert(!std::convertible_to, quantity_point>); +static_assert(!std::constructible_from, quantity<(isq::height[m])>>); +static_assert(!std::convertible_to, quantity_point<(isq::height[m]), mean_sea_level>>); -static_assert(!std::constructible_from, quantity>); -static_assert(!std::convertible_to, quantity_point>); +static_assert(!std::constructible_from, quantity<(si::metre)>>); +static_assert(!std::convertible_to, quantity_point<(isq::height[m]), mean_sea_level>>); -static_assert(!std::constructible_from, quantity>); -static_assert(!std::convertible_to, quantity_point>); +static_assert(!std::constructible_from, quantity<(isq::height[m])>>); +static_assert(!std::convertible_to, quantity_point<(si::metre), mean_sea_level>>); -static_assert(!std::constructible_from, quantity>); -static_assert(!std::convertible_to, quantity_point>); +static_assert(!std::constructible_from, quantity>); +static_assert(!std::convertible_to, quantity_point<(isq::height[m]), mean_sea_level>>); static_assert(!std::constructible_from, quantity>); static_assert(!std::convertible_to, quantity_point>); // quantity_specs with common_quantity_spec -static_assert(!std::constructible_from, quantity>); -static_assert(!std::convertible_to, quantity_point>); +static_assert(!std::constructible_from, quantity<(isq::height[m])>>); +static_assert(!std::convertible_to, quantity_point<(isq::width[m]), zeroth_length>>); -static_assert(!std::constructible_from, quantity>); -static_assert(!std::convertible_to, quantity_point>); +static_assert(!std::constructible_from, quantity<(isq::width[m])>>); +static_assert(!std::convertible_to, quantity_point<(isq::height[m]), zeroth_length>>); // different dimensions -static_assert(!std::constructible_from, quantity>); -static_assert(!std::convertible_to, quantity_point>); +static_assert(!std::constructible_from, quantity<(si::second)>>); +static_assert(!std::convertible_to, quantity_point<(isq::height[m]), mean_sea_level>>); // non-convertible quantity_specs -static_assert(!std::constructible_from, quantity>); -static_assert(!std::convertible_to, quantity_point>); +static_assert(!std::constructible_from, quantity<(isq::length[m])>>); +static_assert(!std::convertible_to, quantity_point<(isq::height[m]), mean_sea_level>>); -static_assert(!std::constructible_from, quantity>); -static_assert(!std::convertible_to, quantity_point>); +static_assert(!std::constructible_from, quantity<(isq::height[m])>>); +static_assert(!std::convertible_to, quantity_point<(isq::height[m]), mean_sea_level>>); // not-compatible origin -static_assert(!std::constructible_from, quantity>); -static_assert(!std::convertible_to, quantity_point>); +static_assert(!std::constructible_from, quantity<(isq::length[m])>>); +static_assert(!std::convertible_to, quantity_point<((si::metre)), mean_sea_level>>); #if MP_UNITS_HOSTED // quantity-like -static_assert(!std::constructible_from>, +static_assert(!std::constructible_from>, std::chrono::seconds>); static_assert(!std::convertible_to>>); + quantity_point<(si::second), chrono_point_origin>>); -static_assert(!std::constructible_from>, +static_assert(!std::constructible_from>, std::chrono::seconds>); static_assert(!std::convertible_to>>); + quantity_point<(isq::time[s]), chrono_point_origin>>); static_assert( - !std::constructible_from>, + !std::constructible_from>, std::chrono::seconds>); static_assert( !std::convertible_to>>); + quantity_point<(isq::period_duration[s]), chrono_point_origin>>); #endif @@ -533,140 +533,140 @@ static_assert( /////////////////////////////////////// // implicit origin -static_assert(std::constructible_from, quantity_point>); -static_assert(std::convertible_to, quantity_point>); -static_assert(std::constructible_from, quantity_point>); -static_assert(std::convertible_to, quantity_point>); +static_assert(std::constructible_from, quantity_point<(si::metre)>>); +static_assert(std::convertible_to, quantity_point<(si::metre)>>); +static_assert(std::constructible_from, quantity_point<(isq::height[m])>>); +static_assert(std::convertible_to, quantity_point<(isq::height[m])>>); -static_assert(std::constructible_from, quantity_point>); -static_assert(std::convertible_to, quantity_point>); -static_assert(std::constructible_from, quantity_point>); -static_assert(std::convertible_to, quantity_point>); +static_assert(std::constructible_from, quantity_point<(isq::height[m])>>); +static_assert(std::convertible_to, quantity_point<(si::metre)>>); +static_assert(std::constructible_from, quantity_point<(si::metre)>>); +static_assert(std::convertible_to, quantity_point<(isq::height[m])>>); static_assert( - std::constructible_from, quantity_point>); -static_assert(std::convertible_to, quantity_point>); + std::constructible_from, quantity_point<(isq::speed[m / s])>>); +static_assert(std::convertible_to, quantity_point<(isq::length[m]) / isq::time[s]>>); -static_assert(std::constructible_from, quantity_point>); -static_assert(std::convertible_to, quantity_point>); +static_assert(std::constructible_from, quantity_point<(isq::speed[m / s])>>); +static_assert(std::convertible_to, quantity_point>); -static_assert(std::constructible_from, quantity_point>); -static_assert(std::convertible_to, quantity_point>); +static_assert(std::constructible_from, quantity_point<(isq::length[m]) / isq::time[s]>>); +static_assert(std::convertible_to, quantity_point>); // convertible but different quantity_specs -static_assert(!std::constructible_from, quantity_point>); -static_assert(!std::convertible_to, quantity_point>); +static_assert(!std::constructible_from, quantity_point<(isq::height[m])>>); +static_assert(!std::convertible_to, quantity_point<(isq::length[m])>>); -static_assert(!std::constructible_from, quantity_point>); -static_assert(!std::convertible_to, quantity_point>); +static_assert(!std::constructible_from, quantity_point>); +static_assert(!std::convertible_to, quantity_point<(isq::height[m])>>); // quantity_specs with common_quantity_spec -static_assert(!std::constructible_from, quantity_point>); -static_assert(!std::convertible_to, quantity_point>); +static_assert(!std::constructible_from, quantity_point<(isq::height[m])>>); +static_assert(!std::convertible_to, quantity_point<(isq::width[m])>>); -static_assert(!std::constructible_from, quantity_point>); -static_assert(!std::convertible_to, quantity_point>); +static_assert(!std::constructible_from, quantity_point<(isq::width[m])>>); +static_assert(!std::convertible_to, quantity_point<(isq::height[m])>>); // non-convertible quantity_specs -static_assert(!std::constructible_from, quantity_point>); -static_assert(!std::convertible_to, quantity_point>); +static_assert(!std::constructible_from, quantity_point<(isq::length[m])>>); +static_assert(!std::convertible_to, quantity_point<(isq::height[m])>>); -static_assert(!std::constructible_from, quantity_point>); -static_assert(!std::convertible_to, quantity_point>); +static_assert(!std::constructible_from, quantity_point<(isq::height[m])>>); +static_assert(!std::convertible_to, quantity_point>); // mixed origins -static_assert(!std::constructible_from, quantity_point>); -static_assert(!std::convertible_to, quantity_point>); -static_assert(!std::constructible_from, quantity_point>); -static_assert(!std::convertible_to, quantity_point>); +static_assert(!std::constructible_from, quantity_point<(si::metre)>>); +static_assert(!std::convertible_to, quantity_point<(si::metre), mean_sea_level>>); +static_assert(!std::constructible_from, quantity_point<(isq::height[m])>>); +static_assert(!std::convertible_to, quantity_point<(isq::height[m]), mean_sea_level>>); -static_assert(!std::constructible_from, quantity_point>); -static_assert(!std::convertible_to, quantity_point>); -static_assert(!std::constructible_from, quantity_point>); -static_assert(!std::convertible_to, quantity_point>); +static_assert(!std::constructible_from, quantity_point<(si::metre), mean_sea_level>>); +static_assert(!std::convertible_to, quantity_point<(si::metre)>>); +static_assert(!std::constructible_from, quantity_point<(isq::height[m]), mean_sea_level>>); +static_assert(!std::convertible_to, quantity_point<(isq::height[m])>>); // same explicit origins static_assert( - std::constructible_from, quantity_point>); + std::constructible_from, quantity_point<(si::metre), mean_sea_level>>); static_assert( - std::convertible_to, quantity_point>); + std::convertible_to, quantity_point<(si::metre), mean_sea_level>>); -static_assert(std::constructible_from, - quantity_point>); +static_assert(std::constructible_from, + quantity_point<(isq::height[m]), mean_sea_level>>); static_assert( - std::convertible_to, quantity_point>); + std::convertible_to, quantity_point<(isq::height[m]), mean_sea_level>>); -static_assert(std::constructible_from, - quantity_point>); +static_assert(std::constructible_from, + quantity_point<(isq::height[m]), mean_sea_level>>); static_assert( - std::convertible_to, quantity_point>); + std::convertible_to, quantity_point<(isq::height[km]), mean_sea_level>>); -static_assert(std::constructible_from, - quantity_point>); +static_assert(std::constructible_from, + quantity_point<(isq::height[km]), mean_sea_level>>); static_assert( - std::convertible_to, quantity_point>); + std::convertible_to, quantity_point<(isq::height[m]), mean_sea_level>>); static_assert( - std::constructible_from, quantity_point>); + std::constructible_from, quantity_point<(isq::height[m]), mean_sea_level>>); static_assert( - std::convertible_to, quantity_point>); + std::convertible_to, quantity_point<(si::metre), mean_sea_level>>); static_assert( - std::constructible_from, quantity_point>); + std::constructible_from, quantity_point<(si::metre), mean_sea_level>>); static_assert( - std::convertible_to, quantity_point>); + std::convertible_to, quantity_point<(isq::height[m]), mean_sea_level>>); -static_assert(std::constructible_from, +static_assert(std::constructible_from, quantity_point>); static_assert(std::convertible_to, - quantity_point>); + quantity_point<(isq::height[m]), mean_sea_level>>); static_assert( - std::constructible_from, quantity_point>); -static_assert(std::convertible_to, quantity_point>); + std::constructible_from, quantity_point<(si::metre), ground_level>>); +static_assert(std::convertible_to, quantity_point<(si::metre), ground_level>>); static_assert( - std::constructible_from, quantity_point>); + std::constructible_from, quantity_point<(isq::height[m]), ground_level>>); static_assert( - std::convertible_to, quantity_point>); + std::convertible_to, quantity_point<(isq::height[m]), ground_level>>); -static_assert(std::constructible_from, - quantity_point>); +static_assert(std::constructible_from, + quantity_point<(isq::height[m]), mean_sea_level>>); static_assert( - std::convertible_to, quantity_point>); + std::convertible_to, quantity_point<(isq::height[km]), mean_sea_level>>); static_assert( - std::constructible_from, quantity_point>); + std::constructible_from, quantity_point<(isq::height[km]), ground_level>>); static_assert( - std::convertible_to, quantity_point>); + std::convertible_to, quantity_point<(isq::height[m]), ground_level>>); static_assert( - std::constructible_from, quantity_point>); + std::constructible_from, quantity_point<(isq::height[m]), ground_level>>); static_assert( - std::convertible_to, quantity_point>); + std::convertible_to, quantity_point<(si::metre), ground_level>>); static_assert( - std::constructible_from, quantity_point>); + std::constructible_from, quantity_point<(si::metre), ground_level>>); static_assert( - std::convertible_to, quantity_point>); + std::convertible_to, quantity_point<(isq::height[m]), ground_level>>); -static_assert(std::constructible_from, +static_assert(std::constructible_from, quantity_point>); static_assert( - std::convertible_to, quantity_point>); + std::convertible_to, quantity_point<(isq::height[m]), ground_level>>); static_assert( - std::constructible_from, quantity_point>); -static_assert(std::convertible_to, quantity_point>); + std::constructible_from, quantity_point<(si::metre), ground_level>>); +static_assert(std::convertible_to, quantity_point<(si::metre), mean_sea_level>>); static_assert( - std::constructible_from, quantity_point>); -static_assert(std::convertible_to, quantity_point>); + std::constructible_from, quantity_point<(si::metre), mean_sea_level>>); +static_assert(std::convertible_to, quantity_point<(si::metre), ground_level>>); static_assert( - std::constructible_from, quantity_point>); + std::constructible_from, quantity_point<(si::metre), other_ground_level>>); static_assert( - std::convertible_to, quantity_point>); + std::convertible_to, quantity_point<(si::metre), ground_level>>); static_assert( std::constructible_from, quantity_point>); @@ -682,121 +682,121 @@ static_assert( static_assert( std::convertible_to, quantity_point>); -static_assert(std::constructible_from, - quantity_point>); +static_assert(std::constructible_from, + quantity_point<(isq::height[m]), zeroth_length>>); static_assert( - std::convertible_to, quantity_point>); + std::convertible_to, quantity_point<(isq::length[m]), zeroth_length>>); // quantity_specs with common_quantity_spec -static_assert(!std::constructible_from, - quantity_point>); +static_assert(!std::constructible_from, + quantity_point<(isq::height[m]), zeroth_length>>); static_assert( - !std::convertible_to, quantity_point>); + !std::convertible_to, quantity_point<(isq::width[m]), zeroth_length>>); -static_assert(!std::constructible_from, - quantity_point>); +static_assert(!std::constructible_from, + quantity_point<(isq::width[m]), zeroth_length>>); static_assert( - !std::convertible_to, quantity_point>); + !std::convertible_to, quantity_point<(isq::height[m]), zeroth_length>>); // different dimensions static_assert( - !std::constructible_from, quantity_point>); + !std::constructible_from, quantity_point<(si::kelvin), (si::ice_point)>>); static_assert( - !std::convertible_to, quantity_point>); + !std::convertible_to, quantity_point<(isq::height[m]), mean_sea_level>>); // non-convertible quantity_specs static_assert(!std::constructible_from, - quantity_point>); -static_assert(!std::convertible_to, + quantity_point<(isq::height[m]), mean_sea_level>>); +static_assert(!std::convertible_to, quantity_point>); // implicit conversion from another quantity point only if non-truncating // int -> double OK -static_assert(std::constructible_from, - quantity_point>); -static_assert(std::convertible_to, - quantity_point>); +static_assert(std::constructible_from, + quantity_point<(isq::height[m]), mean_sea_level, int>>); +static_assert(std::convertible_to, + quantity_point<(isq::height[m]), mean_sea_level>>); // truncating double -> int not allowed -static_assert(!std::constructible_from, - quantity_point>); -static_assert(!std::convertible_to, - quantity_point>); +static_assert(!std::constructible_from, + quantity_point<(isq::height[m]), mean_sea_level>>); +static_assert(!std::convertible_to, + quantity_point<(isq::height[m]), mean_sea_level, int>>); // kilometre -> metre OK -static_assert(std::constructible_from, - quantity_point>); -static_assert(std::convertible_to, - quantity_point>); +static_assert(std::constructible_from, + quantity_point<(isq::height[km]), mean_sea_level, int>>); +static_assert(std::convertible_to, + quantity_point<(isq::height[m]), mean_sea_level, int>>); // truncating metre -> kilometre not allowed -static_assert(!std::constructible_from, - quantity_point>); -static_assert(!std::convertible_to, - quantity_point>); +static_assert(!std::constructible_from, + quantity_point<(isq::height[m]), mean_sea_level, int>>); +static_assert(!std::convertible_to, + quantity_point<(isq::height[km]), mean_sea_level, int>>); // converting to double always OK -static_assert(std::constructible_from, - quantity_point>); -static_assert(std::convertible_to, - quantity_point>); -static_assert(std::constructible_from, - quantity_point>); -static_assert(std::convertible_to, - quantity_point>); +static_assert(std::constructible_from, + quantity_point<(isq::height[km]), mean_sea_level, int>>); +static_assert(std::convertible_to, + quantity_point<(isq::height[m]), mean_sea_level>>); +static_assert(std::constructible_from, + quantity_point<(isq::height[m]), mean_sea_level, int>>); +static_assert(std::convertible_to, + quantity_point<(isq::height[km]), mean_sea_level>>); // same but not a default origin -static_assert(std::constructible_from, - quantity_point>); +static_assert(std::constructible_from, + quantity_point<(isq::height[m]), mean_sea_level>>); static_assert( - std::convertible_to, quantity_point>); + std::convertible_to, quantity_point<(isq::height[m]), mean_sea_level>>); static_assert( - std::constructible_from, quantity_point>); + std::constructible_from, quantity_point<(isq::height[m]), mean_sea_level>>); static_assert( - std::convertible_to, quantity_point>); + std::convertible_to, quantity_point<(si::metre), mean_sea_level>>); static_assert( - std::constructible_from, quantity_point>); + std::constructible_from, quantity_point<(si::metre), mean_sea_level>>); static_assert( - std::convertible_to, quantity_point>); + std::convertible_to, quantity_point<(isq::height[m]), mean_sea_level>>); -static_assert(std::constructible_from, +static_assert(std::constructible_from, quantity_point>); static_assert(std::convertible_to, - quantity_point>); + quantity_point<(isq::height[m]), mean_sea_level>>); static_assert(!std::constructible_from, - quantity_point>); -static_assert(!std::convertible_to, + quantity_point<(isq::height[m]), mean_sea_level>>); +static_assert(!std::convertible_to, quantity_point>); // different origins -static_assert(!std::constructible_from, - quantity_point>); -static_assert(!std::convertible_to, - quantity_point>); -static_assert(!std::constructible_from, - quantity_point>); -static_assert(!std::convertible_to, - quantity_point>); -static_assert(!std::constructible_from, - quantity_point>); -static_assert(!std::convertible_to, - quantity_point>); +static_assert(!std::constructible_from, + quantity_point<(isq::height[m]), other_absolute_level>>); +static_assert(!std::convertible_to, + quantity_point<(isq::height[m]), mean_sea_level>>); +static_assert(!std::constructible_from, + quantity_point<(isq::height[m]), other_absolute_level>>); +static_assert(!std::convertible_to, + quantity_point<(isq::height[m]), ground_level>>); +static_assert(!std::constructible_from, + quantity_point<(isq::height[m]), ground_level>>); +static_assert(!std::convertible_to, + quantity_point<(isq::height[m]), other_absolute_level>>); #if MP_UNITS_HOSTED // quantity-point-like static_assert( - std::constructible_from>, sys_seconds>); + std::constructible_from>, sys_seconds>); static_assert( - std::convertible_to>>); + std::convertible_to>>); // incompatible origin static_assert( - !std::constructible_from>, sys_seconds>); + !std::constructible_from>, sys_seconds>); static_assert( - !std::convertible_to>>); + !std::convertible_to>>); #endif @@ -825,17 +825,17 @@ static_assert((mean_sea_level + 42 * m).quantity_from(mean_sea_level) == 42 * m) static_assert((ground_level + 42 * m).quantity_from(ground_level) == 42 * m); static_assert((tower_peak + 42 * m).quantity_from(tower_peak) == 42 * m); -static_assert(quantity_point(ground_level + 42 * m).quantity_from(mean_sea_level) == +static_assert(quantity_point<(isq::height[m]), mean_sea_level>(ground_level + 42 * m).quantity_from(mean_sea_level) == 84 * m); -static_assert(quantity_point(tower_peak + 42 * m).quantity_from(mean_sea_level) == +static_assert(quantity_point<(isq::height[m]), mean_sea_level>(tower_peak + 42 * m).quantity_from(mean_sea_level) == 126 * m); -static_assert(quantity_point(mean_sea_level + 84 * m).quantity_from(ground_level) == +static_assert(quantity_point<(isq::height[m]), ground_level>(mean_sea_level + 84 * m).quantity_from(ground_level) == 42 * m); -static_assert(quantity_point(tower_peak + 42 * m).quantity_from(ground_level) == 84 * m); +static_assert(quantity_point<(isq::height[m]), ground_level>(tower_peak + 42 * m).quantity_from(ground_level) == 84 * m); -static_assert(quantity_point(mean_sea_level + 42 * m).quantity_from(tower_peak) == -42 * m); -static_assert(quantity_point(ground_level + 84 * m).quantity_from(tower_peak) == 42 * m); +static_assert(quantity_point<(isq::height[m]), tower_peak>(mean_sea_level + 42 * m).quantity_from(tower_peak) == -42 * m); +static_assert(quantity_point<(isq::height[m]), tower_peak>(ground_level + 84 * m).quantity_from(tower_peak) == 42 * m); static_assert((mean_sea_level + 42 * m).point_for(mean_sea_level).quantity_from(mean_sea_level) == 42 * m); static_assert((ground_level + 42 * m).point_for(mean_sea_level).quantity_from(mean_sea_level) == 84 * m); @@ -850,7 +850,7 @@ static_assert((mean_sea_level + 42 * m).point_for(tower_peak).quantity_from(towe static_assert((ground_level + 84 * m).point_for(tower_peak).quantity_from(tower_peak) == 42 * m); static_assert(is_of_type<(ground_level + isq::height(short{42} * m)).point_for(mean_sea_level), - quantity_point>); + quantity_point<(isq::height[m]), mean_sea_level, int>>); /////////////////////////////////// @@ -877,8 +877,8 @@ static_assert(is_of_type<(mean_sea_level + 2500. * m).force_in(km), quantit template typename QP> concept invalid_unit_conversion = requires { - requires !requires { QP(2000 * m).in(km); }; // truncating conversion - requires !requires { QP(2 * m).in(s); }; // invalid unit + requires !requires { QP<(isq::height[m]), mean_sea_level, int>(2000 * m).in(km); }; // truncating conversion + requires !requires { QP<(isq::height[m]), mean_sea_level, int>(2 * m).in(s); }; // invalid unit }; static_assert(invalid_unit_conversion); @@ -1020,18 +1020,18 @@ static_assert((mean_sea_level + 1123 * m -= 1 * km).quantity_from_zero().numeric template typename QP> concept invalid_compound_assignments = requires() { // truncating not allowed - requires !requires(QP l) { l += 2.5 * m; }; - requires !requires(QP l) { l -= 2.5 * m; }; - requires !requires(QP l) { l += 2 * isq::height[m]; }; - requires !requires(QP l) { l -= 2 * isq::height[m]; }; + requires !requires(QP<(isq::height[m]), mean_sea_level, int> l) { l += 2.5 * m; }; + requires !requires(QP<(isq::height[m]), mean_sea_level, int> l) { l -= 2.5 * m; }; + requires !requires(QP l) { l += 2 * (isq::height[m]); }; + requires !requires(QP l) { l -= 2 * (isq::height[m]); }; // only quantities can be added or subtracted - requires !requires(QP l) { l += 2; }; - requires !requires(QP l) { l -= 2; }; + requires !requires(QP<(isq::height[m]), mean_sea_level, int> l) { l += 2; }; + requires !requires(QP<(isq::height[m]), mean_sea_level, int> l) { l -= 2; }; // no unit constants - requires !requires(QP l) { l += m; }; - requires !requires(QP l) { l -= m; }; + requires !requires(QP<(isq::height[m]), mean_sea_level, int> l) { l += m; }; + requires !requires(QP<(isq::height[m]), mean_sea_level, int> l) { l -= m; }; }; static_assert(invalid_compound_assignments); @@ -1174,36 +1174,36 @@ static_assert(is_of_type<1 * m + (mean_sea_level + 1 * km), quantity_point>); static_assert( - is_of_type<1 * m + (mean_sea_level + isq::height(1 * m)), quantity_point>); + is_of_type<1 * m + (mean_sea_level + isq::height(1 * m)), quantity_point<(isq::height[m]), mean_sea_level, int>>); static_assert( - is_of_type<1 * m + (mean_sea_level + isq::height(1 * km)), quantity_point>); + is_of_type<1 * m + (mean_sea_level + isq::height(1 * km)), quantity_point<(isq::height[m]), mean_sea_level, int>>); static_assert( - is_of_type<1 * km + (mean_sea_level + isq::height(1 * m)), quantity_point>); + is_of_type<1 * km + (mean_sea_level + isq::height(1 * m)), quantity_point<(isq::height[m]), mean_sea_level, int>>); static_assert( - is_of_type>); + is_of_type>); static_assert( - is_of_type>); + is_of_type>); static_assert( - is_of_type>); + is_of_type>); static_assert(is_of_type>); + quantity_point<(isq::height[m]), mean_sea_level, int>>); static_assert(is_of_type>); + quantity_point<(isq::height[m]), mean_sea_level, int>>); static_assert(is_of_type>); + quantity_point<(isq::height[m]), mean_sea_level, int>>); static_assert(is_of_type>); static_assert(is_of_type, mean_sea_level, int>>); -static_assert(is_of_type>); +static_assert(is_of_type>); static_assert( is_of_type>); static_assert(is_of_type], mean_sea_level, int>>); static_assert(is_of_type<1 * m + mean_sea_level, quantity_point>); static_assert(is_of_type<1 * km + mean_sea_level, quantity_point, mean_sea_level, int>>); -static_assert(is_of_type>); +static_assert(is_of_type>); static_assert( is_of_type>); static_assert(is_of_type>); static_assert( - is_of_type<(mean_sea_level + 1 * m) - isq::height(1 * m), quantity_point>); + is_of_type<(mean_sea_level + 1 * m) - isq::height(1 * m), quantity_point<(isq::height[m]), mean_sea_level, int>>); static_assert( - is_of_type<(mean_sea_level + 1 * m) - isq::height(1 * km), quantity_point>); + is_of_type<(mean_sea_level + 1 * m) - isq::height(1 * km), quantity_point<(isq::height[m]), mean_sea_level, int>>); static_assert( - is_of_type<(mean_sea_level + 1 * km) - isq::height(1 * m), quantity_point>); + is_of_type<(mean_sea_level + 1 * km) - isq::height(1 * m), quantity_point<(isq::height[m]), mean_sea_level, int>>); static_assert( - is_of_type<(mean_sea_level + isq::height(1 * m)) - 1 * m, quantity_point>); + is_of_type<(mean_sea_level + isq::height(1 * m)) - 1 * m, quantity_point<(isq::height[m]), mean_sea_level, int>>); static_assert( - is_of_type<(mean_sea_level + isq::height(1 * m)) - 1 * km, quantity_point>); + is_of_type<(mean_sea_level + isq::height(1 * m)) - 1 * km, quantity_point<(isq::height[m]), mean_sea_level, int>>); static_assert( - is_of_type<(mean_sea_level + isq::height(1 * km)) - 1 * m, quantity_point>); + is_of_type<(mean_sea_level + isq::height(1 * km)) - 1 * m, quantity_point<(isq::height[m]), mean_sea_level, int>>); static_assert(is_of_type<(mean_sea_level + isq::height(1 * m)) - isq::height(1 * m), - quantity_point>); + quantity_point<(isq::height[m]), mean_sea_level, int>>); static_assert(is_of_type<(mean_sea_level + isq::height(1 * m)) - isq::height(1 * km), - quantity_point>); + quantity_point<(isq::height[m]), mean_sea_level, int>>); static_assert(is_of_type<(mean_sea_level + isq::height(1 * km)) - isq::height(1 * m), - quantity_point>); + quantity_point<(isq::height[m]), mean_sea_level, int>>); static_assert(is_of_type>); static_assert(is_of_type, mean_sea_level, int>>); @@ -1254,39 +1254,39 @@ static_assert(is_of_type<(mean_sea_level + 1 * km) - (mean_sea_level + 1 * m), q static_assert(is_of_type<(mean_sea_level + 1 * m) - (mean_sea_level + 1 * km), quantity>); static_assert( - is_of_type<(mean_sea_level + 1 * m) - (mean_sea_level + isq::height(1 * m)), quantity>); + is_of_type<(mean_sea_level + 1 * m) - (mean_sea_level + isq::height(1 * m)), quantity<(isq::height[m]), int>>); static_assert( - is_of_type<(mean_sea_level + 1 * m) - (mean_sea_level + isq::height(1 * km)), quantity>); + is_of_type<(mean_sea_level + 1 * m) - (mean_sea_level + isq::height(1 * km)), quantity<(isq::height[m]), int>>); static_assert( - is_of_type<(mean_sea_level + 1 * km) - (mean_sea_level + isq::height(1 * m)), quantity>); + is_of_type<(mean_sea_level + 1 * km) - (mean_sea_level + isq::height(1 * m)), quantity<(isq::height[m]), int>>); static_assert( - is_of_type<(mean_sea_level + isq::height(1 * m)) - (mean_sea_level + 1 * m), quantity>); + is_of_type<(mean_sea_level + isq::height(1 * m)) - (mean_sea_level + 1 * m), quantity<(isq::height[m]), int>>); static_assert( - is_of_type<(mean_sea_level + isq::height(1 * m)) - (mean_sea_level + 1 * km), quantity>); + is_of_type<(mean_sea_level + isq::height(1 * m)) - (mean_sea_level + 1 * km), quantity<(isq::height[m]), int>>); static_assert( - is_of_type<(mean_sea_level + isq::height(1 * km)) - (mean_sea_level + 1 * m), quantity>); + is_of_type<(mean_sea_level + isq::height(1 * km)) - (mean_sea_level + 1 * m), quantity<(isq::height[m]), int>>); static_assert(is_of_type<(mean_sea_level + isq::height(1 * m)) - (mean_sea_level + isq::height(1 * m)), - quantity>); + quantity<(isq::height[m]), int>>); static_assert(is_of_type<(mean_sea_level + isq::height(1 * m)) - (mean_sea_level + isq::height(1 * km)), - quantity>); + quantity<(isq::height[m]), int>>); static_assert(is_of_type<(mean_sea_level + isq::height(1 * km)) - (mean_sea_level + isq::height(1 * m)), - quantity>); + quantity<(isq::height[m]), int>>); static_assert(is_of_type<(mean_sea_level + 1 * m) - (mean_sea_level + 1 * m), quantity>); static_assert(is_of_type<(ground_level + 1 * m) - (ground_level + 1 * m), quantity>); static_assert(is_of_type<(tower_peak + 1 * m) - (tower_peak + 1 * m), quantity>); -static_assert(is_of_type<(mean_sea_level + 1 * m) - (ground_level + 1 * m), quantity>); -static_assert(is_of_type<(ground_level + 1 * m) - (mean_sea_level + 1 * m), quantity>); -static_assert(is_of_type<(tower_peak + 1 * m) - (ground_level + 1 * m), quantity>); -static_assert(is_of_type<(ground_level + 1 * m) - (tower_peak + 1 * m), quantity>); -static_assert(is_of_type<(tower_peak + 1 * m) - (mean_sea_level + 1 * m), quantity>); -static_assert(is_of_type<(mean_sea_level + 1 * m) - (tower_peak + 1 * m), quantity>); -static_assert(is_of_type<(other_ground_level + 1 * m) - (ground_level + 1 * m), quantity>); -static_assert(is_of_type<(ground_level + 1 * m) - (other_ground_level + 1 * m), quantity>); -static_assert(is_of_type<(other_ground_level + 1 * m) - (tower_peak + 1 * m), quantity>); -static_assert(is_of_type<(tower_peak + 1 * m) - (other_ground_level + 1 * m), quantity>); +static_assert(is_of_type<(mean_sea_level + 1 * m) - (ground_level + 1 * m), quantity<(isq::height[m]), int>>); +static_assert(is_of_type<(ground_level + 1 * m) - (mean_sea_level + 1 * m), quantity<(isq::height[m]), int>>); +static_assert(is_of_type<(tower_peak + 1 * m) - (ground_level + 1 * m), quantity<(isq::height[m]), int>>); +static_assert(is_of_type<(ground_level + 1 * m) - (tower_peak + 1 * m), quantity<(isq::height[m]), int>>); +static_assert(is_of_type<(tower_peak + 1 * m) - (mean_sea_level + 1 * m), quantity<(isq::height[m]), int>>); +static_assert(is_of_type<(mean_sea_level + 1 * m) - (tower_peak + 1 * m), quantity<(isq::height[m]), int>>); +static_assert(is_of_type<(other_ground_level + 1 * m) - (ground_level + 1 * m), quantity<(isq::height[m]), int>>); +static_assert(is_of_type<(ground_level + 1 * m) - (other_ground_level + 1 * m), quantity<(isq::height[m]), int>>); +static_assert(is_of_type<(other_ground_level + 1 * m) - (tower_peak + 1 * m), quantity<(isq::height[m]), int>>); +static_assert(is_of_type<(tower_peak + 1 * m) - (other_ground_level + 1 * m), quantity<(isq::height[m]), int>>); static_assert(is_of_type>); static_assert(is_of_type, int>>); @@ -1298,32 +1298,32 @@ static_assert(is_of_type>); static_assert(is_of_type<(ground_level + 1 * km) - ground_level, quantity, int>>); -static_assert(is_of_type>); -static_assert(is_of_type>); -static_assert(is_of_type<(ground_level + 1 * m) - mean_sea_level, quantity>); -static_assert(is_of_type<(ground_level + 1 * km) - mean_sea_level, quantity>); +static_assert(is_of_type>); +static_assert(is_of_type>); +static_assert(is_of_type<(ground_level + 1 * m) - mean_sea_level, quantity<(isq::height[m]), int>>); +static_assert(is_of_type<(ground_level + 1 * km) - mean_sea_level, quantity<(isq::height[m]), int>>); -static_assert(is_of_type>); -static_assert(is_of_type>); -static_assert(is_of_type<(mean_sea_level + 1 * m) - ground_level, quantity>); -static_assert(is_of_type<(mean_sea_level + 1 * km) - ground_level, quantity>); +static_assert(is_of_type>); +static_assert(is_of_type>); +static_assert(is_of_type<(mean_sea_level + 1 * m) - ground_level, quantity<(isq::height[m]), int>>); +static_assert(is_of_type<(mean_sea_level + 1 * km) - ground_level, quantity<(isq::height[m]), int>>); -static_assert(is_of_type>); -static_assert(is_of_type>); -static_assert(is_of_type>); -static_assert(is_of_type>); -static_assert(is_of_type>); +static_assert(is_of_type>); +static_assert(is_of_type>); +static_assert(is_of_type>); +static_assert(is_of_type>); +static_assert(is_of_type>); -static_assert(is_of_type<(1 * m + mean_sea_level) - (1 * m + ground_level), quantity>); -static_assert(is_of_type<(1 * m + ground_level) - (1 * m + mean_sea_level), quantity>); -static_assert(is_of_type<(1 * m + tower_peak) - (1 * m + ground_level), quantity>); -static_assert(is_of_type<(1 * m + ground_level) - (1 * m + tower_peak), quantity>); -static_assert(is_of_type<(1 * m + tower_peak) - (1 * m + mean_sea_level), quantity>); -static_assert(is_of_type<(1 * m + mean_sea_level) - (1 * m + tower_peak), quantity>); -static_assert(is_of_type<(1 * m + other_ground_level) - (1 * m + ground_level), quantity>); -static_assert(is_of_type<(1 * m + ground_level) - (1 * m + other_ground_level), quantity>); -static_assert(is_of_type<(1 * m + other_ground_level) - (1 * m + tower_peak), quantity>); -static_assert(is_of_type<(1 * m + tower_peak) - (1 * m + other_ground_level), quantity>); +static_assert(is_of_type<(1 * m + mean_sea_level) - (1 * m + ground_level), quantity<(isq::height[m]), int>>); +static_assert(is_of_type<(1 * m + ground_level) - (1 * m + mean_sea_level), quantity<(isq::height[m]), int>>); +static_assert(is_of_type<(1 * m + tower_peak) - (1 * m + ground_level), quantity<(isq::height[m]), int>>); +static_assert(is_of_type<(1 * m + ground_level) - (1 * m + tower_peak), quantity<(isq::height[m]), int>>); +static_assert(is_of_type<(1 * m + tower_peak) - (1 * m + mean_sea_level), quantity<(isq::height[m]), int>>); +static_assert(is_of_type<(1 * m + mean_sea_level) - (1 * m + tower_peak), quantity<(isq::height[m]), int>>); +static_assert(is_of_type<(1 * m + other_ground_level) - (1 * m + ground_level), quantity<(isq::height[m]), int>>); +static_assert(is_of_type<(1 * m + ground_level) - (1 * m + other_ground_level), quantity<(isq::height[m]), int>>); +static_assert(is_of_type<(1 * m + other_ground_level) - (1 * m + tower_peak), quantity<(isq::height[m]), int>>); +static_assert(is_of_type<(1 * m + tower_peak) - (1 * m + other_ground_level), quantity<(isq::height[m]), int>>); // check for integral types promotion diff --git a/test/static/quantity_test.cpp b/test/static/quantity_test.cpp index 7fcabec2..9d93cfe5 100644 --- a/test/static/quantity_test.cpp +++ b/test/static/quantity_test.cpp @@ -84,14 +84,14 @@ static_assert(std::is_nothrow_destructible_v>); static_assert(std::is_trivially_copyable_v>); static_assert(std::is_standard_layout_v>); -static_assert(std::default_initializable>); -static_assert(std::move_constructible>); -static_assert(std::copy_constructible>); -static_assert(std::equality_comparable>); -static_assert(std::totally_ordered>); -static_assert(std::regular>); +static_assert(std::default_initializable>); +static_assert(std::move_constructible>); +static_assert(std::copy_constructible>); +static_assert(std::equality_comparable>); +static_assert(std::totally_ordered>); +static_assert(std::regular>); -static_assert(std::three_way_comparable>); +static_assert(std::three_way_comparable>); ////////////////// @@ -112,8 +112,8 @@ static_assert(quantity::unit == si::metre); // member types ///////////////// -static_assert(is_same_v::rep, double>); -static_assert(is_same_v::rep, int>); +static_assert(is_same_v::rep, double>); +static_assert(is_same_v::rep, int>); //////////////////////////// @@ -135,11 +135,11 @@ static_assert(quantity::max().numerical_value_in(m) == s ///////////////////////////////////////////////// // construction from a value is private -static_assert(!std::constructible_from, double>); -static_assert(!std::convertible_to>); +static_assert(!std::constructible_from, double>); +static_assert(!std::convertible_to>); -static_assert(!std::constructible_from, int>); -static_assert(!std::convertible_to>); +static_assert(!std::constructible_from, int>); +static_assert(!std::convertible_to>); static_assert(std::constructible_from, double>); static_assert(std::convertible_to>); @@ -159,45 +159,45 @@ static_assert(std::convertible_to>); /////////////////////////////////////// // conversion only between convertible quantities -static_assert(std::constructible_from, quantity>); -static_assert(std::convertible_to, quantity>); -static_assert(std::constructible_from, quantity>); -static_assert(std::convertible_to, quantity>); -static_assert(std::constructible_from, quantity>); -static_assert(std::convertible_to, quantity>); +static_assert(std::constructible_from, quantity<(isq::length[m])>>); +static_assert(std::convertible_to, quantity<(isq::length[m])>>); +static_assert(std::constructible_from, quantity<(isq::distance[m])>>); +static_assert(std::convertible_to, quantity<(isq::length[m])>>); +static_assert(std::constructible_from, quantity<(isq::length[km])>>); +static_assert(std::convertible_to, quantity<(isq::length[m])>>); // conversion between different quantities not allowed -static_assert(!std::constructible_from, quantity>); -static_assert(!std::convertible_to, quantity>); -static_assert(!std::constructible_from, quantity>); -static_assert(!std::convertible_to, quantity>); +static_assert(!std::constructible_from, quantity<(isq::time[s])>>); +static_assert(!std::convertible_to, quantity<(isq::length[m])>>); +static_assert(!std::constructible_from, quantity<(isq::speed[m / s])>>); +static_assert(!std::convertible_to, quantity<(isq::length[m])>>); // implicit conversion from another quantity only if non-truncating -static_assert(std::constructible_from, quantity>); // int -> double OK -static_assert(std::convertible_to, quantity>); // int -> double OK +static_assert(std::constructible_from, quantity<(isq::length[m]), int>>); // int -> double OK +static_assert(std::convertible_to, quantity<(isq::length[m])>>); // int -> double OK -static_assert(!std::constructible_from, - quantity>); // truncating double -> int not allowed -static_assert(!std::convertible_to, - quantity>); // truncating double -> int not allowed +static_assert(!std::constructible_from, + quantity<(isq::length[m])>>); // truncating double -> int not allowed +static_assert(!std::convertible_to, + quantity<(isq::length[m]), int>>); // truncating double -> int not allowed -static_assert(std::constructible_from, - quantity>); // kilometre -> metre OK -static_assert(std::convertible_to, - quantity>); // kilometre -> metre OK +static_assert(std::constructible_from, + quantity<(isq::length[km]), int>>); // kilometre -> metre OK +static_assert(std::convertible_to, + quantity<(isq::length[m]), int>>); // kilometre -> metre OK -static_assert(!std::constructible_from, - quantity>); // truncating metre -> +static_assert(!std::constructible_from, + quantity<(isq::length[m]), int>>); // truncating metre -> // kilometre not allowed static_assert( - !std::convertible_to, - quantity>); // truncating metre -> kilometre not allowed + !std::convertible_to, + quantity<(isq::length[km]), int>>); // truncating metre -> kilometre not allowed // converting to double always OK -static_assert(std::constructible_from, quantity>); -static_assert(std::convertible_to, quantity>); -static_assert(std::constructible_from, quantity>); -static_assert(std::convertible_to, quantity>); +static_assert(std::constructible_from, quantity<(isq::length[km]), int>>); +static_assert(std::convertible_to, quantity<(isq::length[m])>>); +static_assert(std::constructible_from, quantity<(isq::length[m]), int>>); +static_assert(std::convertible_to, quantity<(isq::length[km])>>); /////////////////////// // obtaining a number @@ -324,9 +324,9 @@ struct derived_quantity : quantity { // NOLINTEND(google-explicit-constructor, hicpp-explicit-conversions) }; -static_assert(Quantity, "NTTP type description">>); +static_assert(Quantity, "NTTP type description">>); -constexpr QuantityOf auto get_length_derived_quantity() noexcept +constexpr QuantityOf<(isq::length)> auto get_length_derived_quantity() noexcept { derived_quantity, "NTTP type description"> dist{}; dist += 1 * m; @@ -454,10 +454,10 @@ static_assert((std::uint8_t{255}* m %= 257 * m).numerical_value_in(m) != [] { #if !(defined MP_UNITS_COMP_CLANG && MP_UNITS_COMP_CLANG < 18 && defined MP_UNITS_MODULES) // next two lines trigger conversions warnings // (warning disabled in CMake for this file) -static_assert((22 * m *= 33.33).numerical_value_in(m) == 733); -static_assert((22 * m /= 3.33).numerical_value_in(m) == 6); -static_assert((22 * m *= 33.33 * one).numerical_value_in(m) == 733); -static_assert((22 * m /= 3.33 * one).numerical_value_in(m) == 6); +static_assert(((22 * m) *= 33.33).numerical_value_in(m) ==733); +static_assert(((22 * m) /= 3.33).numerical_value_in(m) == 6); +static_assert(((22 * m) *= 33.33 * one).numerical_value_in(m) == 733); +static_assert(((22 * m) /= 3.33 * one).numerical_value_in(m) == 6); #endif template typename Q> @@ -843,27 +843,27 @@ static_assert(2 * one / (1 * m) == 2 / (1 * m)); // equality operators /////////////////////// -static_assert(std::equality_comparable_with, quantity>); -static_assert(std::equality_comparable_with, quantity>); -static_assert(std::equality_comparable_with, quantity, int>>); -static_assert(std::equality_comparable_with, quantity, int>>); -static_assert(std::equality_comparable_with, quantity>); -static_assert(std::equality_comparable_with, quantity>); -static_assert(std::equality_comparable_with, quantity, int>>); -static_assert(std::equality_comparable_with, quantity>); -static_assert(std::equality_comparable_with, quantity>); -static_assert(std::equality_comparable_with, quantity, int>>); -static_assert(std::equality_comparable_with, quantity>); -static_assert(std::equality_comparable_with, quantity>); +static_assert(std::equality_comparable_with, quantity<(si::metre)>>); +static_assert(std::equality_comparable_with, quantity<(si::metre), int>>); +static_assert(std::equality_comparable_with, quantity, int>>); +static_assert(std::equality_comparable_with, quantity, int>>); +static_assert(std::equality_comparable_with, quantity<(si::metre)>>); +static_assert(std::equality_comparable_with, quantity<(si::metre), int>>); +static_assert(std::equality_comparable_with, quantity, int>>); +static_assert(std::equality_comparable_with, quantity<(si::metre)>>); +static_assert(std::equality_comparable_with, quantity<(si::metre), int>>); +static_assert(std::equality_comparable_with, quantity<(si::kilo<(si::metre)>), int>>); +static_assert(std::equality_comparable_with, quantity<(isq::height[(si::metre)])>>); +static_assert(std::equality_comparable_with, quantity<(isq::height[(si::metre)]), int>>); static_assert( - std::equality_comparable_with, quantity], int>>); + std::equality_comparable_with, quantity<(isq::height[(si::kilo<(si::metre)>)]), int>>); template concept no_crossdimensional_equality = requires { requires !requires { 1 * s == 1 * M; }; requires !requires { 1 * s != 1 * M; }; }; -static_assert(no_crossdimensional_equality); +static_assert(no_crossdimensional_equality<(si::metre)>); // same type static_assert(123 * m == 123 * m); @@ -916,7 +916,7 @@ concept no_crossdimensional_ordering = requires { requires !requires { 1 * s <= 1 * M; }; requires !requires { 1 * s >= 1 * M; }; }; -static_assert(no_crossdimensional_ordering); +static_assert(no_crossdimensional_ordering<(si::metre)>); // same type static_assert(123 * m < 321 * m); @@ -1030,34 +1030,34 @@ static_assert(is_of_type(lvalue_q), quantity, isq::length>); -static_assert(QuantityOf, isq::length>); -static_assert(QuantityOf, isq::length>); -static_assert(!QuantityOf, isq::width>); -static_assert(QuantityOf, isq::width>); -static_assert(QuantityOf, isq::position_vector>); -static_assert(QuantityOf[m]>, isq::width>); -static_assert(QuantityOf[m]>, isq::position_vector>); -static_assert(!QuantityOf, isq::altitude>); +static_assert(QuantityOf, (isq::length)>); +static_assert(QuantityOf, (isq::length)>); +static_assert(QuantityOf, (isq::length)>); +static_assert(!QuantityOf, (isq::width)>); +static_assert(QuantityOf, (isq::width)>); +static_assert(QuantityOf, (isq::position_vector)>); +static_assert(QuantityOf[m]>, (isq::width)>); +static_assert(QuantityOf[m]>, (isq::position_vector)>); +static_assert(!QuantityOf, isq::altitude>); -static_assert(QuantityOf, isq::speed>); -static_assert(QuantityOf, isq::length / isq::time>); +static_assert(QuantityOf, (isq::speed)>); +static_assert(QuantityOf, (isq::length) / (isq::time)>); static_assert(QuantityOf, isq::length / isq::time>); -static_assert(QuantityOf[m / s]>, isq::length / isq::time>); -static_assert(!QuantityOf, isq::distance / isq::duration>); -static_assert(!QuantityOf, isq::width / isq::duration>); +static_assert(QuantityOf[m / s]>, (isq::length) / (isq::time)>); +static_assert(!QuantityOf, (isq::distance) / (isq::duration)>); +static_assert(!QuantityOf, (isq::width) / (isq::duration)>); static_assert(QuantityOf, isq::width / isq::duration>); -static_assert(QuantityOf[m / s]>, isq::width / isq::duration>); -static_assert(!QuantityOf, isq::position_vector / isq::duration>); +static_assert(QuantityOf[m / s]>, (isq::width) / (isq::duration)>); +static_assert(!QuantityOf, (isq::position_vector) / (isq::duration)>); static_assert(QuantityOf, isq::position_vector / isq::duration>); -static_assert(QuantityOf[m / s]>, isq::position_vector / isq::duration>); -static_assert(QuantityOf, isq::position_vector / isq::duration>); +static_assert(QuantityOf[m / s]>, isq::position_vector / isq::duration>); +static_assert(QuantityOf, isq::position_vector / isq::duration>); -static_assert(QuantityOf); // kind of -static_assert(QuantityOf[m]), isq::height>); // kind of -static_assert(!QuantityOf); // different kinds -static_assert(!QuantityOf); // different kinds -static_assert(QuantityOf); -static_assert(QuantityOf); // derived unnamed quantity +static_assert(QuantityOf); // kind of +static_assert(QuantityOf[m]), (isq::height)>); // kind of +static_assert(!QuantityOf); // different kinds +static_assert(!QuantityOf); // different kinds +static_assert(QuantityOf); +static_assert(QuantityOf); // derived unnamed quantity } // namespace diff --git a/test/static/reference_test.cpp b/test/static/reference_test.cpp index f7f3d709..46026702 100644 --- a/test/static/reference_test.cpp +++ b/test/static/reference_test.cpp @@ -238,7 +238,7 @@ template concept invalid_nu_unit = !requires { dim[unit]; }; static_assert(invalid_nu_unit); -static_assert(invalid_nu_unit); +static_assert(invalid_nu_unit<(nu::time), second>); static_assert(invalid_nu_unit); static_assert(invalid_nu_unit); static_assert(invalid_nu_unit); diff --git a/test/static/si_test.cpp b/test/static/si_test.cpp index 4f306fd2..d52a8edc 100644 --- a/test/static/si_test.cpp +++ b/test/static/si_test.cpp @@ -65,7 +65,7 @@ concept can_not_be_prefixed = Unit && !requires { typename prefix< static_assert(can_not_be_prefixed); static_assert(can_not_be_prefixed); -static_assert(can_not_be_prefixed>); +static_assert(can_not_be_prefixed)>); static_assert(can_not_be_prefixed); static_assert(can_not_be_prefixed * si::degree>);