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

style: clang-format-16 applied to all the code base

Browse Source
This commit is contained in:
Mateusz Pusz
2023-03-29 17:05:02 +02:00
parent 60eaa4728d
commit 33d9f43b0f
17 changed files with 509 additions and 530 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
example/include/validated_type.h
View File

@@ -61,7 +61,7 @@ public:
{
}
constexpr explicit(false) operator T() const & noexcept(std::is_nothrow_copy_constructible_v<T>)
constexpr explicit(false) operator T() const& noexcept(std::is_nothrow_copy_constructible_v<T>)
requires std::copyable<T>
{
return value_;

16
src/core/include/units/bits/basic_concepts.h
View File

@@ -217,14 +217,13 @@ struct point_origin;
* Satisfied by types derived from an specialization of @c point_origin.
*/
template<typename T>
concept PointOrigin = is_derived_from_specialization_of<T, point_origin> &&
requires {
concept PointOrigin = is_derived_from_specialization_of<T, point_origin> && requires {
typename T::dimension;
requires Dimension<typename T::dimension>;
typename T::point_origin;
requires std::same_as<typename T::point_origin, point_origin<typename T::dimension>>;
requires !std::same_as<T, point_origin<typename T::dimension>>;
};
};
// RebindablePointOriginFor
@@ -264,7 +263,7 @@ concept kind_impl_ = is_derived_from_specialization_of<T, Base> && requires {
typename T::base_kind;
typename T::dimension;
requires Dimension<typename T::dimension>;
};
};
/**
* @brief A concept matching all kind types
@@ -389,12 +388,12 @@ concept QuantityPointLike = detail::is_quantity_point_like<T>;
template<typename T, typename U>
concept common_type_with_ = // exposition only
(std::same_as<std::common_type_t<T, U>, std::common_type_t<U, T>>) &&
(std::constructible_from<std::common_type_t<T, U>, T>) && (std::constructible_from<std::common_type_t<T, U>, U>);
(std::same_as<std::common_type_t<T, U>, std::common_type_t<U, T>>)&&(
std::constructible_from<std::common_type_t<T, U>, T>)&&(std::constructible_from<std::common_type_t<T, U>, U>);
template<typename T, typename U = T>
concept scalable_number_ = // exposition only
(std::regular_invocable<std::multiplies<>, T, U>) && (std::regular_invocable<std::divides<>, T, U>);
(std::regular_invocable<std::multiplies<>, T, U>)&&(std::regular_invocable<std::divides<>, T, U>);
template<typename T>
concept castable_number_ = // exposition only
@@ -443,8 +442,7 @@ concept wrapped_quantity_ = // exposition only
* Satisfied by types that satisfy `(!Quantity<T>) && (!WrappedQuantity<T>) && std::regular<T>`.
*/
template<typename T>
concept Representation = (!Quantity<T>) && (!QuantityLike<T>) &&
(!wrapped_quantity_<T>) && std::regular<T> && scalable_<T>;
concept Representation = (!Quantity<T>)&&(!QuantityLike<T>)&&(!wrapped_quantity_<T>)&&std::regular<T> && scalable_<T>;
namespace detail {

6
src/core/include/units/magnitude.h
View File

@@ -313,11 +313,9 @@ struct pairwise_all {
}(sizeof...(Ts));
// Compare zero or more pairs of neighbours as needed.
return [this]<std::size_t... Is>(std::tuple<Ts...> && t, std::index_sequence<Is...>)
{
return [this]<std::size_t... Is>(std::tuple<Ts...>&& t, std::index_sequence<Is...>) {
return (predicate(std::get<Is>(t), std::get<Is + 1>(t)) && ...);
}
(std::make_tuple(std::forward<Ts>(ts)...), std::make_index_sequence<num_comparisons>());
}(std::make_tuple(std::forward<Ts>(ts)...), std::make_index_sequence<num_comparisons>());
}
};

6
src/core/include/units/math.h
View File

