feedc0de/mp-units
1
0
Fork 0
forked from mpusz/mp-units
Code Pull Requests Activity

style: clang-format applied to the remaining files

Browse Source
This commit is contained in:
Mateusz Pusz
2022-04-02 21:36:42 +02:00
parent 0dca41b5ae
commit b221dace3f
109 changed files with 4546 additions and 3140 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -58,11 +58,11 @@ static_assert(sizeof(length<metre, short>) == sizeof(short));
#if UNITS_COMP_GCC != 10 || UNITS_COMP_GCC_MINOR > 2
template<template<typename, typename, typename> typename Q>
concept invalid_types = requires {
requires !requires { typename Q<dim_length, second, int>; }; // unit of a different dimension
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
};
requires !requires { typename Q<dim_length, second, int>; }; // unit of a different dimension
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
@@ -128,7 +128,8 @@ static_assert(!std::convertible_to<double, length<metre>>);
static_assert(std::constructible_from<length<metre>, float>);
static_assert(!std::convertible_to<float, length<metre>>);
static_assert(std::constructible_from<length<metre, float>, double>); // truncating implicit conversions double -> float allowed
static_assert(
std::constructible_from<length<metre, float>, double>); // truncating implicit conversions double -> float allowed
static_assert(!std::convertible_to<double, length<metre, float>>);
static_assert(std::constructible_from<length<metre>, int>);
@@ -137,7 +138,8 @@ static_assert(!std::convertible_to<int, length<metre>>);
static_assert(std::constructible_from<length<metre>, short>);
static_assert(!std::convertible_to<short, length<metre>>);
static_assert(std::constructible_from<length<metre, short>, int>); // truncating implicit conversions int -> short allowed
static_assert(
std::constructible_from<length<metre, short>, int>); // truncating implicit conversions int -> short allowed
static_assert(!std::convertible_to<int, length<metre, short>>);
// exception, implicit construction from a value allowed for a dimensionless quantity
@@ -166,7 +168,8 @@ static_assert(!std::convertible_to<double, dimensionless<percent>>);
static_assert(std::constructible_from<dimensionless<percent>, float>);
static_assert(!std::convertible_to<float, dimensionless<percent>>);
static_assert(std::constructible_from<dimensionless<percent, float>, double>); // truncating implicit conversions double -> float allowed
static_assert(std::constructible_from<dimensionless<percent, float>,
double>); // truncating implicit conversions double -> float allowed
static_assert(!std::convertible_to<double, dimensionless<percent, float>>);
static_assert(std::constructible_from<dimensionless<percent>, int>);
@@ -175,7 +178,8 @@ static_assert(!std::convertible_to<int, dimensionless<percent>>);
static_assert(std::constructible_from<dimensionless<percent>, short>);
static_assert(!std::convertible_to<short, dimensionless<percent>>);
static_assert(std::constructible_from<dimensionless<percent, short>, int>); // truncating implicit conversions int -> short allowed
static_assert(
std::constructible_from<dimensionless<percent, short>, int>); // truncating implicit conversions int -> short allowed
static_assert(!std::convertible_to<int, dimensionless<percent, short>>);
// floating-point to integral truncating conversion not allowed
@@ -185,7 +189,7 @@ static_assert(!std::convertible_to<double, length<metre, int>>);
static_assert(!std::constructible_from<dimensionless<one, int>, double>);
static_assert(!std::convertible_to<double, dimensionless<one, int>>);
static_assert(length<metre, int>().number() == 0); // value initialization
static_assert(length<metre, int>().number() == 0); // value initialization
static_assert(length<metre, int>(1).number() == 1);
static_assert(length<metre, double>(1.0).number() == 1.0);
static_assert(length<metre, double>(1).number() == 1.0);
@@ -212,16 +216,18 @@ static_assert(!std::convertible_to<speed<metre_per_second>, length<metre>>);
// implicit conversion from another quantity only if non-truncating
static_assert(std::constructible_from<length<metre>, length<metre, int>>); // int -> double OK
static_assert(std::convertible_to<length<metre, int>, length<metre>>); // int -> double OK
static_assert(std::convertible_to<length<metre, int>, length<metre>>); // int -> double OK
static_assert(!std::constructible_from<length<metre, int>, length<metre>>); // truncating double -> int not allowed
static_assert(!std::convertible_to<length<metre>, length<metre, int>>); // truncating double -> int not allowed
static_assert(!std::convertible_to<length<metre>, length<metre, int>>); // truncating double -> int not allowed
static_assert(std::constructible_from<length<metre, int>, length<kilometre, int>>); // kilometre<int> -> metre<int> OK
static_assert(std::convertible_to<length<kilometre, int>, length<metre, int>>); // kilometre<int> -> metre<int> OK
static_assert(std::convertible_to<length<kilometre, int>, length<metre, int>>); // kilometre<int> -> metre<int> OK
static_assert(!std::constructible_from<length<kilometre, int>, length<metre, int>>); // truncating metre<int> -> kilometre<int> not allowed
static_assert(!std::convertible_to<length<metre, int>, length<kilometre, int>>); // truncating metre<int> -> kilometre<int> not allowed
static_assert(!std::constructible_from<length<kilometre, int>,
length<metre, int>>); // truncating metre<int> -> kilometre<int> not allowed
static_assert(!std::convertible_to<length<metre, int>,
length<kilometre, int>>); // truncating metre<int> -> kilometre<int> not allowed
// converting to double always OK
static_assert(std::constructible_from<length<metre>, length<kilometre, int>>);
@@ -249,13 +255,21 @@ struct derived_quantity : quantity<typename Q::dimension, typename Q::unit, Rep>
constexpr explicit(!std::is_trivial_v<Rep>) derived_quantity(const R& t) : R(t) {}
constexpr explicit(!std::is_trivial_v<Rep>) derived_quantity(R&& t) : R(std::move(t)) {}
constexpr derived_quantity& operator=(const R& t) { R::operator=(t); return *this; }
constexpr derived_quantity& operator=(R&& t) { R::operator=(std::move(t)); return *this; }
constexpr derived_quantity& operator=(const R& t)
{
R::operator=(t);
return *this;
}
constexpr derived_quantity& operator=(R&& t)
{
R::operator=(std::move(t));
return *this;
}
constexpr operator R&() & noexcept { return *this; }
constexpr operator const R&() const & noexcept { return *this; }
constexpr operator const R&() const& noexcept { return *this; }
constexpr operator R&&() && noexcept { return *this; }
constexpr operator const R&&() const && noexcept { return *this; }
constexpr operator const R&&() const&& noexcept { return *this; }
};
static_assert(detail::is_quantity<derived_quantity<double, si::length<metre>, "NTTP type description">>);
@@ -290,8 +304,16 @@ static_assert(is_same_v<decltype(quantity{1.23}), dimensionless<one, double>>);
// assignment operator
////////////////////////
static_assert([]() { length<metre, int> l1(1), l2(2); return l2 = l1; }().number() == 1);
static_assert([]() { length<metre, int> l1(1), l2(2); return l2 = std::move(l1); }().number() == 1);
static_assert([]() {
length<metre, int> l1(1), l2(2);
return l2 = l1;
}()
.number() == 1);
static_assert([]() {
length<metre, int> l1(1), l2(2);
return l2 = std::move(l1);
}()
.number() == 1);
////////////////////
@@ -303,10 +325,22 @@ static_assert((-123_q_m).number() == -123);
static_assert((+(-123_q_m)).number() == -123);
static_assert((-(-123_q_m)).number() == 123);
static_assert([](auto v) { auto vv = v++; return std::pair(v, vv); }(123_q_m) == std::pair(124_q_m, 123_q_m));
static_assert([](auto v) { auto vv = ++v; return std::pair(v, vv); }(123_q_m) == std::pair(124_q_m, 124_q_m));
static_assert([](auto v) { auto vv = v--; return std::pair(v, vv); }(123_q_m) == std::pair(122_q_m, 123_q_m));
static_assert([](auto v) { auto vv = --v; return std::pair(v, vv); }(123_q_m) == std::pair(122_q_m, 122_q_m));
static_assert([](auto v) {
auto vv = v++;
return std::pair(v, vv);
}(123_q_m) == std::pair(124_q_m, 123_q_m));
static_assert([](auto v) {
auto vv = ++v;
return std::pair(v, vv);
}(123_q_m) == std::pair(124_q_m, 124_q_m));
static_assert([](auto v) {
auto vv = v--;
return std::pair(v, vv);
}(123_q_m) == std::pair(122_q_m, 123_q_m));
static_assert([](auto v) {
auto vv = --v;
return std::pair(v, vv);
}(123_q_m) == std::pair(122_q_m, 122_q_m));
static_assert(is_same_v<decltype((+(short{0} * m)).number()), int&&>);
@@ -337,15 +371,32 @@ static_assert((2.5_q_m *= quantity(3)).number() == 7.5);
static_assert((7.5_q_m /= quantity(3)).number() == 2.5);
static_assert((3500_q_m %= 1_q_km).number() == 500);
static_assert((std::uint8_t(255) * m %= 256).number() == [] { std::uint8_t ui(255); return ui %= 256; }());
static_assert((std::uint8_t(255) * m %= quantity(256)).number() == [] { std::uint8_t ui(255); return ui %= 256; }());
// static_assert((std::uint8_t(255) * m %= 256 * m).number() != [] { std::uint8_t ui(255); return ui %= 256; }()); // UB
static_assert((std::uint8_t(255) * m %= 257).number() == [] { std::uint8_t ui(255); return ui %= 257; }());
static_assert((std::uint8_t(255) * m %= quantity(257)).number() == [] { std::uint8_t ui(255); return ui %= 257; }());
static_assert((std::uint8_t(255) * m %= 256).number() == [] {
std::uint8_t ui(255);
return ui %= 256;
}());
static_assert((std::uint8_t(255) * m %= quantity(256)).number() == [] {
std::uint8_t ui(255);
return ui %= 256;
}());
// static_assert((std::uint8_t(255) * m %= 256 * m).number() != [] { std::uint8_t ui(255); return ui %= 256; }()); //
// UB
static_assert((std::uint8_t(255) * m %= 257).number() == [] {
std::uint8_t ui(255);
return ui %= 257;
}());
static_assert((std::uint8_t(255) * m %= quantity(257)).number() == [] {
std::uint8_t ui(255);
return ui %= 257;
}());
// TODO: Fix
static_assert((std::uint8_t(255) * m %= 257 * m).number() != [] { std::uint8_t ui(255); return ui %= 257; }());
static_assert((std::uint8_t(255) * m %= 257 * m).number() != [] {
std::uint8_t ui(255);
return ui %= 257;
}());
#ifndef UNITS_COMP_MSVC // TODO ICE (https://developercommunity2.visualstudio.com/t/ICE-on-a-constexpr-operator-in-mp-unit/1302907)
#ifndef UNITS_COMP_MSVC // TODO ICE
// (https://developercommunity2.visualstudio.com/t/ICE-on-a-constexpr-operator-in-mp-unit/1302907)
// next two lines trigger conversions warnings
// (warning disabled in CMake for this file)
static_assert((22_q_m *= 33.33).number() == 733);
@@ -355,43 +406,44 @@ static_assert((22_q_m /= quantity(3.33)).number() == 6);
#endif
template<typename Metre, typename Kilometre>
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; };
requires !requires(length<Kilometre, int> l) { l += length<Metre, int>(2); };
requires !requires(length<Kilometre, int> l) { l -= length<Metre, int>(2); };
requires !requires(length<Kilometre, int> l) { l %= length<Metre, int>(2); };
requires !requires(length<Kilometre, int> l) { l %= dimensionless<percent, int>(2); };
requires !requires(length<Kilometre, int> l) { l %= dimensionless<percent, double>(2); };
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; };
requires !requires(length<Kilometre, int> l) { l += length<Metre, int>(2); };
requires !requires(length<Kilometre, int> l) { l -= length<Metre, int>(2); };
requires !requires(length<Kilometre, int> l) { l %= length<Metre, int>(2); };
requires !requires(length<Kilometre, int> l) { l %= dimensionless<percent, int>(2); };
requires !requires(length<Kilometre, int> l) { l %= dimensionless<percent, double>(2); };
// TODO: accept non-truncating argument
requires !requires(length<Kilometre, int> l) { l *= 1 * (km / m); };
requires !requires(length<Kilometre, int> l) { l /= 1 * (km / m); };
requires !requires(length<Kilometre, int> l) { l %= 1 * (km / m); };
// TODO: accept non-truncating argument
requires !requires(length<Kilometre, int> l) { l *= 1 * (km / m); };
requires !requires(length<Kilometre, int> l) { l /= 1 * (km / m); };
requires !requires(length<Kilometre, int> l) { l %= 1 * (km / m); };
// only quantities can be added or subtracted
requires !requires(length<Metre, int> l) { l += 2; };
requires !requires(length<Metre, int> l) { l -= 2; };
// only quantities can be added or subtracted
requires !requires(length<Metre, int> l) { l += 2; };
requires !requires(length<Metre, int> l) { l -= 2; };
// compound multiply/divide by another quantity not allowed
requires !requires(length<Metre, int> l) { l *= 2_q_m; };
requires !requires(length<Metre, int> l) { l /= 2_q_m; };
// compound multiply/divide by another quantity not allowed
requires !requires(length<Metre, int> l) { l *= 2_q_m; };
requires !requires(length<Metre, int> l) { l /= 2_q_m; };
// modulo operations on a floating point representation not allowed
requires !requires(length<Metre, double> l) { l %= 2.; };
requires !requires(length<Metre, double> l) { l %= 2; };
requires !requires(length<Metre, double> l) { l %= 2._q_m; };
requires !requires(length<Metre, double> l) { l %= 2_q_m; };
requires !requires(length<Metre, int> l) { l %= 2._q_m; };
// modulo operations on a floating point representation not allowed
requires !requires(length<Metre, double> l) { l %= 2.; };
requires !requires(length<Metre, double> l) { l %= 2; };
requires !requires(length<Metre, double> l) { l %= 2._q_m; };
requires !requires(length<Metre, double> l) { l %= 2_q_m; };
requires !requires(length<Metre, int> l) { l %= 2._q_m; };
// no unit constants
requires !requires(length<Metre, int> l) { l += m; };
requires !requires(length<Metre, int> l) { l -= m; };
requires !requires(length<Metre, int> l) { l *= m; };
requires !requires(length<Metre, int> l) { l /= m; };
requires !requires(length<Metre, int> l) { l %= m; };
};
// no unit constants
requires !requires(length<Metre, int> l) { l += m; };
requires !requires(length<Metre, int> l) { l -= m; };
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>);
@@ -401,26 +453,26 @@ static_assert(invalid_compound_assignments<metre, kilometre>);
template<typename Metre>
concept invalid_binary_operations = requires {
// no crossdimensional addition and subtraction
requires !requires { 1_q_s + length<Metre, int>(1); };
requires !requires { 1_q_s - length<Metre, int>(1); };
// no crossdimensional addition and subtraction
requires !requires { 1_q_s + length<Metre, int>(1); };
requires !requires { 1_q_s - length<Metre, int>(1); };
// no floating-point modulo
requires !requires(length<Metre, double> a) { a % 2_q_m; };
requires !requires(length<Metre, double> a) { 2_q_m % a; };
requires !requires(length<Metre, double> a) { a % 2; };
requires !requires(length<Metre, double> a, length<Metre, double> b) { a % b; };
requires !requires(length<Metre, double> a, length<Metre, int> b) { a % b; };
requires !requires(length<Metre, double> a, length<Metre, int> b) { b % a; };
// no floating-point modulo
requires !requires(length<Metre, double> a) { a % 2_q_m; };
requires !requires(length<Metre, double> a) { 2_q_m % a; };
requires !requires(length<Metre, double> a) { a % 2; };
requires !requires(length<Metre, double> a, length<Metre, double> b) { a % b; };
requires !requires(length<Metre, double> a, length<Metre, int> b) { a % b; };
requires !requires(length<Metre, double> a, length<Metre, int> b) { b % a; };
// unit constants
requires !requires { length<Metre, int>(1) + m; };
requires !requires { length<Metre, int>(1) - m; };
requires !requires { length<Metre, int>(1) % m; };
requires !requires { m + length<Metre, int>(1); };
requires !requires { m - length<Metre, int>(1); };
requires !requires { m % length<Metre, int>(1); };
};
// unit constants
requires !requires { length<Metre, int>(1) + m; };
requires !requires { length<Metre, int>(1) - m; };
requires !requires { length<Metre, int>(1) % m; };
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
@@ -443,7 +495,8 @@ static_assert(compare<decltype(1_q_m * 1_q_m), area<square_metre, std::int64_t>>
static_assert(compare<decltype(1_q_m / 1_q_m), dimensionless<one, std::int64_t>>);
static_assert(compare<decltype(1 / 1_q_s), frequency<hertz, std::int64_t>>);
static_assert(compare<decltype(quantity{1} / 1_q_s), frequency<hertz, std::int64_t>>);
static_assert(compare<decltype(dimensionless<percent, std::int64_t>(1) / 1_q_s), frequency<scaled_unit<ratio(1, 100), hertz>, std::int64_t>>);
static_assert(compare<decltype(dimensionless<percent, std::int64_t>(1) / 1_q_s),
frequency<scaled_unit<ratio(1, 100), hertz>, std::int64_t>>);
static_assert(is_same_v<decltype((std::uint8_t(0) * m + std::uint8_t(0) * m).number()), int&&>);
static_assert(is_same_v<decltype((std::uint8_t(0) * m - std::uint8_t(0) * m).number()), int&&>);
@@ -456,9 +509,13 @@ static_assert(is_same_v<decltype(((std::uint8_t(0) * m) % (std::uint8_t(0) * m))
// different representation types
static_assert(is_same_v<decltype(1_q_m + 1._q_m), length<metre, long double>>);
static_assert(is_same_v<decltype(1_q_m - 1._q_m), length<metre, long double>>);
static_assert(is_same_v<decltype(1_q_m * 1.L), length<metre, long double>>); // TODO should we address fundamental types implicit truncating conversions with concepts?
static_assert(
is_same_v<decltype(1_q_m * 1.L), length<metre, long double>>); // TODO should we address fundamental types implicit
// truncating conversions with concepts?
static_assert(is_same_v<decltype(1 * 1._q_m), length<metre, long double>>);
static_assert(is_same_v<decltype(1_q_m * quantity{1.L}), length<metre, long double>>); // TODO should we address fundamental types implicit truncating conversions with concepts?
static_assert(is_same_v<decltype(1_q_m * quantity{1.L}),
length<metre, long double>>); // TODO should we address fundamental types implicit truncating
// conversions with concepts?
static_assert(is_same_v<decltype(quantity{1} * 1._q_m), length<metre, long double>>);
static_assert(is_same_v<decltype(1_q_m / 1.L), length<metre, long double>>);
static_assert(is_same_v<decltype(1_q_m / quantity{1.L}), length<metre, long double>>);
@@ -469,7 +526,8 @@ static_assert(compare<decltype(1_q_m / dimensionless<percent, long double>(1)),
static_assert(compare<decltype(1_q_m / 1._q_m), dimensionless<one, long double>>);
static_assert(compare<decltype(1 / 1._q_s), frequency<hertz, long double>>);
static_assert(compare<decltype(quantity{1} / 1._q_s), frequency<hertz, long double>>);
static_assert(compare<decltype(dimensionless<percent, std::int64_t>(1) / 1._q_s), frequency<scaled_unit<ratio(1, 100), hertz>, long double>>);
static_assert(compare<decltype(dimensionless<percent, std::int64_t>(1) / 1._q_s),
frequency<scaled_unit<ratio(1, 100), hertz>, long double>>);
static_assert(compare<decltype(1_q_m % short(1)), length<metre, std::int64_t>>);
static_assert(compare<decltype(1_q_m % quantity{short(1)}), length<metre, std::int64_t>>);
static_assert(compare<decltype(1_q_m % dimensionless<percent, short>(1)), length<metre, std::int64_t>>);
@@ -490,7 +548,8 @@ static_assert(compare<decltype(1._q_m * 1_q_m), area<square_metre, long double>>
static_assert(compare<decltype(1._q_m / 1_q_m), dimensionless<one, long double>>);
static_assert(compare<decltype(1.L / 1_q_s), frequency<hertz, long double>>);
static_assert(compare<decltype(quantity{1.L} / 1_q_s), frequency<hertz, long double>>);
static_assert(compare<decltype(dimensionless<percent, long double>(1) / 1_q_s), frequency<scaled_unit<ratio(1, 100), hertz>, long double>>);
static_assert(compare<decltype(dimensionless<percent, long double>(1) / 1_q_s),
frequency<scaled_unit<ratio(1, 100), hertz>, long double>>);
// different units
static_assert(is_same_v<decltype(1_q_m + 1_q_km), length<metre, std::int64_t>>);
@@ -519,15 +578,21 @@ static_assert(is_same_v<decltype(1_q_km % 1_q_m), length<kilometre, std::int64_t
// different dimensions
static_assert(compare<decltype(1_q_m_per_s * 1_q_s), length<metre, std::int64_t>>);
static_assert(compare<decltype(1_q_m_per_s * 1_q_h), length<scaled_unit<ratio(36, 1, 2), metre>, std::int64_t>>);
static_assert(compare<decltype(1_q_m * 1_q_min), quantity<unknown_dimension<exponent<dim_length, 1>, exponent<dim_time, 1>>, scaled_unit<ratio(60), unknown_coherent_unit>, std::int64_t>>);
static_assert(
compare<decltype(1_q_m * 1_q_min), quantity<unknown_dimension<exponent<dim_length, 1>, exponent<dim_time, 1>>,
scaled_unit<ratio(60), unknown_coherent_unit>, std::int64_t>>);
static_assert(compare<decltype(1_q_s * 1_q_Hz), dimensionless<one, std::int64_t>>);
static_assert(compare<decltype(1 / 1_q_min), frequency<scaled_unit<ratio(1, 60), hertz>, std::int64_t>>);
static_assert(compare<decltype(1 / 1_q_Hz), isq::si::time<second, std::int64_t>>);
static_assert(compare<decltype(1 / 1_q_km), quantity<unknown_dimension<exponent<dim_length, -1>>, scaled_unit<ratio(1, 1, -3), unknown_coherent_unit>, std::int64_t>>);
static_assert(
compare<decltype(1 / 1_q_km), quantity<unknown_dimension<exponent<dim_length, -1>>,
scaled_unit<ratio(1, 1, -3), unknown_coherent_unit>, std::int64_t>>);
static_assert(compare<decltype(1_q_km / 1_q_m), dimensionless<scaled_unit<ratio(1000), one>, std::int64_t>>);
static_assert(compare<decltype(1_q_m / 1_q_s), speed<metre_per_second, std::int64_t>>);
static_assert(compare<decltype(1_q_m / 1_q_min), speed<scaled_unit<ratio(1, 60), metre_per_second>, std::int64_t>>);
static_assert(compare<decltype(1_q_min / 1_q_m), quantity<unknown_dimension<exponent<dim_length, -1>, exponent<dim_time, 1>>, scaled_unit<ratio(60), unknown_coherent_unit>, std::int64_t>>);
static_assert(
compare<decltype(1_q_min / 1_q_m), quantity<unknown_dimension<exponent<dim_length, -1>, exponent<dim_time, 1>>,
scaled_unit<ratio(60), unknown_coherent_unit>, std::int64_t>>);
static_assert((1_q_m + 1_q_m).number() == 2);
static_assert((1_q_m + 1_q_km).number() == 1001);
@@ -652,9 +717,9 @@ static_assert(quantity{2} / (1 * m) == 2 / 1_q_m);
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); };
};
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
@@ -688,11 +753,11 @@ static_assert(123 != quantity{321});
template<typename Metre>
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); };
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); };
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
@@ -764,9 +829,9 @@ static_assert(!std::equality_comparable_with<dimensionless<one, int>, double>);
template<typename Int>
concept invalid_dimensionless_operations = requires {
requires !requires(dimensionless<percent, Int> d) { 1 + d; };
requires !requires(dimensionless<percent, Int> d) { d + 1; };
};
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>>);
@@ -815,7 +880,9 @@ static_assert(!is_same_v<decltype(quantity_cast<litre>(2_q_dm3)), volume<cubic_d
#if UNITS_DOWNCAST_MODE == 0
static_assert(is_same_v<decltype(10_q_m / 5_q_s), quantity<unknown_dimension<units::exponent<dim_length, 1>, units::exponent<dim_time, -1>>, scaled_unit<ratio(1), unknown_coherent_unit>, std::int64_t>>);
static_assert(is_same_v<decltype(10_q_m / 5_q_s),
quantity<unknown_dimension<units::exponent<dim_length, 1>, units::exponent<dim_time, -1>>,
scaled_unit<ratio(1), unknown_coherent_unit>, std::int64_t>>);
static_assert(is_same_v<decltype(1_q_mm + 1_q_km), length<scaled_unit<ratio(1, 1, -3), metre>, std::int64_t>>);
#else
@@ -846,6 +913,7 @@ static_assert(same(quotient_remainder_theorem(3'000 * m, 400), 3'000 * m));
static_assert(same(quotient_remainder_theorem(3'000 * m, quantity(400)), 3'000 * m));
static_assert(same(quotient_remainder_theorem(3 * km, quantity(400)), 3 * km));
static_assert(same(quotient_remainder_theorem(3 * km, quantity(2)), 3 * km));
static_assert(same(quotient_remainder_theorem(3 * km, dimensionless<scaled_unit<ratio(1, 1000), one>, int>(400)), 3 * km));
static_assert(same(quotient_remainder_theorem(3 * km, dimensionless<scaled_unit<ratio(1, 1000), one>, int>(400)),
3 * km));
} // namespace