forked from mpusz/mp-units
[msvc][fix] a lot of brackets where msvc prefers
the type and not the value. (Issue reported)
This commit is contained in:
Jonas Hoppe
+31
-31
@@ -57,41 +57,41 @@ static_assert(!QuantityPoint<sys_seconds>);
|
||||
|
||||
// construction - same rep type
|
||||
static_assert(
|
||||
std::constructible_from<quantity<isq::time[si::second], std::chrono::seconds::rep>, std::chrono::seconds>);
|
||||
static_assert(std::convertible_to<std::chrono::seconds, quantity<isq::time[si::second], std::chrono::seconds::rep>>);
|
||||
static_assert(std::constructible_from<quantity<isq::time[si::hour], std::chrono::hours::rep>, std::chrono::hours>);
|
||||
static_assert(std::convertible_to<std::chrono::hours, quantity<isq::time[si::hour], std::chrono::hours::rep>>);
|
||||
static_assert(std::constructible_from<quantity<isq::time[si::second], std::chrono::hours::rep>, std::chrono::hours>);
|
||||
static_assert(std::convertible_to<std::chrono::hours, quantity<isq::time[si::second], std::chrono::hours::rep>>);
|
||||
static_assert(!std::constructible_from<quantity<isq::time[si::hour], std::chrono::seconds::rep>, std::chrono::seconds>);
|
||||
static_assert(!std::convertible_to<std::chrono::seconds, quantity<isq::time[si::hour], std::chrono::seconds::rep>>);
|
||||
std::constructible_from<quantity<(isq::time[si::second]), std::chrono::seconds::rep>, std::chrono::seconds>);
|
||||
static_assert(std::convertible_to<std::chrono::seconds, quantity<(isq::time[si::second]), std::chrono::seconds::rep>>);
|
||||
static_assert(std::constructible_from<quantity<(isq::time[si::hour]), std::chrono::hours::rep>, std::chrono::hours>);
|
||||
static_assert(std::convertible_to<std::chrono::hours, quantity<(isq::time[si::hour]), std::chrono::hours::rep>>);
|
||||
static_assert(std::constructible_from<quantity<(isq::time[si::second]), std::chrono::hours::rep>, std::chrono::hours>);
|
||||
static_assert(std::convertible_to<std::chrono::hours, quantity<(isq::time[si::second]), std::chrono::hours::rep>>);
|
||||
static_assert(!std::constructible_from<quantity<(isq::time[si::hour]), std::chrono::seconds::rep>, std::chrono::seconds>);
|
||||
static_assert(!std::convertible_to<std::chrono::seconds, quantity<(isq::time[si::hour]), std::chrono::seconds::rep>>);
|
||||
static_assert(
|
||||
std::constructible_from<time_point<si::second, std::chrono::system_clock, sys_seconds::rep>, sys_seconds>);
|
||||
std::constructible_from<time_point<(si::second), std::chrono::system_clock, sys_seconds::rep>, sys_seconds>);
|
||||
static_assert(
|
||||
!std::constructible_from<time_point<si::second, std::chrono::steady_clock, sys_seconds::rep>, sys_seconds>);
|
||||
static_assert(std::convertible_to<sys_seconds, time_point<si::second, std::chrono::system_clock, sys_seconds::rep>>);
|
||||
static_assert(std::constructible_from<time_point<si::day, std::chrono::system_clock, sys_days::rep>, sys_days>);
|
||||
static_assert(!std::constructible_from<time_point<si::day, std::chrono::steady_clock, sys_days::rep>, sys_days>);
|
||||
static_assert(std::convertible_to<sys_days, time_point<si::day, std::chrono::system_clock, sys_days::rep>>);
|
||||
static_assert(std::constructible_from<time_point<si::second, std::chrono::system_clock, sys_days::rep>, sys_days>);
|
||||
static_assert(!std::constructible_from<time_point<si::second, std::chrono::steady_clock, sys_days::rep>, sys_days>);
|
||||
static_assert(std::convertible_to<sys_days, time_point<si::second, std::chrono::system_clock, sys_days::rep>>);
|
||||
static_assert(!std::constructible_from<time_point<si::day, std::chrono::system_clock, sys_seconds::rep>, sys_seconds>);
|
||||
static_assert(!std::convertible_to<sys_seconds, time_point<si::day, std::chrono::system_clock, sys_seconds::rep>>);
|
||||
!std::constructible_from<time_point<(si::second), std::chrono::steady_clock, sys_seconds::rep>, sys_seconds>);
|
||||
static_assert(std::convertible_to<sys_seconds, time_point<(si::second), std::chrono::system_clock, sys_seconds::rep>>);
|
||||
static_assert(std::constructible_from<time_point<(si::day), std::chrono::system_clock, sys_days::rep>, sys_days>);
|
||||
static_assert(!std::constructible_from<time_point<(si::day), std::chrono::steady_clock, sys_days::rep>, sys_days>);
|
||||
static_assert(std::convertible_to<sys_days, time_point<(si::day), std::chrono::system_clock, sys_days::rep>>);
|
||||
static_assert(std::constructible_from<time_point<(si::second), std::chrono::system_clock, sys_days::rep>, sys_days>);
|
||||
static_assert(!std::constructible_from<time_point<(si::second), std::chrono::steady_clock, sys_days::rep>, sys_days>);
|
||||
static_assert(std::convertible_to<sys_days, time_point<(si::second), std::chrono::system_clock, sys_days::rep>>);
|
||||
static_assert(!std::constructible_from<time_point<(si::day), std::chrono::system_clock, sys_seconds::rep>, sys_seconds>);
|
||||
static_assert(!std::convertible_to<sys_seconds, time_point<(si::day), std::chrono::system_clock, sys_seconds::rep>>);
|
||||
|
||||
// construction - different rep type (integral to a floating-point)
|
||||
static_assert(std::constructible_from<quantity<isq::time[si::second]>, std::chrono::seconds>);
|
||||
static_assert(std::convertible_to<std::chrono::seconds, quantity<isq::time[si::second]>>);
|
||||
static_assert(std::constructible_from<quantity<isq::time[si::second]>, std::chrono::hours>);
|
||||
static_assert(std::convertible_to<std::chrono::hours, quantity<isq::time[si::second]>>);
|
||||
static_assert(std::constructible_from<quantity<isq::time[si::hour]>, std::chrono::seconds>);
|
||||
static_assert(std::convertible_to<std::chrono::seconds, quantity<isq::time[si::hour]>>);
|
||||
static_assert(std::constructible_from<time_point<si::second, std::chrono::system_clock>, sys_seconds>);
|
||||
static_assert(std::convertible_to<sys_seconds, time_point<si::second, std::chrono::system_clock>>);
|
||||
static_assert(std::constructible_from<time_point<si::second, std::chrono::system_clock>, sys_days>);
|
||||
static_assert(std::convertible_to<sys_days, time_point<si::second, std::chrono::system_clock>>);
|
||||
static_assert(std::constructible_from<time_point<si::day, std::chrono::system_clock>, sys_seconds>);
|
||||
static_assert(std::convertible_to<sys_seconds, time_point<si::day, std::chrono::system_clock>>);
|
||||
static_assert(std::constructible_from<quantity<(isq::time[si::second])>, std::chrono::seconds>);
|
||||
static_assert(std::convertible_to<std::chrono::seconds, quantity<(isq::time[si::second])>>);
|
||||
static_assert(std::constructible_from<quantity<(isq::time[si::second])>, std::chrono::hours>);
|
||||
static_assert(std::convertible_to<std::chrono::hours, quantity<(isq::time[si::second])>>);
|
||||
static_assert(std::constructible_from<quantity<(isq::time[si::hour])>, std::chrono::seconds>);
|
||||
static_assert(std::convertible_to<std::chrono::seconds, quantity<(isq::time[si::hour])>>);
|
||||
static_assert(std::constructible_from<time_point<(si::second), std::chrono::system_clock>, sys_seconds>);
|
||||
static_assert(std::convertible_to<sys_seconds, time_point<(si::second), std::chrono::system_clock>>);
|
||||
static_assert(std::constructible_from<time_point<(si::second), std::chrono::system_clock>, sys_days>);
|
||||
static_assert(std::convertible_to<sys_days, time_point<(si::second), std::chrono::system_clock>>);
|
||||
static_assert(std::constructible_from<time_point<(si::day), std::chrono::system_clock>, sys_seconds>);
|
||||
static_assert(std::convertible_to<sys_seconds, time_point<(si::day), std::chrono::system_clock>>);
|
||||
|
||||
static_assert(quantity<si::second>{1s} == 1 * s);
|
||||
static_assert(quantity<isq::time[si::second]>{1s} == 1 * s);
|
||||
|
||||
+146
-121
@@ -83,7 +83,7 @@ inline constexpr auto speed = isq::length / isq::time;
|
||||
static_assert(QuantitySpec<struct isq::length>);
|
||||
static_assert(QuantitySpec<struct isq::radius>);
|
||||
static_assert(QuantitySpec<struct isq::speed>);
|
||||
static_assert(QuantitySpec<decltype(kind_of<isq::length>)>);
|
||||
static_assert(QuantitySpec<decltype(kind_of<(isq::length)>)>);
|
||||
static_assert(QuantitySpec<decltype(isq::length / isq::time)>);
|
||||
static_assert(QuantitySpec<decltype(pow<2>(isq::length))>);
|
||||
static_assert(QuantitySpec<struct dimensionless>);
|
||||
@@ -95,7 +95,7 @@ static_assert(!QuantitySpec<int>);
|
||||
static_assert(detail::NamedQuantitySpec<struct isq::length>);
|
||||
static_assert(detail::NamedQuantitySpec<struct isq::radius>);
|
||||
static_assert(detail::NamedQuantitySpec<struct isq::speed>);
|
||||
static_assert(!detail::NamedQuantitySpec<std::remove_const_t<decltype(kind_of<isq::length>)>>);
|
||||
static_assert(!detail::NamedQuantitySpec<std::remove_const_t<decltype(kind_of<(isq::length)>)>>);
|
||||
static_assert(!detail::NamedQuantitySpec<decltype(isq::length / isq::time)>);
|
||||
static_assert(!detail::NamedQuantitySpec<decltype(pow<2>(isq::length))>);
|
||||
static_assert(detail::NamedQuantitySpec<struct dimensionless>);
|
||||
@@ -106,7 +106,7 @@ static_assert(!detail::NamedQuantitySpec<int>);
|
||||
// DerivedQuantitySpec
|
||||
static_assert(!detail::DerivedQuantitySpec<struct isq::length>);
|
||||
static_assert(!detail::DerivedQuantitySpec<struct isq::radius>);
|
||||
static_assert(!detail::DerivedQuantitySpec<decltype(kind_of<isq::length>)>);
|
||||
static_assert(!detail::DerivedQuantitySpec<decltype(kind_of<(isq::length)>)>);
|
||||
static_assert(!detail::DerivedQuantitySpec<struct isq::speed>);
|
||||
static_assert(detail::DerivedQuantitySpec<decltype(isq::length / isq::time)>);
|
||||
static_assert(detail::DerivedQuantitySpec<decltype(pow<2>(isq::length))>);
|
||||
@@ -118,7 +118,7 @@ static_assert(!detail::DerivedQuantitySpec<int>);
|
||||
// QuantityKindSpec
|
||||
static_assert(!detail::QuantityKindSpec<struct isq::length>);
|
||||
static_assert(!detail::QuantityKindSpec<struct isq::radius>);
|
||||
static_assert(detail::QuantityKindSpec<std::remove_const_t<decltype(kind_of<isq::length>)>>);
|
||||
static_assert(detail::QuantityKindSpec<std::remove_const_t<decltype(kind_of<(isq::length)>)>>);
|
||||
static_assert(!detail::QuantityKindSpec<struct isq::speed>);
|
||||
static_assert(!detail::QuantityKindSpec<decltype(isq::length / isq::time)>);
|
||||
static_assert(!detail::QuantityKindSpec<decltype(pow<2>(isq::length))>);
|
||||
@@ -133,7 +133,7 @@ static_assert(!detail::QuantityKindSpec<int>);
|
||||
// Unit
|
||||
static_assert(Unit<struct si::metre>);
|
||||
static_assert(Unit<decltype(si::kilogram)>);
|
||||
static_assert(Unit<decltype(si::kilo<si::gram>)>);
|
||||
static_assert(Unit<decltype(si::kilo<(si::gram)>)>);
|
||||
static_assert(Unit<struct natural::electronvolt>);
|
||||
static_assert(Unit<decltype(si::metre / si::second)>);
|
||||
static_assert(Unit<decltype(inverse(si::second))>);
|
||||
@@ -144,22 +144,47 @@ static_assert(Unit<struct si::standard_gravity>);
|
||||
static_assert(Unit<scaled_unit<mag<10>, struct si::second>>);
|
||||
static_assert(Unit<derived_unit<struct si::metre, per<struct si::second>>>);
|
||||
static_assert(Unit<struct one>);
|
||||
static_assert(!Unit<named_unit<"?", kind_of<isq::length>>>);
|
||||
static_assert(!Unit<named_unit<"?", kind_of<(isq::length)>>>);
|
||||
static_assert(!Unit<named_unit<"?">>);
|
||||
static_assert(!Unit<named_unit<"?", si::metre / si::second>>);
|
||||
static_assert(!Unit<named_unit<"?", si::metre, kind_of<isq::length>>>);
|
||||
static_assert(!Unit<prefixed_unit<"?", mag<10>, si::second>>);
|
||||
static_assert(!Unit<named_unit<"?", (si::metre), kind_of<(isq::length)>>>);
|
||||
static_assert(!Unit<prefixed_unit<"?", mag<10>, (si::second)>>);
|
||||
static_assert(!Unit<struct isq::dim_length>);
|
||||
static_assert(!Unit<int>);
|
||||
#if MP_UNITS_HOSTED
|
||||
static_assert(!Unit<std::chrono::seconds>);
|
||||
#endif
|
||||
|
||||
// NamedUnit
|
||||
static_assert(detail::NamedUnit<struct si::metre>);
|
||||
static_assert(detail::NamedUnit<struct natural::electronvolt>);
|
||||
static_assert(!detail::NamedUnit<decltype(si::kilogram)>);
|
||||
static_assert(!detail::NamedUnit<decltype((si::kilo<(si::gram)>))>);
|
||||
static_assert(!detail::NamedUnit<decltype(si::metre / si::second)>);
|
||||
static_assert(!detail::NamedUnit<decltype(inverse(si::second))>);
|
||||
static_assert(!detail::NamedUnit<decltype(mag<10> * si::second)>);
|
||||
static_assert(!detail::NamedUnit<decltype(square(si::metre))>);
|
||||
static_assert(!detail::NamedUnit<decltype(pow<2>(si::metre))>);
|
||||
static_assert(detail::NamedUnit<struct si::standard_gravity>);
|
||||
static_assert(!detail::NamedUnit<scaled_unit<mag<10>, struct si::second>>);
|
||||
static_assert(!detail::NamedUnit<derived_unit<struct si::metre, per<struct si::second>>>);
|
||||
static_assert(!detail::NamedUnit<struct one>);
|
||||
static_assert(!detail::NamedUnit<named_unit<"?", kind_of<(isq::length)>>>);
|
||||
static_assert(!detail::NamedUnit<named_unit<"?">>);
|
||||
static_assert(!detail::NamedUnit<named_unit<"?", si::metre / si::second>>);
|
||||
static_assert(!detail::NamedUnit<named_unit<"?", (si::metre), kind_of<(isq::length)>>>);
|
||||
static_assert(!detail::NamedUnit<prefixed_unit<"?", mag<10>, (si::second)>>);
|
||||
static_assert(!detail::NamedUnit<struct isq::dim_length>);
|
||||
static_assert(!detail::NamedUnit<int>);
|
||||
#if MP_UNITS_HOSTED
|
||||
static_assert(!detail::NamedUnit<std::chrono::seconds>);
|
||||
#endif
|
||||
|
||||
// PrefixableUnit
|
||||
static_assert(PrefixableUnit<struct si::metre>);
|
||||
static_assert(PrefixableUnit<struct natural::electronvolt>);
|
||||
static_assert(!PrefixableUnit<decltype(si::kilogram)>);
|
||||
static_assert(!PrefixableUnit<decltype(si::kilo<si::gram>)>);
|
||||
static_assert(!PrefixableUnit<decltype(si::kilo<(si::gram)>)>);
|
||||
static_assert(!PrefixableUnit<decltype(si::metre / si::second)>);
|
||||
static_assert(!PrefixableUnit<decltype(inverse(si::second))>);
|
||||
static_assert(!PrefixableUnit<decltype(mag<10> * si::second)>);
|
||||
@@ -169,11 +194,11 @@ static_assert(PrefixableUnit<struct si::standard_gravity>);
|
||||
static_assert(!PrefixableUnit<scaled_unit<mag<10>, struct si::second>>);
|
||||
static_assert(!PrefixableUnit<derived_unit<struct si::metre, per<struct si::second>>>);
|
||||
static_assert(!PrefixableUnit<struct one>);
|
||||
static_assert(!PrefixableUnit<named_unit<"?", kind_of<isq::length>>>);
|
||||
static_assert(!PrefixableUnit<named_unit<"?", kind_of<(isq::length)>>>);
|
||||
static_assert(!PrefixableUnit<named_unit<"?">>);
|
||||
static_assert(!PrefixableUnit<named_unit<"?", si::metre / si::second>>);
|
||||
static_assert(!PrefixableUnit<named_unit<"?", si::metre, kind_of<isq::length>>>);
|
||||
static_assert(!PrefixableUnit<prefixed_unit<"?", mag<10>, si::second>>);
|
||||
static_assert(!PrefixableUnit<named_unit<"?", (si::metre), kind_of<(isq::length)>>>);
|
||||
static_assert(!PrefixableUnit<prefixed_unit<"?", mag<10>, (si::second)>>);
|
||||
static_assert(!PrefixableUnit<struct isq::dim_length>);
|
||||
static_assert(!PrefixableUnit<int>);
|
||||
#if MP_UNITS_HOSTED
|
||||
@@ -184,7 +209,7 @@ static_assert(!PrefixableUnit<std::chrono::seconds>);
|
||||
static_assert(AssociatedUnit<struct si::metre>);
|
||||
static_assert(!AssociatedUnit<struct natural::electronvolt>);
|
||||
static_assert(AssociatedUnit<decltype(si::kilogram)>);
|
||||
static_assert(AssociatedUnit<decltype(si::kilo<si::gram>)>);
|
||||
static_assert(AssociatedUnit<decltype(si::kilo<(si::gram)>)>);
|
||||
static_assert(AssociatedUnit<decltype(si::metre / si::second)>);
|
||||
static_assert(AssociatedUnit<decltype(inverse(si::second))>);
|
||||
static_assert(AssociatedUnit<decltype(mag<10> * si::second)>);
|
||||
@@ -194,11 +219,11 @@ static_assert(AssociatedUnit<struct si::standard_gravity>);
|
||||
static_assert(AssociatedUnit<scaled_unit<mag<10>, struct si::second>>);
|
||||
static_assert(AssociatedUnit<derived_unit<struct si::metre, per<struct si::second>>>);
|
||||
static_assert(AssociatedUnit<struct one>);
|
||||
static_assert(!AssociatedUnit<named_unit<"?", kind_of<isq::length>>>);
|
||||
static_assert(!AssociatedUnit<named_unit<"?", kind_of<(isq::length)>>>);
|
||||
static_assert(!AssociatedUnit<named_unit<"?">>);
|
||||
static_assert(!AssociatedUnit<named_unit<"?", si::metre / si::second>>);
|
||||
static_assert(!AssociatedUnit<named_unit<"?", si::metre, kind_of<isq::length>>>);
|
||||
static_assert(!AssociatedUnit<prefixed_unit<"?", mag<10>, si::second>>);
|
||||
static_assert(!AssociatedUnit<named_unit<"?", (si::metre), kind_of<(isq::length)>>>);
|
||||
static_assert(!AssociatedUnit<prefixed_unit<"?", mag<10>, (si::second)>>);
|
||||
static_assert(!AssociatedUnit<struct isq::dim_length>);
|
||||
static_assert(!AssociatedUnit<int>);
|
||||
#if MP_UNITS_HOSTED
|
||||
@@ -206,19 +231,19 @@ static_assert(!AssociatedUnit<std::chrono::seconds>);
|
||||
#endif
|
||||
|
||||
// UnitOf
|
||||
static_assert(UnitOf<struct si::metre, isq::length>);
|
||||
static_assert(UnitOf<struct si::metre, isq::radius>);
|
||||
static_assert(UnitOf<decltype(si::kilogram), isq::mass>);
|
||||
static_assert(UnitOf<struct si::hertz, isq::frequency>);
|
||||
static_assert(UnitOf<struct si::metre, (isq::length)>);
|
||||
static_assert(UnitOf<struct si::metre, (isq::radius)>);
|
||||
static_assert(UnitOf<decltype(si::kilogram), (isq::mass)>);
|
||||
static_assert(UnitOf<struct si::hertz, (isq::frequency)>);
|
||||
static_assert(UnitOf<struct si::hertz, inverse(isq::time)>);
|
||||
static_assert(UnitOf<struct one, dimensionless>);
|
||||
static_assert(UnitOf<struct percent, dimensionless>);
|
||||
static_assert(UnitOf<struct si::radian, isq::angular_measure>);
|
||||
static_assert(UnitOf<struct one, isq::angular_measure>);
|
||||
static_assert(UnitOf<struct percent, isq::angular_measure>);
|
||||
static_assert(UnitOf<struct si::radian, (isq::angular_measure)>);
|
||||
static_assert(UnitOf<struct one, (isq::angular_measure)>);
|
||||
static_assert(UnitOf<struct percent, (isq::angular_measure)>);
|
||||
static_assert(!UnitOf<struct si::radian, dimensionless>);
|
||||
static_assert(!UnitOf<struct si::metre, isq::time>);
|
||||
static_assert(!UnitOf<struct natural::electronvolt, isq::energy>);
|
||||
static_assert(!UnitOf<struct si::metre, (isq::time)>);
|
||||
static_assert(!UnitOf<struct natural::electronvolt, (isq::energy)>);
|
||||
|
||||
// Reference
|
||||
static_assert(Reference<struct si::metre>);
|
||||
@@ -228,32 +253,32 @@ static_assert(Reference<decltype(isq::radius[si::metre])>);
|
||||
static_assert(Reference<decltype(isq::radius[si::metre] / isq::time[si::second])>);
|
||||
static_assert(!Reference<struct natural::electronvolt>);
|
||||
static_assert(!Reference<struct isq::length>);
|
||||
static_assert(!Reference<decltype(kind_of<isq::length>)>);
|
||||
static_assert(!Reference<decltype(kind_of<(isq::length)>)>);
|
||||
static_assert(!Reference<struct isq::dim_length>);
|
||||
static_assert(!Reference<int>);
|
||||
|
||||
// ReferenceOf
|
||||
static_assert(ReferenceOf<struct si::metre, isq::length>);
|
||||
static_assert(ReferenceOf<struct si::metre, isq::radius>);
|
||||
static_assert(!ReferenceOf<struct si::second, isq::length>);
|
||||
static_assert(ReferenceOf<decltype(isq::length[si::metre]), isq::length>);
|
||||
static_assert(!ReferenceOf<decltype(isq::length[si::metre]), isq::radius>);
|
||||
static_assert(ReferenceOf<decltype(isq::radius[si::metre]), isq::length>);
|
||||
static_assert(ReferenceOf<decltype(isq::radius[si::metre]), isq::radius>);
|
||||
static_assert(!ReferenceOf<struct si::second, isq::dim_length>);
|
||||
static_assert(ReferenceOf<struct si::metre, (isq::length)>);
|
||||
static_assert(ReferenceOf<struct si::metre, (isq::radius)>);
|
||||
static_assert(!ReferenceOf<struct si::second, (isq::length)>);
|
||||
static_assert(ReferenceOf<decltype(isq::length[si::metre]), (isq::length)>);
|
||||
static_assert(!ReferenceOf<decltype(isq::length[si::metre]), (isq::radius)>);
|
||||
static_assert(ReferenceOf<decltype(isq::radius[si::metre]), (isq::length)>);
|
||||
static_assert(ReferenceOf<decltype(isq::radius[si::metre]), (isq::radius)>);
|
||||
static_assert(!ReferenceOf<struct si::second, (isq::dim_length)>);
|
||||
|
||||
static_assert(ReferenceOf<struct one, dimensionless>);
|
||||
static_assert(ReferenceOf<decltype(dimensionless[one]), dimensionless>);
|
||||
static_assert(ReferenceOf<decltype(isq::rotation[one]), isq::rotation>);
|
||||
static_assert(ReferenceOf<decltype(isq::rotation[one]), (isq::rotation)>);
|
||||
static_assert(ReferenceOf<decltype(isq::rotation[one]), dimensionless>);
|
||||
static_assert(ReferenceOf<struct si::radian, isq::angular_measure>);
|
||||
static_assert(ReferenceOf<struct si::radian, (isq::angular_measure)>);
|
||||
static_assert(!ReferenceOf<struct si::radian, dimensionless>);
|
||||
static_assert(ReferenceOf<decltype(isq::angular_measure[si::radian]), isq::angular_measure>);
|
||||
static_assert(ReferenceOf<decltype(isq::angular_measure[si::radian]), (isq::angular_measure)>);
|
||||
static_assert(!ReferenceOf<decltype(isq::angular_measure[si::radian]), dimensionless>);
|
||||
static_assert(ReferenceOf<struct one, isq::rotation>);
|
||||
static_assert(ReferenceOf<struct one, isq::angular_measure>);
|
||||
static_assert(!ReferenceOf<decltype(dimensionless[one]), isq::rotation>);
|
||||
static_assert(!ReferenceOf<decltype(dimensionless[one]), isq::angular_measure>);
|
||||
static_assert(ReferenceOf<struct one, (isq::rotation)>);
|
||||
static_assert(ReferenceOf<struct one, (isq::angular_measure)>);
|
||||
static_assert(!ReferenceOf<decltype(dimensionless[one]), (isq::rotation)>);
|
||||
static_assert(!ReferenceOf<decltype(dimensionless[one]), (isq::angular_measure)>);
|
||||
|
||||
// Representation
|
||||
static_assert(Representation<int>);
|
||||
@@ -278,57 +303,57 @@ static_assert(!RepresentationOf<std::string, quantity_character::scalar>);
|
||||
#endif
|
||||
|
||||
// Quantity
|
||||
static_assert(Quantity<quantity<si::metre>>);
|
||||
static_assert(Quantity<quantity<isq::length[si::metre]>>);
|
||||
static_assert(Quantity<quantity<si::metre, int>>);
|
||||
static_assert(Quantity<quantity<isq::length[si::metre], int>>);
|
||||
static_assert(Quantity<quantity<(si::metre)>>);
|
||||
static_assert(Quantity<quantity<(isq::length[si::metre])>>);
|
||||
static_assert(Quantity<quantity<(si::metre), int>>);
|
||||
static_assert(Quantity<quantity<(isq::length[si::metre]), int>>);
|
||||
#if MP_UNITS_HOSTED
|
||||
static_assert(!Quantity<std::chrono::seconds>);
|
||||
#endif
|
||||
static_assert(!Quantity<quantity_point<si::metre, my_origin>>);
|
||||
static_assert(!Quantity<quantity_point<(si::metre), my_origin>>);
|
||||
static_assert(!Quantity<decltype(isq::length[si::metre])>);
|
||||
|
||||
// QuantityOf
|
||||
static_assert(QuantityOf<quantity<si::metre>, isq::length>);
|
||||
static_assert(QuantityOf<quantity<si::metre>, isq::radius>);
|
||||
static_assert(!QuantityOf<quantity<si::second>, isq::length>);
|
||||
static_assert(QuantityOf<quantity<isq::length[si::metre]>, isq::length>);
|
||||
static_assert(!QuantityOf<quantity<isq::length[si::metre]>, isq::radius>);
|
||||
static_assert(QuantityOf<quantity<isq::radius[si::metre]>, isq::length>);
|
||||
static_assert(QuantityOf<quantity<isq::radius[si::metre]>, isq::radius>);
|
||||
static_assert(!QuantityOf<quantity<si::second>, isq::dim_length>);
|
||||
static_assert(QuantityOf<quantity<(si::metre)>, (isq::length)>);
|
||||
static_assert(QuantityOf<quantity<(si::metre)>, (isq::radius)>);
|
||||
static_assert(!QuantityOf<quantity<(si::second)>, (isq::length)>);
|
||||
static_assert(QuantityOf<quantity<(isq::length[si::metre])>, (isq::length)>);
|
||||
static_assert(!QuantityOf<quantity<(isq::length[si::metre])>, (isq::radius)>);
|
||||
static_assert(QuantityOf<quantity<(isq::radius[si::metre])>, (isq::length)>);
|
||||
static_assert(QuantityOf<quantity<(isq::radius[si::metre])>, (isq::radius)>);
|
||||
static_assert(!QuantityOf<quantity<(si::second)>, (isq::dim_length)>);
|
||||
|
||||
static_assert(QuantityOf<quantity<one>, dimensionless>);
|
||||
static_assert(QuantityOf<quantity<dimensionless[one]>, dimensionless>);
|
||||
static_assert(QuantityOf<quantity<isq::rotation[one]>, isq::rotation>);
|
||||
static_assert(QuantityOf<quantity<isq::rotation[one]>, dimensionless>);
|
||||
static_assert(QuantityOf<quantity<si::radian>, isq::angular_measure>);
|
||||
static_assert(!QuantityOf<quantity<si::radian>, dimensionless>);
|
||||
static_assert(QuantityOf<quantity<isq::angular_measure[si::radian]>, isq::angular_measure>);
|
||||
static_assert(!QuantityOf<quantity<isq::angular_measure[si::radian]>, dimensionless>);
|
||||
static_assert(QuantityOf<quantity<one>, isq::rotation>);
|
||||
static_assert(QuantityOf<quantity<one>, isq::angular_measure>);
|
||||
static_assert(!QuantityOf<quantity<dimensionless[one]>, isq::rotation>);
|
||||
static_assert(!QuantityOf<quantity<dimensionless[one]>, isq::angular_measure>);
|
||||
static_assert(QuantityOf<quantity<(isq::rotation[one])>, (isq::rotation)>);
|
||||
static_assert(QuantityOf<quantity<(isq::rotation[one])>, dimensionless>);
|
||||
static_assert(QuantityOf<quantity<(si::radian)>, (isq::angular_measure)>);
|
||||
static_assert(!QuantityOf<quantity<(si::radian)>, dimensionless>);
|
||||
static_assert(QuantityOf<quantity<(isq::angular_measure[si::radian])>, (isq::angular_measure)>);
|
||||
static_assert(!QuantityOf<quantity<(isq::angular_measure[si::radian])>, dimensionless>);
|
||||
static_assert(QuantityOf<quantity<one>, (isq::rotation)>);
|
||||
static_assert(QuantityOf<quantity<one>, (isq::angular_measure)>);
|
||||
static_assert(!QuantityOf<quantity<dimensionless[one]>, (isq::rotation)>);
|
||||
static_assert(!QuantityOf<quantity<dimensionless[one]>, (isq::angular_measure)>);
|
||||
|
||||
// QuantityLike
|
||||
#if MP_UNITS_HOSTED
|
||||
static_assert(QuantityLike<std::chrono::seconds>);
|
||||
static_assert(QuantityLike<std::chrono::hours>);
|
||||
#endif
|
||||
static_assert(!QuantityLike<quantity<isq::time[si::second]>>);
|
||||
static_assert(!QuantityLike<quantity_point<isq::length[si::metre], my_origin>>);
|
||||
static_assert(!QuantityLike<quantity<(isq::time[si::second])>>);
|
||||
static_assert(!QuantityLike<quantity_point<(isq::length[si::metre]), my_origin>>);
|
||||
static_assert(!QuantityLike<int>);
|
||||
|
||||
// QuantityPoint
|
||||
static_assert(QuantityPoint<quantity_point<si::metre, my_origin>>);
|
||||
static_assert(QuantityPoint<quantity_point<si::metre, my_relative_origin>>);
|
||||
static_assert(QuantityPoint<quantity_point<isq::length[si::metre], my_origin>>);
|
||||
static_assert(QuantityPoint<quantity_point<isq::length[si::metre], my_relative_origin, int>>);
|
||||
static_assert(QuantityPoint<quantity_point<isq::radius[si::metre], my_origin>>);
|
||||
static_assert(QuantityPoint<quantity_point<isq::radius[si::metre], my_relative_origin>>);
|
||||
static_assert(QuantityPoint<quantity_point<(si::metre), my_origin>>);
|
||||
static_assert(QuantityPoint<quantity_point<(si::metre), my_relative_origin>>);
|
||||
static_assert(QuantityPoint<quantity_point<(isq::length[si::metre]), my_origin>>);
|
||||
static_assert(QuantityPoint<quantity_point<(isq::length[si::metre]), my_relative_origin, int>>);
|
||||
static_assert(QuantityPoint<quantity_point<(isq::radius[si::metre]), my_origin>>);
|
||||
static_assert(QuantityPoint<quantity_point<(isq::radius[si::metre]), my_relative_origin>>);
|
||||
static_assert(!QuantityPoint<decltype(isq::length[si::metre])>);
|
||||
static_assert(!QuantityPoint<absolute_point_origin<isq::length>>);
|
||||
static_assert(!QuantityPoint<absolute_point_origin<(isq::length)>>);
|
||||
static_assert(!QuantityPoint<struct my_origin>);
|
||||
static_assert(!QuantityPoint<struct my_relative_origin>);
|
||||
#if MP_UNITS_HOSTED
|
||||
@@ -338,35 +363,35 @@ static_assert(!QuantityPoint<std::chrono::time_point<std::chrono::system_clock>>
|
||||
static_assert(!QuantityPoint<int>);
|
||||
|
||||
// QuantityPointOf
|
||||
static_assert(QuantityPointOf<quantity_point<si::metre, my_origin>, isq::length>);
|
||||
static_assert(QuantityPointOf<quantity_point<si::metre, my_origin>, isq::radius>);
|
||||
static_assert(QuantityPointOf<quantity_point<isq::length[si::metre], my_origin>, isq::length>);
|
||||
static_assert(!QuantityPointOf<quantity_point<isq::length[si::metre], my_origin>, isq::radius>);
|
||||
static_assert(QuantityPointOf<quantity_point<isq::radius[si::metre], my_origin>, isq::length>);
|
||||
static_assert(QuantityPointOf<quantity_point<isq::radius[si::metre], my_origin>, isq::radius>);
|
||||
static_assert(QuantityPointOf<quantity_point<isq::radius[si::metre], my_relative_origin>, isq::length>);
|
||||
static_assert(QuantityPointOf<quantity_point<isq::radius[si::metre], my_relative_origin>, isq::radius>);
|
||||
static_assert(QuantityPointOf<quantity_point<si::metre, my_origin>, my_origin>);
|
||||
static_assert(QuantityPointOf<quantity_point<si::metre, my_origin>, my_relative_origin>);
|
||||
static_assert(QuantityPointOf<quantity_point<si::metre, my_relative_origin>, my_relative_origin>);
|
||||
static_assert(QuantityPointOf<quantity_point<si::metre, my_relative_origin>, my_origin>);
|
||||
static_assert(QuantityPointOf<quantity_point<isq::length[si::metre], my_origin>, my_origin>);
|
||||
static_assert(QuantityPointOf<quantity_point<isq::length[si::metre], my_origin>, my_relative_origin>);
|
||||
static_assert(QuantityPointOf<quantity_point<isq::length[si::metre], my_relative_origin>, my_relative_origin>);
|
||||
static_assert(QuantityPointOf<quantity_point<isq::length[si::metre], my_relative_origin>, my_origin>);
|
||||
static_assert(QuantityPointOf<quantity_point<isq::radius[si::metre], my_origin>, my_origin>);
|
||||
static_assert(QuantityPointOf<quantity_point<isq::radius[si::metre], my_origin>, my_relative_origin>);
|
||||
static_assert(QuantityPointOf<quantity_point<isq::radius[si::metre], my_relative_origin>, my_relative_origin>);
|
||||
static_assert(QuantityPointOf<quantity_point<isq::radius[si::metre], my_relative_origin>, my_origin>);
|
||||
static_assert(QuantityPointOf<quantity_point<(si::metre), my_origin>, (isq::length)>);
|
||||
static_assert(QuantityPointOf<quantity_point<(si::metre), my_origin>, (isq::radius)>);
|
||||
static_assert(QuantityPointOf<quantity_point<(isq::length[si::metre]), my_origin>, (isq::length)>);
|
||||
static_assert(!QuantityPointOf<quantity_point<(isq::length[si::metre]), my_origin>, (isq::radius)>);
|
||||
static_assert(QuantityPointOf<quantity_point<(isq::radius[si::metre]), my_origin>, (isq::length)>);
|
||||
static_assert(QuantityPointOf<quantity_point<(isq::radius[si::metre]), my_origin>, (isq::radius)>);
|
||||
static_assert(QuantityPointOf<quantity_point<(isq::radius[si::metre]), my_relative_origin>, (isq::length)>);
|
||||
static_assert(QuantityPointOf<quantity_point<(isq::radius[si::metre]), my_relative_origin>, (isq::radius)>);
|
||||
static_assert(QuantityPointOf<quantity_point<(si::metre), my_origin>, my_origin>);
|
||||
static_assert(QuantityPointOf<quantity_point<(si::metre), my_origin>, my_relative_origin>);
|
||||
static_assert(QuantityPointOf<quantity_point<(si::metre), my_relative_origin>, my_relative_origin>);
|
||||
static_assert(QuantityPointOf<quantity_point<(si::metre), my_relative_origin>, my_origin>);
|
||||
static_assert(QuantityPointOf<quantity_point<(isq::length[si::metre]), my_origin>, my_origin>);
|
||||
static_assert(QuantityPointOf<quantity_point<(isq::length[si::metre]), my_origin>, my_relative_origin>);
|
||||
static_assert(QuantityPointOf<quantity_point<(isq::length[si::metre]), my_relative_origin>, my_relative_origin>);
|
||||
static_assert(QuantityPointOf<quantity_point<(isq::length[si::metre]), my_relative_origin>, my_origin>);
|
||||
static_assert(QuantityPointOf<quantity_point<(isq::radius[si::metre]), my_origin>, my_origin>);
|
||||
static_assert(QuantityPointOf<quantity_point<(isq::radius[si::metre]), my_origin>, my_relative_origin>);
|
||||
static_assert(QuantityPointOf<quantity_point<(isq::radius[si::metre]), my_relative_origin>, my_relative_origin>);
|
||||
static_assert(QuantityPointOf<quantity_point<(isq::radius[si::metre]), my_relative_origin>, my_origin>);
|
||||
|
||||
// PointOrigin
|
||||
static_assert(PointOrigin<struct my_origin>);
|
||||
static_assert(PointOrigin<struct my_relative_origin>);
|
||||
static_assert(!PointOrigin<absolute_point_origin<isq::length>>);
|
||||
static_assert(!PointOrigin<absolute_point_origin<(isq::length)>>);
|
||||
static_assert(!PointOrigin<relative_point_origin<my_origin + 42 * si::metre>>);
|
||||
static_assert(!PointOrigin<quantity_point<si::metre, my_origin>>);
|
||||
static_assert(!PointOrigin<quantity_point<isq::length[si::metre], my_origin>>);
|
||||
static_assert(!PointOrigin<quantity_point<isq::radius[si::metre], my_origin>>);
|
||||
static_assert(!PointOrigin<quantity_point<(si::metre), my_origin>>);
|
||||
static_assert(!PointOrigin<quantity_point<(isq::length[si::metre]), my_origin>>);
|
||||
static_assert(!PointOrigin<quantity_point<(isq::radius[si::metre]), my_origin>>);
|
||||
static_assert(!PointOrigin<decltype(isq::length[si::metre])>);
|
||||
#if MP_UNITS_HOSTED
|
||||
static_assert(!PointOrigin<std::chrono::seconds>);
|
||||
@@ -375,38 +400,38 @@ static_assert(!PointOrigin<std::chrono::time_point<std::chrono::system_clock>>);
|
||||
static_assert(!PointOrigin<int>);
|
||||
|
||||
// PointOriginFor
|
||||
static_assert(PointOriginFor<struct my_origin, isq::length>);
|
||||
static_assert(PointOriginFor<struct my_origin, isq::radius>);
|
||||
static_assert(!PointOriginFor<struct my_origin, isq::time>);
|
||||
static_assert(PointOriginFor<struct my_relative_origin, isq::length>);
|
||||
static_assert(PointOriginFor<struct my_relative_origin, isq::radius>);
|
||||
static_assert(!PointOriginFor<struct my_relative_origin, isq::time>);
|
||||
static_assert(!PointOriginFor<quantity_point<si::metre, my_origin>, isq::length>);
|
||||
static_assert(!PointOriginFor<quantity_point<si::metre, my_origin>, isq::radius>);
|
||||
static_assert(!PointOriginFor<quantity_point<si::metre, my_origin>, isq::time>);
|
||||
static_assert(!PointOriginFor<quantity_point<isq::length[si::metre], my_origin>, isq::length>);
|
||||
static_assert(!PointOriginFor<quantity_point<isq::length[si::metre], my_origin>, isq::radius>);
|
||||
static_assert(!PointOriginFor<quantity_point<isq::length[si::metre], my_origin>, isq::time>);
|
||||
static_assert(!PointOriginFor<quantity_point<isq::radius[si::metre], my_origin>, isq::length>);
|
||||
static_assert(!PointOriginFor<quantity_point<isq::radius[si::metre], my_origin>, isq::radius>);
|
||||
static_assert(!PointOriginFor<quantity_point<isq::radius[si::metre], my_origin>, isq::time>);
|
||||
static_assert(!PointOriginFor<quantity_point<isq::radius[si::metre], my_relative_origin>, isq::length>);
|
||||
static_assert(!PointOriginFor<quantity_point<isq::radius[si::metre], my_relative_origin>, isq::radius>);
|
||||
static_assert(!PointOriginFor<quantity_point<isq::radius[si::metre], my_relative_origin>, isq::time>);
|
||||
static_assert(!PointOriginFor<decltype(isq::length[si::metre]), isq::length>);
|
||||
static_assert(PointOriginFor<struct my_origin, (isq::length)>);
|
||||
static_assert(PointOriginFor<struct my_origin, (isq::radius)>);
|
||||
static_assert(!PointOriginFor<struct my_origin, (isq::time)>);
|
||||
static_assert(PointOriginFor<struct my_relative_origin, (isq::length)>);
|
||||
static_assert(PointOriginFor<struct my_relative_origin, (isq::radius)>);
|
||||
static_assert(!PointOriginFor<struct my_relative_origin, (isq::time)>);
|
||||
static_assert(!PointOriginFor<quantity_point<(si::metre), my_origin>, (isq::length)>);
|
||||
static_assert(!PointOriginFor<quantity_point<(si::metre), my_origin>, (isq::radius)>);
|
||||
static_assert(!PointOriginFor<quantity_point<(si::metre), my_origin>, (isq::time)>);
|
||||
static_assert(!PointOriginFor<quantity_point<(isq::length[si::metre]), my_origin>, (isq::length)>);
|
||||
static_assert(!PointOriginFor<quantity_point<(isq::length[si::metre]), my_origin>, (isq::radius)>);
|
||||
static_assert(!PointOriginFor<quantity_point<(isq::length[si::metre]), my_origin>, (isq::time)>);
|
||||
static_assert(!PointOriginFor<quantity_point<(isq::radius[si::metre]), my_origin>, (isq::length)>);
|
||||
static_assert(!PointOriginFor<quantity_point<(isq::radius[si::metre]), my_origin>, (isq::radius)>);
|
||||
static_assert(!PointOriginFor<quantity_point<(isq::radius[si::metre]), my_origin>, (isq::time)>);
|
||||
static_assert(!PointOriginFor<quantity_point<(isq::radius[si::metre]), my_relative_origin>, (isq::length)>);
|
||||
static_assert(!PointOriginFor<quantity_point<(isq::radius[si::metre]), my_relative_origin>, (isq::radius)>);
|
||||
static_assert(!PointOriginFor<quantity_point<(isq::radius[si::metre]), my_relative_origin>, (isq::time)>);
|
||||
static_assert(!PointOriginFor<decltype((isq::length[si::metre])), (isq::length)>);
|
||||
#if MP_UNITS_HOSTED
|
||||
static_assert(!PointOriginFor<std::chrono::seconds, isq::length>);
|
||||
static_assert(!PointOriginFor<std::chrono::time_point<std::chrono::system_clock>, isq::length>);
|
||||
static_assert(!PointOriginFor<std::chrono::seconds, (isq::length)>);
|
||||
static_assert(!PointOriginFor<std::chrono::time_point<std::chrono::system_clock>, (isq::length)>);
|
||||
#endif
|
||||
static_assert(!PointOriginFor<int, isq::length>);
|
||||
static_assert(!PointOriginFor<int, (isq::length)>);
|
||||
|
||||
// QuantityPointLike
|
||||
#if MP_UNITS_HOSTED
|
||||
static_assert(QuantityPointLike<std::chrono::time_point<std::chrono::system_clock>>);
|
||||
static_assert(!QuantityPointLike<std::chrono::seconds>);
|
||||
#endif
|
||||
static_assert(!QuantityPointLike<quantity<isq::time[si::second]>>);
|
||||
static_assert(!QuantityPointLike<quantity_point<si::metre, my_origin>>);
|
||||
static_assert(!QuantityPointLike<quantity<(isq::time[si::second])>>);
|
||||
static_assert(!QuantityPointLike<quantity_point<(si::metre), my_origin>>);
|
||||
static_assert(!QuantityPointLike<int>);
|
||||
|
||||
} // namespace
|
||||
|
||||
@@ -78,18 +78,18 @@ static_assert(Representation<min_impl<int>>);
|
||||
static_assert(Representation<min_impl<double>>);
|
||||
|
||||
// construction from a value is not allowed
|
||||
static_assert(!std::constructible_from<quantity<si::metre, min_impl<int>>, min_impl<int>>);
|
||||
static_assert(!std::convertible_to<min_impl<int>, quantity<si::metre, min_impl<int>>>);
|
||||
static_assert(!std::constructible_from<quantity<(si::metre), min_impl<int>>, min_impl<int>>);
|
||||
static_assert(!std::convertible_to<min_impl<int>, quantity<(si::metre), min_impl<int>>>);
|
||||
|
||||
static_assert(!std::constructible_from<quantity<si::metre, min_impl<double>>, min_impl<double>>);
|
||||
static_assert(!std::convertible_to<min_impl<double>, quantity<si::metre, min_impl<double>>>);
|
||||
static_assert(!std::constructible_from<quantity<(si::metre), min_impl<double>>, min_impl<double>>);
|
||||
static_assert(!std::convertible_to<min_impl<double>, quantity<(si::metre), min_impl<double>>>);
|
||||
|
||||
// multiply syntax should work
|
||||
template<typename T, auto U>
|
||||
concept creates_quantity = Unit<decltype(U)> && requires { T{} * U; };
|
||||
|
||||
static_assert(creates_quantity<min_impl<int>, si::metre>);
|
||||
static_assert(creates_quantity<min_impl<double>, si::metre>);
|
||||
static_assert(creates_quantity<min_impl<int>, (si::metre)>);
|
||||
static_assert(creates_quantity<min_impl<double>, (si::metre)>);
|
||||
|
||||
// multiply syntax
|
||||
static_assert(creates_quantity<min_impl<int>, one>);
|
||||
@@ -99,46 +99,46 @@ static_assert(creates_quantity<min_impl<double>, percent>);
|
||||
|
||||
// construction from a quantity
|
||||
// min_impl<T> -> min_impl<T>
|
||||
static_assert(std::constructible_from<quantity<si::metre, min_impl<int>>, quantity<si::metre, min_impl<int>>>);
|
||||
static_assert(std::convertible_to<quantity<si::metre, min_impl<int>>, quantity<si::metre, min_impl<int>>>);
|
||||
static_assert(std::constructible_from<quantity<(si::metre), min_impl<int>>, quantity<(si::metre), min_impl<int>>>);
|
||||
static_assert(std::convertible_to<quantity<(si::metre), min_impl<int>>, quantity<(si::metre), min_impl<int>>>);
|
||||
|
||||
static_assert(std::constructible_from<quantity<si::metre, min_impl<double>>, quantity<si::metre, min_impl<double>>>);
|
||||
static_assert(std::convertible_to<quantity<si::metre, min_impl<double>>, quantity<si::metre, min_impl<double>>>);
|
||||
static_assert(std::constructible_from<quantity<(si::metre), min_impl<double>>, quantity<(si::metre), min_impl<double>>>);
|
||||
static_assert(std::convertible_to<quantity<(si::metre), min_impl<double>>, quantity<(si::metre), min_impl<double>>>);
|
||||
|
||||
static_assert(std::constructible_from<quantity<si::metre, min_impl<double>>, quantity<si::metre, min_impl<int>>>);
|
||||
static_assert(std::convertible_to<quantity<si::metre, min_impl<int>>, quantity<si::metre, min_impl<double>>>);
|
||||
static_assert(std::constructible_from<quantity<(si::metre), min_impl<double>>, quantity<(si::metre), min_impl<int>>>);
|
||||
static_assert(std::convertible_to<quantity<(si::metre), min_impl<int>>, quantity<(si::metre), min_impl<double>>>);
|
||||
|
||||
static_assert(!std::constructible_from<quantity<si::metre, min_impl<int>>,
|
||||
quantity<si::metre, min_impl<double>>>); // narrowing conversion
|
||||
static_assert(!std::convertible_to<quantity<si::metre, min_impl<double>>, quantity<si::metre, min_impl<int>>>);
|
||||
static_assert(!std::constructible_from<quantity<(si::metre), min_impl<int>>,
|
||||
quantity<(si::metre), min_impl<double>>>); // narrowing conversion
|
||||
static_assert(!std::convertible_to<quantity<(si::metre), min_impl<double>>, quantity<(si::metre), min_impl<int>>>);
|
||||
|
||||
// T -> min_impl<T>
|
||||
static_assert(std::constructible_from<quantity<si::metre, min_impl<int>>, quantity<si::metre, int>>);
|
||||
static_assert(std::convertible_to<quantity<si::metre, int>, quantity<si::metre, min_impl<int>>>);
|
||||
static_assert(std::constructible_from<quantity<(si::metre), min_impl<int>>, quantity<(si::metre), int>>);
|
||||
static_assert(std::convertible_to<quantity<(si::metre), int>, quantity<(si::metre), min_impl<int>>>);
|
||||
|
||||
static_assert(std::constructible_from<quantity<si::metre, min_impl<double>>, quantity<si::metre, double>>);
|
||||
static_assert(std::convertible_to<quantity<si::metre, double>, quantity<si::metre, min_impl<double>>>);
|
||||
static_assert(std::constructible_from<quantity<(si::metre), min_impl<double>>, quantity<(si::metre), double>>);
|
||||
static_assert(std::convertible_to<quantity<(si::metre), double>, quantity<(si::metre), min_impl<double>>>);
|
||||
|
||||
static_assert(std::constructible_from<quantity<si::metre, min_impl<double>>, quantity<si::metre, int>>);
|
||||
static_assert(std::convertible_to<quantity<si::metre, int>, quantity<si::metre, min_impl<double>>>);
|
||||
static_assert(std::constructible_from<quantity<(si::metre), min_impl<double>>, quantity<(si::metre), int>>);
|
||||
static_assert(std::convertible_to<quantity<(si::metre), int>, quantity<(si::metre), min_impl<double>>>);
|
||||
|
||||
static_assert(
|
||||
!std::constructible_from<quantity<si::metre, min_impl<int>>, quantity<si::metre, double>>); // narrowing conversion
|
||||
static_assert(!std::convertible_to<quantity<si::metre, double>, quantity<si::metre, min_impl<int>>>);
|
||||
!std::constructible_from<quantity<(si::metre), min_impl<int>>, quantity<(si::metre), double>>); // narrowing conversion
|
||||
static_assert(!std::convertible_to<quantity<(si::metre), double>, quantity<(si::metre), min_impl<int>>>);
|
||||
|
||||
// min_impl<T> -> T
|
||||
static_assert(std::constructible_from<quantity<si::metre, int>, quantity<si::metre, min_impl<int>>>);
|
||||
static_assert(std::convertible_to<quantity<si::metre, min_impl<int>>, quantity<si::metre, int>>);
|
||||
static_assert(std::constructible_from<quantity<(si::metre), int>, quantity<(si::metre), min_impl<int>>>);
|
||||
static_assert(std::convertible_to<quantity<(si::metre), min_impl<int>>, quantity<(si::metre), int>>);
|
||||
|
||||
static_assert(std::constructible_from<quantity<si::metre, double>, quantity<si::metre, min_impl<double>>>);
|
||||
static_assert(std::convertible_to<quantity<si::metre, min_impl<double>>, quantity<si::metre, double>>);
|
||||
static_assert(std::constructible_from<quantity<(si::metre), double>, quantity<(si::metre), min_impl<double>>>);
|
||||
static_assert(std::convertible_to<quantity<(si::metre), min_impl<double>>, quantity<(si::metre), double>>);
|
||||
|
||||
static_assert(std::constructible_from<quantity<si::metre, double>, quantity<si::metre, min_impl<int>>>);
|
||||
static_assert(std::convertible_to<quantity<si::metre, min_impl<int>>, quantity<si::metre, double>>);
|
||||
static_assert(std::constructible_from<quantity<(si::metre), double>, quantity<(si::metre), min_impl<int>>>);
|
||||
static_assert(std::convertible_to<quantity<(si::metre), min_impl<int>>, quantity<(si::metre), double>>);
|
||||
|
||||
static_assert(
|
||||
!std::constructible_from<quantity<si::metre, int>, quantity<si::metre, min_impl<double>>>); // narrowing conversion
|
||||
static_assert(!std::convertible_to<quantity<si::metre, min_impl<double>>, quantity<si::metre, int>>);
|
||||
!std::constructible_from<quantity<(si::metre), int>, quantity<(si::metre), min_impl<double>>>); // narrowing conversion
|
||||
static_assert(!std::convertible_to<quantity<(si::metre), min_impl<double>>, quantity<(si::metre), int>>);
|
||||
|
||||
|
||||
// arithmetic operators
|
||||
|
||||
+341
-341
File diff suppressed because it is too large
Load Diff
@@ -84,14 +84,14 @@ static_assert(std::is_nothrow_destructible_v<quantity<isq::length[m]>>);
|
||||
static_assert(std::is_trivially_copyable_v<quantity<isq::length[m]>>);
|
||||
static_assert(std::is_standard_layout_v<quantity<isq::length[m]>>);
|
||||
|
||||
static_assert(std::default_initializable<quantity<isq::length[m]>>);
|
||||
static_assert(std::move_constructible<quantity<isq::length[m]>>);
|
||||
static_assert(std::copy_constructible<quantity<isq::length[m]>>);
|
||||
static_assert(std::equality_comparable<quantity<isq::length[m]>>);
|
||||
static_assert(std::totally_ordered<quantity<isq::length[m]>>);
|
||||
static_assert(std::regular<quantity<isq::length[m]>>);
|
||||
static_assert(std::default_initializable<quantity<(isq::length[m])>>);
|
||||
static_assert(std::move_constructible<quantity<(isq::length[m])>>);
|
||||
static_assert(std::copy_constructible<quantity<(isq::length[m])>>);
|
||||
static_assert(std::equality_comparable<quantity<(isq::length[m])>>);
|
||||
static_assert(std::totally_ordered<quantity<(isq::length[m])>>);
|
||||
static_assert(std::regular<quantity<(isq::length[m])>>);
|
||||
|
||||
static_assert(std::three_way_comparable<quantity<isq::length[m]>>);
|
||||
static_assert(std::three_way_comparable<quantity<(isq::length[m])>>);
|
||||
|
||||
|
||||
//////////////////
|
||||
@@ -112,8 +112,8 @@ static_assert(quantity<isq::length[m]>::unit == si::metre);
|
||||
// member types
|
||||
/////////////////
|
||||
|
||||
static_assert(is_same_v<quantity<isq::length[m]>::rep, double>);
|
||||
static_assert(is_same_v<quantity<isq::length[m], int>::rep, int>);
|
||||
static_assert(is_same_v<quantity<(isq::length[m])>::rep, double>);
|
||||
static_assert(is_same_v<quantity<(isq::length[m]), int>::rep, int>);
|
||||
|
||||
|
||||
////////////////////////////
|
||||
@@ -135,11 +135,11 @@ static_assert(quantity<isq::length[m], double>::max().numerical_value_in(m) == s
|
||||
/////////////////////////////////////////////////
|
||||
|
||||
// construction from a value is private
|
||||
static_assert(!std::constructible_from<quantity<isq::length[m]>, double>);
|
||||
static_assert(!std::convertible_to<double, quantity<isq::length[m]>>);
|
||||
static_assert(!std::constructible_from<quantity<(isq::length[m])>, double>);
|
||||
static_assert(!std::convertible_to<double, quantity<(isq::length[m])>>);
|
||||
|
||||
static_assert(!std::constructible_from<quantity<isq::length[m], int>, int>);
|
||||
static_assert(!std::convertible_to<int, quantity<isq::length[m], int>>);
|
||||
static_assert(!std::constructible_from<quantity<(isq::length[m]), int>, int>);
|
||||
static_assert(!std::convertible_to<int, quantity<(isq::length[m]), int>>);
|
||||
|
||||
static_assert(std::constructible_from<quantity<one>, double>);
|
||||
static_assert(std::convertible_to<double, quantity<one>>);
|
||||
@@ -159,45 +159,45 @@ static_assert(std::convertible_to<int, quantity<dimensionless[one]>>);
|
||||
///////////////////////////////////////
|
||||
|
||||
// conversion only between convertible quantities
|
||||
static_assert(std::constructible_from<quantity<isq::length[m]>, quantity<isq::length[m]>>);
|
||||
static_assert(std::convertible_to<quantity<isq::length[m]>, quantity<isq::length[m]>>);
|
||||
static_assert(std::constructible_from<quantity<isq::length[m]>, quantity<isq::distance[m]>>);
|
||||
static_assert(std::convertible_to<quantity<isq::distance[m]>, quantity<isq::length[m]>>);
|
||||
static_assert(std::constructible_from<quantity<isq::length[m]>, quantity<isq::length[km]>>);
|
||||
static_assert(std::convertible_to<quantity<isq::length[km]>, quantity<isq::length[m]>>);
|
||||
static_assert(std::constructible_from<quantity<(isq::length[m])>, quantity<(isq::length[m])>>);
|
||||
static_assert(std::convertible_to<quantity<(isq::length[m])>, quantity<(isq::length[m])>>);
|
||||
static_assert(std::constructible_from<quantity<(isq::length[m])>, quantity<(isq::distance[m])>>);
|
||||
static_assert(std::convertible_to<quantity<(isq::distance[m])>, quantity<(isq::length[m])>>);
|
||||
static_assert(std::constructible_from<quantity<(isq::length[m])>, quantity<(isq::length[km])>>);
|
||||
static_assert(std::convertible_to<quantity<(isq::length[km])>, quantity<(isq::length[m])>>);
|
||||
|
||||
// conversion between different quantities not allowed
|
||||
static_assert(!std::constructible_from<quantity<isq::length[m]>, quantity<isq::time[s]>>);
|
||||
static_assert(!std::convertible_to<quantity<isq::time[s]>, quantity<isq::length[m]>>);
|
||||
static_assert(!std::constructible_from<quantity<isq::length[m]>, quantity<isq::speed[m / s]>>);
|
||||
static_assert(!std::convertible_to<quantity<isq::speed[m / s]>, quantity<isq::length[m]>>);
|
||||
static_assert(!std::constructible_from<quantity<(isq::length[m])>, quantity<(isq::time[s])>>);
|
||||
static_assert(!std::convertible_to<quantity<(isq::time[s])>, quantity<(isq::length[m])>>);
|
||||
static_assert(!std::constructible_from<quantity<(isq::length[m])>, quantity<(isq::speed[m / s])>>);
|
||||
static_assert(!std::convertible_to<quantity<(isq::speed[m / s])>, quantity<(isq::length[m])>>);
|
||||
|
||||
// implicit conversion from another quantity only if non-truncating
|
||||
static_assert(std::constructible_from<quantity<isq::length[m]>, quantity<isq::length[m], int>>); // int -> double OK
|
||||
static_assert(std::convertible_to<quantity<isq::length[m], int>, quantity<isq::length[m]>>); // int -> double OK
|
||||
static_assert(std::constructible_from<quantity<(isq::length[m])>, quantity<(isq::length[m]), int>>); // int -> double OK
|
||||
static_assert(std::convertible_to<quantity<(isq::length[m]), int>, quantity<(isq::length[m])>>); // int -> double OK
|
||||
|
||||
static_assert(!std::constructible_from<quantity<isq::length[m], int>,
|
||||
quantity<isq::length[m]>>); // truncating double -> int not allowed
|
||||
static_assert(!std::convertible_to<quantity<isq::length[m]>,
|
||||
quantity<isq::length[m], int>>); // truncating double -> int not allowed
|
||||
static_assert(!std::constructible_from<quantity<(isq::length[m]), int>,
|
||||
quantity<(isq::length[m])>>); // truncating double -> int not allowed
|
||||
static_assert(!std::convertible_to<quantity<(isq::length[m])>,
|
||||
quantity<(isq::length[m]), int>>); // truncating double -> int not allowed
|
||||
|
||||
static_assert(std::constructible_from<quantity<isq::length[m], int>,
|
||||
quantity<isq::length[km], int>>); // kilometre<int> -> metre<int> OK
|
||||
static_assert(std::convertible_to<quantity<isq::length[km], int>,
|
||||
quantity<isq::length[m], int>>); // kilometre<int> -> metre<int> OK
|
||||
static_assert(std::constructible_from<quantity<(isq::length[m]), int>,
|
||||
quantity<(isq::length[km]), int>>); // kilometre<int> -> metre<int> OK
|
||||
static_assert(std::convertible_to<quantity<(isq::length[km]), int>,
|
||||
quantity<(isq::length[m]), int>>); // kilometre<int> -> metre<int> OK
|
||||
|
||||
static_assert(!std::constructible_from<quantity<isq::length[km], int>,
|
||||
quantity<isq::length[m], int>>); // truncating metre<int> ->
|
||||
static_assert(!std::constructible_from<quantity<(isq::length[km]), int>,
|
||||
quantity<(isq::length[m]), int>>); // truncating metre<int> ->
|
||||
// kilometre<int> not allowed
|
||||
static_assert(
|
||||
!std::convertible_to<quantity<isq::length[m], int>,
|
||||
quantity<isq::length[km], int>>); // truncating metre<int> -> kilometre<int> not allowed
|
||||
!std::convertible_to<quantity<(isq::length[m]), int>,
|
||||
quantity<(isq::length[km]), int>>); // truncating metre<int> -> kilometre<int> not allowed
|
||||
|
||||
// converting to double always OK
|
||||
static_assert(std::constructible_from<quantity<isq::length[m]>, quantity<isq::length[km], int>>);
|
||||
static_assert(std::convertible_to<quantity<isq::length[km], int>, quantity<isq::length[m]>>);
|
||||
static_assert(std::constructible_from<quantity<isq::length[km]>, quantity<isq::length[m], int>>);
|
||||
static_assert(std::convertible_to<quantity<isq::length[m], int>, quantity<isq::length[km]>>);
|
||||
static_assert(std::constructible_from<quantity<(isq::length[m])>, quantity<(isq::length[km]), int>>);
|
||||
static_assert(std::convertible_to<quantity<(isq::length[km]), int>, quantity<(isq::length[m])>>);
|
||||
static_assert(std::constructible_from<quantity<(isq::length[km])>, quantity<(isq::length[m]), int>>);
|
||||
static_assert(std::convertible_to<quantity<(isq::length[m]), int>, quantity<(isq::length[km])>>);
|
||||
|
||||
///////////////////////
|
||||
// obtaining a number
|
||||
@@ -324,9 +324,9 @@ struct derived_quantity : quantity<Q::reference, Rep> {
|
||||
// NOLINTEND(google-explicit-constructor, hicpp-explicit-conversions)
|
||||
};
|
||||
|
||||
static_assert(Quantity<derived_quantity<double, quantity<isq::length[m]>, "NTTP type description">>);
|
||||
static_assert(Quantity<derived_quantity<double, quantity<(isq::length[m])>, "NTTP type description">>);
|
||||
|
||||
constexpr QuantityOf<isq::length> auto get_length_derived_quantity() noexcept
|
||||
constexpr QuantityOf<(isq::length)> auto get_length_derived_quantity() noexcept
|
||||
{
|
||||
derived_quantity<double, quantity<isq::length[m]>, "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<template<auto, typename> typename Q>
|
||||
@@ -843,27 +843,27 @@ static_assert(2 * one / (1 * m) == 2 / (1 * m));
|
||||
// equality operators
|
||||
///////////////////////
|
||||
|
||||
static_assert(std::equality_comparable_with<quantity<si::metre>, quantity<si::metre>>);
|
||||
static_assert(std::equality_comparable_with<quantity<si::metre>, quantity<si::metre, int>>);
|
||||
static_assert(std::equality_comparable_with<quantity<si::metre>, quantity<si::kilo<si::metre>, int>>);
|
||||
static_assert(std::equality_comparable_with<quantity<si::metre, int>, quantity<si::kilo<si::metre>, int>>);
|
||||
static_assert(std::equality_comparable_with<quantity<isq::length[si::metre]>, quantity<si::metre>>);
|
||||
static_assert(std::equality_comparable_with<quantity<isq::length[si::metre]>, quantity<si::metre, int>>);
|
||||
static_assert(std::equality_comparable_with<quantity<isq::length[si::metre]>, quantity<si::kilo<si::metre>, int>>);
|
||||
static_assert(std::equality_comparable_with<quantity<isq::width[si::metre]>, quantity<si::metre>>);
|
||||
static_assert(std::equality_comparable_with<quantity<isq::width[si::metre]>, quantity<si::metre, int>>);
|
||||
static_assert(std::equality_comparable_with<quantity<isq::width[si::metre]>, quantity<si::kilo<si::metre>, int>>);
|
||||
static_assert(std::equality_comparable_with<quantity<isq::width[si::metre]>, quantity<isq::height[si::metre]>>);
|
||||
static_assert(std::equality_comparable_with<quantity<isq::width[si::metre]>, quantity<isq::height[si::metre], int>>);
|
||||
static_assert(std::equality_comparable_with<quantity<(si::metre)>, quantity<(si::metre)>>);
|
||||
static_assert(std::equality_comparable_with<quantity<(si::metre)>, quantity<(si::metre), int>>);
|
||||
static_assert(std::equality_comparable_with<quantity<(si::metre)>, quantity<si::kilo<(si::metre)>, int>>);
|
||||
static_assert(std::equality_comparable_with<quantity<(si::metre), int>, quantity<si::kilo<(si::metre)>, int>>);
|
||||
static_assert(std::equality_comparable_with<quantity<(isq::length[(si::metre)])>, quantity<(si::metre)>>);
|
||||
static_assert(std::equality_comparable_with<quantity<(isq::length[(si::metre)])>, quantity<(si::metre), int>>);
|
||||
static_assert(std::equality_comparable_with<quantity<(isq::length[(si::metre)])>, quantity<si::kilo<(si::metre)>, int>>);
|
||||
static_assert(std::equality_comparable_with<quantity<(isq::width[(si::metre)])>, quantity<(si::metre)>>);
|
||||
static_assert(std::equality_comparable_with<quantity<(isq::width[(si::metre)])>, quantity<(si::metre), int>>);
|
||||
static_assert(std::equality_comparable_with<quantity<(isq::width[(si::metre)])>, quantity<(si::kilo<(si::metre)>), int>>);
|
||||
static_assert(std::equality_comparable_with<quantity<(isq::width[(si::metre)])>, quantity<(isq::height[(si::metre)])>>);
|
||||
static_assert(std::equality_comparable_with<quantity<(isq::width[(si::metre)])>, quantity<(isq::height[(si::metre)]), int>>);
|
||||
static_assert(
|
||||
std::equality_comparable_with<quantity<isq::width[si::metre]>, quantity<isq::height[si::kilo<si::metre>], int>>);
|
||||
std::equality_comparable_with<quantity<(isq::width[(si::metre)])>, quantity<(isq::height[(si::kilo<(si::metre)>)]), int>>);
|
||||
|
||||
template<auto M>
|
||||
concept no_crossdimensional_equality = requires {
|
||||
requires !requires { 1 * s == 1 * M; };
|
||||
requires !requires { 1 * s != 1 * M; };
|
||||
};
|
||||
static_assert(no_crossdimensional_equality<si::metre>);
|
||||
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<si::metre>);
|
||||
static_assert(no_crossdimensional_ordering<(si::metre)>);
|
||||
|
||||
// same type
|
||||
static_assert(123 * m < 321 * m);
|
||||
@@ -1030,34 +1030,34 @@ static_assert(is_of_type<quantity_cast<isq::distance>(lvalue_q), quantity<isq::d
|
||||
} // namespace lvalue_tests
|
||||
|
||||
// QuantityOf
|
||||
static_assert(QuantityOf<quantity<isq::length[m]>, isq::length>);
|
||||
static_assert(QuantityOf<quantity<isq::width[m]>, isq::length>);
|
||||
static_assert(QuantityOf<quantity<isq::position_vector[m], int>, isq::length>);
|
||||
static_assert(!QuantityOf<quantity<isq::length[m]>, isq::width>);
|
||||
static_assert(QuantityOf<quantity<m>, isq::width>);
|
||||
static_assert(QuantityOf<quantity<m>, isq::position_vector>);
|
||||
static_assert(QuantityOf<quantity<kind_of<isq::length>[m]>, isq::width>);
|
||||
static_assert(QuantityOf<quantity<kind_of<isq::length>[m]>, isq::position_vector>);
|
||||
static_assert(!QuantityOf<quantity<isq::width[m]>, isq::altitude>);
|
||||
static_assert(QuantityOf<quantity<(isq::length[m])>, (isq::length)>);
|
||||
static_assert(QuantityOf<quantity<(isq::width[m])>, (isq::length)>);
|
||||
static_assert(QuantityOf<quantity<(isq::position_vector[m]), int>, (isq::length)>);
|
||||
static_assert(!QuantityOf<quantity<(isq::length[m])>, (isq::width)>);
|
||||
static_assert(QuantityOf<quantity<m>, (isq::width)>);
|
||||
static_assert(QuantityOf<quantity<m>, (isq::position_vector)>);
|
||||
static_assert(QuantityOf<quantity<kind_of<(isq::length)>[m]>, (isq::width)>);
|
||||
static_assert(QuantityOf<quantity<kind_of<(isq::length)>[m]>, (isq::position_vector)>);
|
||||
static_assert(!QuantityOf<quantity<(isq::width[m])>, isq::altitude>);
|
||||
|
||||
static_assert(QuantityOf<quantity<isq::speed[m / s]>, isq::speed>);
|
||||
static_assert(QuantityOf<quantity<isq::speed[m / s]>, isq::length / isq::time>);
|
||||
static_assert(QuantityOf<quantity<(isq::speed[m / s])>, (isq::speed)>);
|
||||
static_assert(QuantityOf<quantity<(isq::speed[m / s])>, (isq::length) / (isq::time)>);
|
||||
static_assert(QuantityOf<quantity<m / s>, isq::length / isq::time>);
|
||||
static_assert(QuantityOf<quantity<kind_of<isq::speed>[m / s]>, isq::length / isq::time>);
|
||||
static_assert(!QuantityOf<quantity<isq::speed[m / s]>, isq::distance / isq::duration>);
|
||||
static_assert(!QuantityOf<quantity<isq::speed[m / s]>, isq::width / isq::duration>);
|
||||
static_assert(QuantityOf<quantity<kind_of<(isq::speed)>[m / s]>, (isq::length) / (isq::time)>);
|
||||
static_assert(!QuantityOf<quantity<(isq::speed[m / s])>, (isq::distance) / (isq::duration)>);
|
||||
static_assert(!QuantityOf<quantity<(isq::speed[m / s])>, (isq::width) / (isq::duration)>);
|
||||
static_assert(QuantityOf<quantity<m / s>, isq::width / isq::duration>);
|
||||
static_assert(QuantityOf<quantity<kind_of<isq::speed>[m / s]>, isq::width / isq::duration>);
|
||||
static_assert(!QuantityOf<quantity<isq::speed[m / s]>, isq::position_vector / isq::duration>);
|
||||
static_assert(QuantityOf<quantity<kind_of<(isq::speed)>[m / s]>, (isq::width) / (isq::duration)>);
|
||||
static_assert(!QuantityOf<quantity<(isq::speed[m / s])>, (isq::position_vector) / (isq::duration)>);
|
||||
static_assert(QuantityOf<quantity<m / s>, isq::position_vector / isq::duration>);
|
||||
static_assert(QuantityOf<quantity<kind_of<isq::speed>[m / s]>, isq::position_vector / isq::duration>);
|
||||
static_assert(QuantityOf<quantity<isq::velocity[m / s], int>, isq::position_vector / isq::duration>);
|
||||
static_assert(QuantityOf<quantity<kind_of<(isq::speed)>[m / s]>, isq::position_vector / isq::duration>);
|
||||
static_assert(QuantityOf<quantity<(isq::velocity)[m / s], int>, isq::position_vector / isq::duration>);
|
||||
|
||||
static_assert(QuantityOf<decltype(10 * m), isq::height>); // kind of
|
||||
static_assert(QuantityOf<decltype(10 * kind_of<isq::length>[m]), isq::height>); // kind of
|
||||
static_assert(!QuantityOf<decltype(10 * isq::length[m]), isq::height>); // different kinds
|
||||
static_assert(!QuantityOf<decltype(10 * isq::width[m]), isq::height>); // different kinds
|
||||
static_assert(QuantityOf<decltype(10 * isq::speed[m / s]), isq::speed>);
|
||||
static_assert(QuantityOf<decltype(20 * isq::length[m] / (2 * isq::time[s])), isq::speed>); // derived unnamed quantity
|
||||
static_assert(QuantityOf<decltype(10 * m), (isq::height)>); // kind of
|
||||
static_assert(QuantityOf<decltype(10 * kind_of<(isq::length)>[m]), (isq::height)>); // kind of
|
||||
static_assert(!QuantityOf<decltype(10 * (isq::length[m])), (isq::height)>); // different kinds
|
||||
static_assert(!QuantityOf<decltype(10 * (isq::width[m])), (isq::height)>); // different kinds
|
||||
static_assert(QuantityOf<decltype(10 * (isq::speed[m / s])), (isq::speed)>);
|
||||
static_assert(QuantityOf<decltype(20 * (isq::length[m]) / (2 * isq::time[s])), (isq::speed)>); // derived unnamed quantity
|
||||
|
||||
} // namespace
|
||||
|
||||
@@ -238,7 +238,7 @@ template<auto dim, auto unit>
|
||||
concept invalid_nu_unit = !requires { dim[unit]; };
|
||||
|
||||
static_assert(invalid_nu_unit<time, nu::second>);
|
||||
static_assert(invalid_nu_unit<nu::time, second>);
|
||||
static_assert(invalid_nu_unit<(nu::time), second>);
|
||||
static_assert(invalid_nu_unit<length / time, nu::second / nu::second>);
|
||||
static_assert(invalid_nu_unit<speed, nu::second / nu::second>);
|
||||
static_assert(invalid_nu_unit<speed, nu::second / second>);
|
||||
|
||||
@@ -65,7 +65,7 @@ concept can_not_be_prefixed = Unit<decltype(V1)> && !requires { typename prefix<
|
||||
|
||||
static_assert(can_not_be_prefixed<si::milli_, si::kilogram>);
|
||||
static_assert(can_not_be_prefixed<si::milli_, si::hectare>);
|
||||
static_assert(can_not_be_prefixed<si::milli_, si::kilo<si::metre>>);
|
||||
static_assert(can_not_be_prefixed<si::milli_, (si::kilo<(si::metre)>)>);
|
||||
static_assert(can_not_be_prefixed<si::milli_, si::metre / si::second>);
|
||||
static_assert(can_not_be_prefixed<si::milli_, mag_ratio<1, 60> * si::degree>);
|
||||
|
||||
|
||||
Reference in New Issue
Block a user