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

refactor: 💥 q_* UDL renamed to _q_*

Browse Source 
We had some fun exploring the STD UDLs for potential collisions,
we have learnt our lesson and know how to proceed.
Now is high time to start behaving and obeying C++ rules.
This commit is contained in:
Mateusz Pusz
2020-09-09 19:20:35 +02:00
parent 2b408f19c0
commit 9527b39005
130 changed files with 2221 additions and 2235 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/unit_test/static/quantity_test.cpp
+88 -88
View File
@@ -69,9 +69,9 @@ static_assert(length<metre, double>(3.14).count() == 3.14);
static_assert(length<metre, int>(km).count() == 1000);
static_assert(!std::is_constructible_v<length<metre, int>,
length<metre, double>>); // truncating conversion
static_assert(length<metre, double>(1000.0q_m).count() == 1000.0);
static_assert(length<metre, double>(1000.0_q_m).count() == 1000.0);
static_assert(length<metre, double>(km).count() == 1000.0);
static_assert(length<metre, int>(1q_km).count() == 1000);
static_assert(length<metre, int>(1_q_km).count() == 1000);
static_assert(!std::is_constructible_v<length<metre, int>,
physical::si::time<second, int>>); // different dimensions
static_assert(!std::is_constructible_v<length<kilometre, int>,
@@ -116,18 +116,18 @@ static_assert([](auto v) {
// compound assignment
static_assert((1q_m += 1q_m).count() == 2);
static_assert((2q_m -= 1q_m).count() == 1);
static_assert((1q_m *= 2).count() == 2);
static_assert((2q_m /= 2).count() == 1);
static_assert((7q_m %= 2).count() == 1);
static_assert((7q_m %= 2q_m).count() == 1);
static_assert((1_q_m += 1_q_m).count() == 2);
static_assert((2_q_m -= 1_q_m).count() == 1);
static_assert((1_q_m *= 2).count() == 2);
static_assert((2_q_m /= 2).count() == 1);
static_assert((7_q_m %= 2).count() == 1);
static_assert((7_q_m %= 2_q_m).count() == 1);
static_assert((2.5q_m += 3q_m).count() == 5.5);
static_assert((2.5q_m += 3.5q_m).count() == 6);
static_assert((2.5_q_m += 3_q_m).count() == 5.5);
static_assert((2.5_q_m += 3.5_q_m).count() == 6);
static_assert((2.5q_m *= 3).count() == 7.5);
static_assert((2.5q_m *= 3.5).count() == 8.75);
static_assert((2.5_q_m *= 3).count() == 7.5);
static_assert((2.5_q_m *= 3.5).count() == 8.75);
// operations not allowed for the respective quantities
template<typename Metre>
@@ -136,11 +136,11 @@ concept invalid_compound_assignments = requires()
!requires(length<Metre, double> l) { l %= 2.; };
!requires(length<Metre, double> l) { l %= 2; };
!requires(length<Metre, int> l) { l %= 2.; };
!requires(length<Metre, double> l) { l %= 2.q_m; };
!requires(length<Metre, double> l) { l %= 2q_m; };
!requires(length<Metre, int> l) { l %= 2.q_m; };
!requires(length<Metre, int> l) { l += 3.5q_m; };
!requires(length<Metre, int> l) { l *= 3.5q_m; };
!requires(length<Metre, double> l) { l %= 2._q_m; };
!requires(length<Metre, double> l) { l %= 2_q_m; };
!requires(length<Metre, int> l) { l %= 2._q_m; };
!requires(length<Metre, int> l) { l += 3.5_q_m; };
!requires(length<Metre, int> l) { l *= 3.5_q_m; };
};
static_assert(invalid_compound_assignments<metre>);
@@ -179,22 +179,22 @@ static_assert(is_same_v<decltype(physical::si::time<minute>() / length<metre>())
static_assert(is_same_v<decltype(length<metre, int>() % short(1)), length<metre, int>>);
static_assert(is_same_v<decltype(length<metre, int>() % length<metre, short>(1)), length<metre, int>>);
static_assert((1q_m + km).count() == 1001);
static_assert((1q_m + 1q_km).count() == 1001);
static_assert((km - 1q_m).count() == 999);
static_assert((1q_km - 1q_m).count() == 999);
static_assert((2q_m * 2).count() == 4);
static_assert((3 * 3q_m).count() == 9);
static_assert((4q_m / 2).count() == 2);
static_assert((4q_km / 2q_m).count() == 2);
static_assert((4000q_m / 2q_m).count() == 2000);
static_assert((7q_m % 2).count() == 1);
static_assert((7q_m % 2q_m).count() == 1);
static_assert((7q_km % 2000q_m).count() == 1000);
static_assert((1_q_m + km).count() == 1001);
static_assert((1_q_m + 1_q_km).count() == 1001);
static_assert((km - 1_q_m).count() == 999);
static_assert((1_q_km - 1_q_m).count() == 999);
static_assert((2_q_m * 2).count() == 4);
static_assert((3 * 3_q_m).count() == 9);
static_assert((4_q_m / 2).count() == 2);
static_assert((4_q_km / 2_q_m).count() == 2);
static_assert((4000_q_m / 2_q_m).count() == 2000);
static_assert((7_q_m % 2).count() == 1);
static_assert((7_q_m % 2_q_m).count() == 1);
static_assert((7_q_km % 2000_q_m).count() == 1000);
static_assert((10q_km2 * 10q_km2) / 50q_km2 == 2q_km2);
static_assert((10_q_km2 * 10_q_km2) / 50_q_km2 == 2_q_km2);
constexpr auto q1 = 10q_km / 5q_m;
constexpr auto q1 = 10_q_km / 5_q_m;
static_assert(std::is_same_v<decltype(q1), const dimensionless<scaled_unit<ratio(1, 1, 3), one>, std::int64_t>>);
static_assert(q1.count() == 2);
@@ -203,47 +203,47 @@ static_assert(q2.count() == 2000);
static_assert(quantity_cast<one>(q1).count() == 2000);
constexpr auto q3 = 10q_s * 2q_kHz;
constexpr auto q3 = 10_q_s * 2_q_kHz;
static_assert(std::is_same_v<decltype(q3), const dimensionless<scaled_unit<ratio(1, 1, 3), one>, std::int64_t>>);
static_assert(q3.count() == 20);
// comparators
static_assert(2q_m + 1q_m == 3q_m);
static_assert(!(2q_m + 2q_m == 3q_m));
static_assert(2q_m + 2q_m != 3q_m);
static_assert(!(2q_m + 2q_m != 4q_m));
static_assert(2q_m > 1q_m);
static_assert(!(1q_m > 1q_m));
static_assert(1q_m < 2q_m);
static_assert(!(2q_m < 2q_m));
static_assert(2q_m >= 1q_m);
static_assert(2q_m >= 2q_m);
static_assert(!(2q_m >= 3q_m));
static_assert(1q_m <= 2q_m);
static_assert(2q_m <= 2q_m);
static_assert(!(3q_m <= 2q_m));
static_assert(2_q_m + 1_q_m == 3_q_m);
static_assert(!(2_q_m + 2_q_m == 3_q_m));
static_assert(2_q_m + 2_q_m != 3_q_m);
static_assert(!(2_q_m + 2_q_m != 4_q_m));
static_assert(2_q_m > 1_q_m);
static_assert(!(1_q_m > 1_q_m));
static_assert(1_q_m < 2_q_m);
static_assert(!(2_q_m < 2_q_m));
static_assert(2_q_m >= 1_q_m);
static_assert(2_q_m >= 2_q_m);
static_assert(!(2_q_m >= 3_q_m));
static_assert(1_q_m <= 2_q_m);
static_assert(2_q_m <= 2_q_m);
static_assert(!(3_q_m <= 2_q_m));
static_assert(3q_m == 3.0q_m);
static_assert(3q_m != 3.14q_m);
static_assert(2q_m > 1.0q_m);
static_assert(1.0q_m < 2q_m);
static_assert(2.0q_m >= 1q_m);
static_assert(1q_m <= 2.0q_m);
static_assert(3_q_m == 3.0_q_m);
static_assert(3_q_m != 3.14_q_m);
static_assert(2_q_m > 1.0_q_m);
static_assert(1.0_q_m < 2_q_m);
static_assert(2.0_q_m >= 1_q_m);
static_assert(1_q_m <= 2.0_q_m);
static_assert(1000q_m == 1q_km);
static_assert(1001q_m != 1q_km);
static_assert(1001q_m > 1q_km);
static_assert(999q_m < 1q_km);
static_assert(1000q_m >= 1q_km);
static_assert(1000q_m <= 1q_km);
static_assert(1000_q_m == 1_q_km);
static_assert(1001_q_m != 1_q_km);
static_assert(1001_q_m > 1_q_km);
static_assert(999_q_m < 1_q_km);
static_assert(1000_q_m >= 1_q_km);
static_assert(1000_q_m <= 1_q_km);
// alias units
static_assert(2q_l + 2q_ml == 2002q_ml);
static_assert(2q_l + 2q_ml == 2002q_cm3);
static_assert(2q_l + 2q_cm3 == 2002q_ml);
static_assert(2q_dm3 + 2q_cm3 == 2002q_ml);
static_assert(2_q_l + 2_q_ml == 2002_q_ml);
static_assert(2_q_l + 2_q_ml == 2002_q_cm3);
static_assert(2_q_l + 2_q_cm3 == 2002_q_ml);
static_assert(2_q_dm3 + 2_q_cm3 == 2002_q_ml);
// is_quantity
@@ -261,10 +261,10 @@ static_assert(is_same_v<common_quantity<length<kilometre, long long>, length<mil
using namespace units::physical::us::literals;
static_assert(std::equality_comparable<decltype(1q_m)>);
static_assert(std::equality_comparable_with<decltype(1q_m), decltype(1q_cm)>);
static_assert(0q_m == 0q_ft_us);
static_assert(std::equality_comparable_with<decltype(1q_m), decltype(1q_ft_us)>);
static_assert(std::equality_comparable<decltype(1_q_m)>);
static_assert(std::equality_comparable_with<decltype(1_q_m), decltype(1_q_cm)>);
static_assert(0_q_m == 0_q_ft_us);
static_assert(std::equality_comparable_with<decltype(1_q_m), decltype(1_q_ft_us)>);
static_assert(std::equality_comparable_with<dimensionless<one>, int>);
static_assert(std::equality_comparable_with<dimensionless<one>, double>);
static_assert(std::equality_comparable_with<dimensionless<one, int>, int>);
@@ -272,14 +272,14 @@ static_assert(!std::equality_comparable_with<dimensionless<one, int>, double>);
// quantity_cast
static_assert(is_same_v<decltype(quantity_cast<scaled_unit<ratio(1), metre>>(2q_km))::unit, metre>);
static_assert(is_same_v<decltype(quantity_cast<scaled_unit<ratio(1), metre>>(2_q_km))::unit, metre>);
static_assert(quantity_cast<length<metre, int>>(2q_km).count() == 2000);
static_assert(quantity_cast<length<kilometre, int>>(2000q_m).count() == 2);
static_assert(quantity_cast<length<metre, int>>(1.23q_m).count() == 1);
static_assert(quantity_cast<metre>(2q_km).count() == 2000);
static_assert(quantity_cast<kilometre>(2000q_m).count() == 2);
static_assert(quantity_cast<int>(1.23q_m).count() == 1);
static_assert(quantity_cast<length<metre, int>>(2_q_km).count() == 2000);
static_assert(quantity_cast<length<kilometre, int>>(2000_q_m).count() == 2);
static_assert(quantity_cast<length<metre, int>>(1.23_q_m).count() == 1);
static_assert(quantity_cast<metre>(2_q_km).count() == 2000);
static_assert(quantity_cast<kilometre>(2000_q_m).count() == 2);
static_assert(quantity_cast<int>(1.23_q_m).count() == 1);
// dimensionless
@@ -308,37 +308,37 @@ concept invalid_dimensionless_operations = requires
};
static_assert(invalid_dimensionless_operations<int>);
static_assert(std::is_same_v<decltype(10q_km / 5q_km), quantity<dim_one, one, std::int64_t>>);
static_assert(std::is_same_v<decltype(10_q_km / 5_q_km), quantity<dim_one, one, std::int64_t>>);
static_assert(quantity_cast<percent>(50.q_m / 100.q_m).count() == 50);
static_assert(50.q_m / 100.q_m == dimensionless<percent>(50));
static_assert(quantity_cast<percent>(50._q_m / 100._q_m).count() == 50);
static_assert(50._q_m / 100._q_m == dimensionless<percent>(50));
static_assert(dimensionless<one>(dimensionless<percent>(50)).count() == 0.5);
// time
static_assert(1q_h == 3600q_s);
static_assert(1_q_h == 3600_q_s);
template<typename Metre>
concept no_crossdimensional_equality = !requires { 1q_s == length<Metre, int>(1); };
concept no_crossdimensional_equality = !requires { 1_q_s == length<Metre, int>(1); };
static_assert(no_crossdimensional_equality<metre>);
// length
static_assert(1q_km == 1000q_m);
static_assert(1q_km + 1q_m == 1001q_m);
static_assert(10q_km / 5q_km == 2);
static_assert(10q_km / 2 == 5q_km);
static_assert(1_q_km == 1000_q_m);
static_assert(1_q_km + 1_q_m == 1001_q_m);
static_assert(10_q_km / 5_q_km == 2);
static_assert(10_q_km / 2 == 5_q_km);
// speed
static_assert(10q_m / 5q_s == 2q_m_per_s);
static_assert(10 / 5q_s * 1q_m == 2q_m_per_s);
static_assert(1q_km / 1q_s == 1000q_m_per_s);
static_assert(2q_km_per_h * 2q_h == 4q_km);
static_assert(2q_km / 2q_km_per_h == 1q_h);
static_assert(10_q_m / 5_q_s == 2_q_m_per_s);
static_assert(10 / 5_q_s * 1_q_m == 2_q_m_per_s);
static_assert(1_q_km / 1_q_s == 1000_q_m_per_s);
static_assert(2_q_km_per_h * 2_q_h == 4_q_km);
static_assert(2_q_km / 2_q_km_per_h == 1_q_h);
static_assert(is_same_v<decltype(pow<2>(2q_m)), decltype(4q_m2)>);
static_assert(is_same_v<decltype(pow<2>(2_q_m)), decltype(4_q_m2)>);
} // namespace