@@ -308,8 +308,7 @@ template<Quantity To, std::same_as<typename To::dimension> D, typename U, std::s
*/
template<Quantity Q1, Quantity Q2>
[[nodiscard]] inline std::common_type_t<Q1, Q2> hypot(const Q1& x, const Q2& y) noexcept
requires requires { typename std::common_type_t<Q1, Q2>; } &&
requires(std::common_type_t<Q1, Q2> q) {
requires requires { typename std::common_type_t<Q1, Q2>; } && requires(std::common_type_t<Q1, Q2> q) {
requires requires { hypot(q.number(), q.number()); } || requires { std::hypot(q.number(), q.number()); };
}
{
@@ -326,8 +325,7 @@ template<Quantity Q1, Quantity Q2>
*/
template<Quantity Q1, Quantity Q2, Quantity Q3>
[[nodiscard]] inline std::common_type_t<Q1, Q2, Q3> hypot(const Q1& x, const Q2& y, const Q3& z) noexcept
requires requires { typename std::common_type_t<Q1, Q2, Q3>; } &&
requires(std::common_type_t<Q1, Q2, Q3> q) {
requires requires { typename std::common_type_t<Q1, Q2, Q3>; } && requires(std::common_type_t<Q1, Q2, Q3> q) {
requires requires { hypot(q.number(), q.number(), q.number()); } ||
requires { std::hypot(q.number(), q.number(), q.number()); };
}

14
src/core/include/units/quantity.h
View File

@@ -51,8 +51,8 @@ inline constexpr auto make_quantity = [](auto&& v) {
template<typename T>
concept quantity_one =
Quantity<T> &&
(std::same_as<typename T::dimension, dim_one> || std::same_as<typename T::dimension, unknown_dimension<>>) &&
detail::equivalent_unit<typename T::unit, typename T::dimension, ::units::one, typename T::dimension>::value;
(std::same_as<typename T::dimension, dim_one> || std::same_as<typename T::dimension, unknown_dimension<>>)&&detail::
equivalent_unit<typename T::unit, typename T::dimension, ::units::one, typename T::dimension>::value;
} // namespace detail
@@ -62,7 +62,7 @@ concept floating_point_ = // exposition only
template<typename From, typename To>
concept safe_convertible_to_ = // exposition only
(!Quantity<From>) && (!Quantity<To>) && std::convertible_to<From, To> &&
(!Quantity<From>)&&(!Quantity<To>)&&std::convertible_to<From, To> &&
(floating_point_<To> || (!floating_point_<From>));
// QFrom ratio is an exact multiple of QTo
@@ -84,7 +84,7 @@ concept invoke_result_convertible_to_ =
Representation<T> && quantity_value_for_<Func, U, V> && safe_convertible_to_<T, std::invoke_result_t<Func, U, V>>;
template<typename Func, typename Q, typename V>
concept have_quantity_for_ = Quantity<Q> && (!Quantity<V>) && quantity_value_for_<Func, typename Q::rep, V>;
concept have_quantity_for_ = Quantity<Q> && (!Quantity<V>)&&quantity_value_for_<Func, typename Q::rep, V>;
template<QuantityLike Q>
using quantity_like_type = quantity<typename quantity_like_traits<Q>::dimension, typename quantity_like_traits<Q>::unit,
@@ -445,14 +445,14 @@ public:
// CTAD
#if !UNITS_COMP_CLANG || UNITS_COMP_CLANG > 17
template<typename D, typename U, typename Rep>
explicit(false) quantity(Rep&&)->quantity<D, U, Rep>;
explicit(false) quantity(Rep&&) -> quantity<D, U, Rep>;
#endif
template<typename D, typename U, typename Rep>
explicit(false) quantity(quantity<D, U, Rep>)->quantity<D, U, Rep>;
explicit(false) quantity(quantity<D, U, Rep>) -> quantity<D, U, Rep>;
template<Representation Rep>
explicit(false) quantity(Rep)->quantity<dim_one, one, Rep>;
explicit(false) quantity(Rep) -> quantity<dim_one, one, Rep>;
template<QuantityLike Q>
explicit quantity(Q) -> quantity<typename quantity_like_traits<Q>::dimension, typename quantity_like_traits<Q>::unit,

2
src/core/include/units/symbol_text.h
View File

@@ -162,7 +162,7 @@ struct basic_symbol_text {
}
};
basic_symbol_text(char)->basic_symbol_text<char, 1, 1>;
basic_symbol_text(char) -> basic_symbol_text<char, 1, 1>;
template<typename StandardCharT>
basic_symbol_text(StandardCharT, char) -> basic_symbol_text<StandardCharT, 1, 1>;

4
src/core/include/units/unit.h
View File

@@ -211,7 +211,7 @@ template<typename U, typename P, typename AU>
void is_named_impl(const volatile prefixed_alias_unit<U, P, AU>*);
template<Unit U>
inline constexpr bool is_named<U> = requires(U * u) { is_named_impl(u); };
inline constexpr bool is_named<U> = requires(U* u) { is_named_impl(u); };
template<typename Child, basic_symbol_text Symbol>
void can_be_prefixed_impl(const volatile named_unit<Child, Symbol>*);
@@ -223,7 +223,7 @@ template<typename U, basic_symbol_text Symbol>
void can_be_prefixed_impl(const volatile alias_unit<U, Symbol>*);
template<Unit U>
inline constexpr bool can_be_prefixed<U> = requires(U * u) { can_be_prefixed_impl(u); };
inline constexpr bool can_be_prefixed<U> = requires(U* u) { can_be_prefixed_impl(u); };
template<Magnitude auto M, typename U>
inline constexpr bool can_be_prefixed<scaled_unit<M, U>> = can_be_prefixed<typename U::reference>;

4
test/unit_test/runtime/almost_equals.h
View File

@@ -31,8 +31,8 @@ struct AlmostEqualsMatcher : Catch::Matchers::MatcherGenericBase {
AlmostEqualsMatcher(const T& target) : target_{target} {}
template<QuantityEquivalentTo<T> U>
requires std::same_as<typename T::rep, typename U::rep> && treat_as_floating_point<typename T::rep> bool
match(const U& other) const
requires std::same_as<typename T::rep, typename U::rep> && treat_as_floating_point<typename T::rep>
bool match(const U& other) const
{
using std::abs;
using common = std::common_type_t<T, U>;

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

@@ -222,7 +222,7 @@ concept invalid_member_operations = requires(length<metre, Rep> lhs) {
requires !requires(length<metre, int> rhs) { lhs >= rhs; };
requires !requires(std::ostream os) { os << lhs; };
};
};
static_assert(invalid_member_operations<min_expl<>>);
// equality

27
test/unit_test/static/quantity_kind_test.cpp
View File

@@ -110,8 +110,7 @@ static_assert(sizeof(width<metre, double>) == sizeof(double));
static_assert(sizeof(height<metre, short>) == sizeof(short));
template<typename Width>
concept invalid_types =
requires {
concept invalid_types = requires {
requires !requires { typename quantity_kind<Width, second, int>; }; // unit of a different dimension
requires !requires { typename quantity_kind<Width, metre, length<metre>>; }; // quantity used as Rep
requires !requires { // quantity point used as Rep
@@ -120,7 +119,7 @@ concept invalid_types =
requires !requires { typename quantity_kind<Width, metre, width<metre>>; }; // quantity kind used as Rep
requires !requires { typename quantity_kind<metre, Width, double>; }; // reordered arguments
requires !requires { typename quantity_kind<metre, double, Width>; }; // reordered arguments
};
};
static_assert(invalid_types<width_kind>);
static_assert(std::is_trivially_default_constructible_v<width<metre>>);
@@ -442,10 +441,9 @@ concept invalid_compound_assignments_ = requires(quantity_kind<K, U, int> w, Qx
requires !requires { w *= q; };
requires !requires { w /= q; };
requires !requires { w %= q; };
};
};
template<typename Width>
concept invalid_compound_assignments =
requires(quantity_kind<Width, metre, int> w, height<metre, int> h) {
concept invalid_compound_assignments = requires(quantity_kind<Width, metre, int> w, height<metre, int> h) {
requires !requires { w += 1; };
requires !requires { w -= 1; };
requires !requires { w *= 1 * (km / m); };
@@ -469,7 +467,7 @@ concept invalid_compound_assignments =
requires invalid_compound_assignments_<Width, metre, horizontal_area<square_metre, int>>;
requires invalid_compound_assignments_<Width, metre, quantity_point<dynamic_origin<dim_length>, metre, int>>;
requires invalid_compound_assignments_<Width, metre, std::chrono::seconds>;
};
};
static_assert(invalid_compound_assignments<width_kind>);
static_assert(invalid_compound_assignments_<time_kind, second, std::chrono::seconds>);
@@ -738,7 +736,7 @@ concept invalid_equality = requires(quantity_kind<Width, metre, int> w) {
requires !requires { w == quantity_point(1.0 * mm); };
requires !requires { w != quantity_point(quantity(1)); };
requires !requires { w == quantity_point(dimensionless<percent>(1.0)); };
};
};
static_assert(invalid_equality<width_kind>);
static_assert(width<metre, int>(1 * m) < width<metre, int>(2 * m));
@@ -768,7 +766,7 @@ concept invalid_relational = requires(quantity_kind<Width, metre, int> w) {
requires !requires { w >= quantity_point(1.0 * mm); };
requires !requires { w > quantity_point(quantity(1)); };
requires !requires { w <=> quantity_point(dimensionless<percent>(1.0)); };
};
};
static_assert(invalid_relational<width_kind>);
@@ -807,8 +805,7 @@ static_assert(same(quantity_kind_cast<length<centimetre, int>>(width<metre, doub
static_assert(same(quantity_kind_cast<length<centimetre, int>>(width<cgs::centimetre, int>(1 * cgs_cm)), width<cgs::centimetre, int>(1 * cgs_cm)));
// clang-format on
template<typename Width>
concept invalid_cast =
requires {
concept invalid_cast = requires {
requires !requires { quantity_kind_cast<apples<one, int>>(quantity_kind<Width, metre, int>(1 * m)); };
requires !requires {
quantity_kind_cast<horizontal_area<square_metre, int>>(quantity_kind<Width, metre, int>(1 * m));
@@ -830,14 +827,12 @@ concept invalid_cast =
requires !requires { quantity_kind_cast<square_metre>(quantity_kind<Width, metre, int>(1 * m)); };
requires !requires { quantity_kind_cast<second>(quantity_kind<Width, metre, int>(1 * m)); };
requires !requires {
quantity_kind_cast<quantity_point<dynamic_origin<dim_length>, metre, int>>(
quantity_kind<Width, metre, int>(1 * m));
quantity_kind_cast<quantity_point<dynamic_origin<dim_length>, metre, int>>(quantity_kind<Width, metre, int>(1 * m));
};
requires !requires {
quantity_kind_cast<quantity_point<dynamic_origin<dim_one>, one, int>>(
quantity_kind<Width, metre, int>(1 * m));
};
quantity_kind_cast<quantity_point<dynamic_origin<dim_one>, one, int>>(quantity_kind<Width, metre, int>(1 * m));
};
};
static_assert(invalid_cast<width_kind>);

30
test/unit_test/static/quantity_point_kind_test.cpp
View File

@@ -150,8 +150,7 @@ static_assert(sizeof(abscissa<metre, double>) == sizeof(double));
static_assert(sizeof(ordinate<metre, short>) == sizeof(short));
template<typename Width, typename Abscissa>
concept invalid_types =
requires {
concept invalid_types = requires {
requires !requires { typename quantity_point_kind<Width, metre, int>; }; // width_kind is not a point kind
requires !requires { typename quantity_point_kind<Abscissa, second, int>; }; // unit of a different dimension
requires !requires { typename quantity_point_kind<Abscissa, metre, length<metre>>; }; // quantity used as Rep
@@ -164,7 +163,7 @@ concept invalid_types =
}; // quantity point kind used as Rep
requires !requires { typename quantity_point_kind<metre, Abscissa, double>; }; // reordered arguments
requires !requires { typename quantity_point_kind<metre, double, Abscissa>; }; // reordered arguments
};
};
static_assert(invalid_types<width_kind, abscissa_kind>);
static_assert(std::is_trivially_default_constructible_v<abscissa<metre>>);
@@ -476,10 +475,9 @@ template<typename PK, typename U, typename Qx>
concept invalid_compound_assignments_ = requires(quantity_point_kind<PK, U, int> x, Qx q) {
requires !requires { x += q; };
requires !requires { x -= q; };
};
};
template<typename Abscissa>
concept invalid_compound_assignments =
requires(quantity_point_kind<Abscissa, metre, int> x) {
concept invalid_compound_assignments = requires(quantity_point_kind<Abscissa, metre, int> x) {
requires !requires { x += 1; };
requires !requires { x -= 1; };
requires invalid_compound_assignments_<Abscissa, metre, length<metre, int>>;
@@ -487,7 +485,7 @@ concept invalid_compound_assignments =
requires invalid_compound_assignments_<Abscissa, metre, rate_of_climb<metre_per_second, int>>;
requires invalid_compound_assignments_<Abscissa, metre, quantity_point<dynamic_origin<dim_length>, metre, int>>;
requires invalid_compound_assignments_<Abscissa, metre, std::chrono::seconds>;
};
};
static_assert(invalid_compound_assignments<abscissa_kind>);
static_assert(invalid_compound_assignments_<time_point_kind, second, std::chrono::seconds>);
#if __cpp_lib_chrono >= 201907L
@@ -583,7 +581,7 @@ concept invalid_equality = requires(quantity_point_kind<abscissa_kind, metre, In
requires !requires { x != quantity_point_kind(cgs_width<metre, int>(1 * m)); };
requires !requires { x == ordinate<metre, int>(1 * m); };
requires !requires { screen_si_width<metre, Int>{} != screen_si_cgs_width<metre, Int>{}; };
};
};
static_assert(invalid_equality<int>);
// clang-format off
@@ -599,8 +597,7 @@ static_assert(std::three_way_comparable_with<abscissa<cgs::centimetre, int>, abs
static_assert(std::three_way_comparable_with<abscissa<metre>, abscissa<cgs::centimetre>>);
// clang-format on
template<typename Int>
concept invalid_relational =
requires(quantity_point_kind<abscissa_kind, metre, Int> x, Int i) {
concept invalid_relational = requires(quantity_point_kind<abscissa_kind, metre, Int> x, Int i) {
requires !requires { x < 1; };
requires !requires { x <= 1.0; };
requires !requires { x >= 1 * m; };
@@ -620,7 +617,7 @@ concept invalid_relational =
requires !requires { x <= quantity_point_kind(cgs_width<metre, int>(1 * m)); };
requires !requires { x >= ordinate<metre, int>(1 * m); };
requires !requires { screen_si_width<metre, Int>{} > screen_si_cgs_width<metre, Int>{}; };
};
};
static_assert(invalid_relational<int>);
@@ -672,8 +669,7 @@ static_assert(comp(quantity_point_kind_cast<length<centimetre, int>>(abscissa<cg
static_assert(same(quantity_point_kind_cast<screen_si_cgs_width<metre, int>>(screen_si_width<metre, int>(1 * m)), screen_si_cgs_width<metre, int>(1 * m)));
// clang-format on
template<typename Int>
concept invalid_cast =
requires(Int i) {
concept invalid_cast = requires(Int i) {
requires !requires { quantity_point_kind_cast<apples<one, Int>>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<rate_of_climb<metre_per_second, Int>>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<apple>(abscissa<metre, Int>(i * m)); };
@@ -689,18 +685,16 @@ concept invalid_cast =
requires !requires { quantity_point_kind_cast<square_metre>(abscissa<metre, Int>(i * m)); };
requires !requires { quantity_point_kind_cast<second>(abscissa<metre, Int>(i * m)); };
requires !requires {
quantity_point_kind_cast<quantity_point<dynamic_origin<dim_length>, metre, Int>>(
abscissa<metre, Int>(i * m));
quantity_point_kind_cast<quantity_point<dynamic_origin<dim_length>, metre, Int>>(abscissa<metre, Int>(i * m));
};
requires !requires {
quantity_point_kind_cast<quantity_point<dynamic_origin<dim_one>, one, Int>>(
abscissa<metre, Int>(i * m));
quantity_point_kind_cast<quantity_point<dynamic_origin<dim_one>, one, Int>>(abscissa<metre, Int>(i * m));
};
requires !requires {
quantity_point_kind_cast<quantity_point<dynamic_origin<dim_length>, metre, Int>>(
screen_si_width<metre, Int>(i * m));
};
};
};
static_assert(invalid_cast<int>);

15
test/unit_test/static/quantity_point_test.cpp
View File

@@ -46,22 +46,20 @@ struct sea_level_origin : point_origin<dim_length> {};
// class invariants
template<typename DimLength>
concept invalid_types =
requires {
concept invalid_types = requires {
// unit of a different dimension:
requires !requires { typename quantity_point<dynamic_origin<DimLength>, second, int>; };
// quantity used as Rep:
requires !requires { typename quantity_point<dynamic_origin<DimLength>, metre, quantity<DimLength, metre, int>>; };
// quantity point used as Rep:
requires !requires {
typename quantity_point<dynamic_origin<DimLength>, metre,
quantity_point<dynamic_origin<DimLength>, metre, int>>;
typename quantity_point<dynamic_origin<DimLength>, metre, quantity_point<dynamic_origin<DimLength>, metre, int>>;
};
// reordered arguments:
requires !requires { typename quantity_point<metre, dynamic_origin<DimLength>, double>; };
// dimension used as origin:
requires !requires { typename quantity_point<DimLength, second, int>; };
};
};
static_assert(invalid_types<dim_length>);
@@ -239,7 +237,7 @@ concept invalid_comparisons = requires(quantity_point<dynamic_origin<dim_length>
quantity_point<sea_level_origin, metre, Int> rhs) {
requires !requires { lhs == rhs; };
requires !requires { lhs < rhs; };
};
};
static_assert(invalid_comparisons<int>);
// alias units
@@ -295,8 +293,7 @@ static_assert(
quantity_point_cast<dim_speed, kilometre_per_hour>(quantity_point(2000.0_q_m / 3600.0_q_s)).relative().number() == 2);
template<typename Int>
concept invalid_cast =
requires(Int i) {
concept invalid_cast = requires(Int i) {
requires !requires {
quantity_point_cast<quantity_point<dynamic_origin<dim_time>, second, Int>>(quantity_point(i * m));
};
@@ -304,7 +301,7 @@ concept invalid_cast =
quantity_point_cast<quantity_point<dynamic_origin<dim_length>, metre, Int>>(
quantity_point<sea_level_origin, metre, Int>(i * m));
};
};
};
static_assert(invalid_cast<int>);
// time

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

@@ -62,7 +62,7 @@ concept invalid_types = requires {
requires !requires { typename Q<dim_length, metre, length<metre>>; }; // quantity used as Rep
requires !requires { typename Q<metre, dim_length, double>; }; // reordered arguments
requires !requires { typename Q<metre, double, dim_length>; }; // reordered arguments
};
};
static_assert(invalid_types<quantity>);
#endif
@@ -408,8 +408,7 @@ static_assert((22_q_m /= quantity(3.33)).number() == 6);
#endif
template<typename Metre, typename Kilometre>
concept invalid_compound_assignments =
requires() {
concept invalid_compound_assignments = requires() {
// truncating not allowed
requires !requires(length<Metre, int> l) { l += 2.5_q_m; };
requires !requires(length<Metre, int> l) { l -= 2.5_q_m; };
@@ -445,7 +444,7 @@ concept invalid_compound_assignments =
requires !requires(length<Metre, int> l) { l *= m; };
requires !requires(length<Metre, int> l) { l /= m; };
requires !requires(length<Metre, int> l) { l %= m; };
};
};
static_assert(invalid_compound_assignments<metre, kilometre>);
@@ -474,7 +473,7 @@ concept invalid_binary_operations = requires {
requires !requires { m + length<Metre, int>(1); };
requires !requires { m - length<Metre, int>(1); };
requires !requires { m % length<Metre, int>(1); };
};
};
static_assert(invalid_binary_operations<metre>);
// same representation type
@@ -727,7 +726,7 @@ template<typename Metre>
concept no_crossdimensional_equality = requires {
requires !requires { 1_q_s == length<Metre, int>(1); };
requires !requires { 1_q_s != length<Metre, int>(1); };
};
};
static_assert(no_crossdimensional_equality<metre>);
// same type
@@ -765,7 +764,7 @@ concept no_crossdimensional_ordering = requires {
requires !requires { 1_q_s > length<Metre, int>(1); };
requires !requires { 1_q_s <= length<Metre, int>(1); };
requires !requires { 1_q_s >= length<Metre, int>(1); };
};
};
static_assert(no_crossdimensional_ordering<metre>);
// same type
@@ -839,7 +838,7 @@ template<typename Int>
concept invalid_dimensionless_operations = requires {
requires !requires(dimensionless<percent, Int> d) { 1 + d; };
requires !requires(dimensionless<percent, Int> d) { d + 1; };
};
};
static_assert(invalid_dimensionless_operations<int>);
static_assert(compare<decltype(10_q_km / 5_q_km), quantity<dim_one, one, std::int64_t>>);

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

@@ -54,7 +54,7 @@ concept invalid_operations = requires {
requires !requires { 1_q_s - s; };
requires !requires { 1_q_s * s; };
requires !requires { 1_q_s / s; };
};
};
static_assert(invalid_operations<s>);
static_assert(2_q_m / (1 * s) == 2_q_m_per_s);