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

refactor: quantity::count() renamed to quantity::number()

Browse Source 
Resolves #259
This commit is contained in:
Mateusz Pusz
2021-03-19 06:47:37 +01:00
parent bcaf252dec
commit 901b09fd52
26 changed files with 283 additions and 282 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -106,12 +106,12 @@ static_assert(is_same_v<fps::length<fps::mile>::rep, double>);
// static member functions
////////////////////////////
static_assert(length<metre, int>::zero().count() == 0);
static_assert(length<metre, int>::min().count() == std::numeric_limits<int>::lowest());
static_assert(length<metre, int>::max().count() == std::numeric_limits<int>::max());
static_assert(length<metre, double>::zero().count() == 0.0);
static_assert(length<metre, double>::min().count() == std::numeric_limits<double>::lowest());
static_assert(length<metre, double>::max().count() == std::numeric_limits<double>::max());
static_assert(length<metre, int>::zero().number() == 0);
static_assert(length<metre, int>::min().number() == std::numeric_limits<int>::lowest());
static_assert(length<metre, int>::max().number() == std::numeric_limits<int>::max());
static_assert(length<metre, double>::zero().number() == 0.0);
static_assert(length<metre, double>::min().number() == std::numeric_limits<double>::lowest());
static_assert(length<metre, double>::max().number() == std::numeric_limits<double>::max());
//////////////////////////////
@@ -182,11 +182,11 @@ 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>().count() == 0); // value initialization
static_assert(length<metre, int>(1).count() == 1);
static_assert(length<metre, double>(1.0).count() == 1.0);
static_assert(length<metre, double>(1).count() == 1.0);
static_assert(length<metre, double>(3.14).count() == 3.14);
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);
static_assert(length<metre, double>(3.14).number() == 3.14);
///////////////////////////////////////
@@ -226,10 +226,10 @@ static_assert(std::convertible_to<length<kilometre, int>, length<metre>>);
static_assert(std::constructible_from<length<kilometre>, length<metre, int>>);
static_assert(std::convertible_to<length<metre, int>, length<kilometre>>);
static_assert(length<metre, int>(123_q_m).count() == 123);
static_assert(length<kilometre, int>(2_q_km).count() == 2);
static_assert(length<metre, int>(2_q_km).count() == 2000);
static_assert(length<kilometre>(1500_q_m).count() == 1.5);
static_assert(length<metre, int>(123_q_m).number() == 123);
static_assert(length<kilometre, int>(2_q_km).number() == 2);
static_assert(length<metre, int>(2_q_km).number() == 2000);
static_assert(length<kilometre>(1500_q_m).number() == 1.5);
/////////
@@ -248,25 +248,25 @@ 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; }().count() == 1);
static_assert([]() { length<metre, int> l1(1), l2(2); return l2 = std::move(l1); }().count() == 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);
////////////////////
// unary operators
////////////////////
static_assert((+123_q_m).count() == 123);
static_assert((-123_q_m).count() == -123);
static_assert((+(-123_q_m)).count() == -123);
static_assert((-(-123_q_m)).count() == 123);
static_assert((+123_q_m).number() == 123);
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(is_same_v<decltype((+(short{0} * m)).count()), int>);
static_assert(is_same_v<decltype((+(short{0} * m)).number()), int>);
////////////////////////
@@ -274,42 +274,42 @@ static_assert(is_same_v<decltype((+(short{0} * m)).count()), int>);
////////////////////////
// same type
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((1_q_m *= quantity(2)).count() == 2);
static_assert((2_q_m /= quantity(2)).count() == 1);
static_assert((7_q_m %= quantity(2)).count() == 1);
static_assert((7_q_m %= 2_q_m).count() == 1);
static_assert((1_q_m += 1_q_m).number() == 2);
static_assert((2_q_m -= 1_q_m).number() == 1);
static_assert((1_q_m *= 2).number() == 2);
static_assert((2_q_m /= 2).number() == 1);
static_assert((7_q_m %= 2).number() == 1);
static_assert((1_q_m *= quantity(2)).number() == 2);
static_assert((2_q_m /= quantity(2)).number() == 1);
static_assert((7_q_m %= quantity(2)).number() == 1);
static_assert((7_q_m %= 2_q_m).number() == 1);
// different types
static_assert((2.5_q_m += 3_q_m).count() == 5.5);
static_assert((123_q_m += 1_q_km).count() == 1123);
static_assert((5.5_q_m -= 3_q_m).count() == 2.5);
static_assert((1123_q_m -= 1_q_km).count() == 123);
static_assert((2.5_q_m *= 3).count() == 7.5);
static_assert((7.5_q_m /= 3).count() == 2.5);
static_assert((2.5_q_m *= quantity(3)).count() == 7.5);
static_assert((7.5_q_m /= quantity(3)).count() == 2.5);
static_assert((3500_q_m %= 1_q_km).count() == 500);
static_assert((2.5_q_m += 3_q_m).number() == 5.5);
static_assert((123_q_m += 1_q_km).number() == 1123);
static_assert((5.5_q_m -= 3_q_m).number() == 2.5);
static_assert((1123_q_m -= 1_q_km).number() == 123);
static_assert((2.5_q_m *= 3).number() == 7.5);
static_assert((7.5_q_m /= 3).number() == 2.5);
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).count() == [] { std::uint8_t ui(255); return ui %= 256; }());
static_assert((std::uint8_t(255) * m %= quantity(256)).count() == [] { std::uint8_t ui(255); return ui %= 256; }());
// static_assert((std::uint8_t(255) * m %= 256 * m).count() != [] { std::uint8_t ui(255); return ui %= 256; }()); // UB
static_assert((std::uint8_t(255) * m %= 257).count() == [] { std::uint8_t ui(255); return ui %= 257; }());
static_assert((std::uint8_t(255) * m %= quantity(257)).count() == [] { 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).count() != [] { 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)
// next two lines trigger conversions warnings
// (warning disabled in CMake for this file)
static_assert((22_q_m *= 33.33).count() == 733);
static_assert((22_q_m /= 3.33).count() == 6);
static_assert((22_q_m *= quantity(33.33)).count() == 733);
static_assert((22_q_m /= quantity(3.33)).count() == 6);
static_assert((22_q_m *= 33.33).number() == 733);
static_assert((22_q_m /= 3.33).number() == 6);
static_assert((22_q_m *= quantity(33.33)).number() == 733);
static_assert((22_q_m /= quantity(3.33)).number() == 6);
#endif
template<typename Metre, typename Kilometre>
@@ -403,12 +403,12 @@ 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(is_same_v<decltype((std::uint8_t(0) * m + std::uint8_t(0) * m).count()), int>);
static_assert(is_same_v<decltype((std::uint8_t(0) * m - std::uint8_t(0) * m).count()), int>);
static_assert((std::uint8_t(128) * m + std::uint8_t(128) * m).count() == std::uint8_t(128) + std::uint8_t(128));
static_assert((std::uint8_t(0) * m - std::uint8_t(1) * m).count() == std::uint8_t(0) - std::uint8_t(1));
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>);
static_assert((std::uint8_t(128) * m + std::uint8_t(128) * m).number() == std::uint8_t(128) + std::uint8_t(128));
static_assert((std::uint8_t(0) * m - std::uint8_t(1) * m).number() == std::uint8_t(0) - std::uint8_t(1));
static_assert(is_same_v<decltype(((std::uint8_t(0) * m) % (std::uint8_t(0) * m)).count()),
static_assert(is_same_v<decltype(((std::uint8_t(0) * m) % (std::uint8_t(0) * m)).number()),
decltype(std::uint8_t(0) % std::uint8_t(0))>);
// different representation types
@@ -487,75 +487,75 @@ static_assert(compare<decltype(1_q_m / 1_q_s), speed<metre_per_second, std::int6
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((1_q_m + 1_q_m).count() == 2);
static_assert((1_q_m + 1_q_km).count() == 1001);
static_assert((1_q_km + 1_q_m).count() == 1001);
static_assert((2_q_m - 1_q_m).count() == 1);
static_assert((1_q_km - 1_q_m).count() == 999);
static_assert((2_q_m * 2).count() == 4);
static_assert((2_q_m * quantity{2}).count() == 4);
static_assert((2_q_m * dimensionless<percent, int>(2)).count() == 4);
static_assert((3 * 3_q_m).count() == 9);
static_assert((quantity{3} * 3_q_m).count() == 9);
static_assert((dimensionless<percent, int>(3) * 3_q_m).count() == 9);
static_assert((4_q_m / 2).count() == 2);
static_assert((4_q_m / quantity{2}).count() == 2);
static_assert((4_q_m / dimensionless<percent, int>(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((1_q_m + 1_q_m).number() == 2);
static_assert((1_q_m + 1_q_km).number() == 1001);
static_assert((1_q_km + 1_q_m).number() == 1001);
static_assert((2_q_m - 1_q_m).number() == 1);
static_assert((1_q_km - 1_q_m).number() == 999);
static_assert((2_q_m * 2).number() == 4);
static_assert((2_q_m * quantity{2}).number() == 4);
static_assert((2_q_m * dimensionless<percent, int>(2)).number() == 4);
static_assert((3 * 3_q_m).number() == 9);
static_assert((quantity{3} * 3_q_m).number() == 9);
static_assert((dimensionless<percent, int>(3) * 3_q_m).number() == 9);
static_assert((4_q_m / 2).number() == 2);
static_assert((4_q_m / quantity{2}).number() == 2);
static_assert((4_q_m / dimensionless<percent, int>(2)).number() == 2);
static_assert((4_q_km / 2_q_m).number() == 2);
static_assert((4000_q_m / 2_q_m).number() == 2000);
static_assert((1.5_q_m + 1_q_m).count() == 2.5);
static_assert((1.5_q_m + 1_q_km).count() == 1001.5);
static_assert((1.5_q_km + 1_q_m).count() == 1501);
static_assert((2.5_q_m - 1_q_m).count() == 1.5);
static_assert((1.5_q_km - 1_q_m).count() == 1499);
static_assert((2.5_q_m * 2).count() == 5);
static_assert((2.5_q_m * quantity{2}).count() == 5);
static_assert((2.5_q_m * dimensionless<percent, int>(2)).count() == 5);
static_assert((2.5L * 2_q_m).count() == 5);
static_assert((quantity{2.5L} * 2_q_m).count() == 5);
static_assert((dimensionless<percent, long double>(2.5L) * 2_q_m).count() == 5);
static_assert((5._q_m / 2).count() == 2.5);
static_assert((5._q_m / quantity{2}).count() == 2.5);
static_assert((5._q_m / dimensionless<percent, int>(2)).count() == 2.5);
static_assert((5._q_km / 2_q_m).count() == 2.5);
static_assert((5000._q_m / 2_q_m).count() == 2500);
static_assert((1.5_q_m + 1_q_m).number() == 2.5);
static_assert((1.5_q_m + 1_q_km).number() == 1001.5);
static_assert((1.5_q_km + 1_q_m).number() == 1501);
static_assert((2.5_q_m - 1_q_m).number() == 1.5);
static_assert((1.5_q_km - 1_q_m).number() == 1499);
static_assert((2.5_q_m * 2).number() == 5);
static_assert((2.5_q_m * quantity{2}).number() == 5);
static_assert((2.5_q_m * dimensionless<percent, int>(2)).number() == 5);
static_assert((2.5L * 2_q_m).number() == 5);
static_assert((quantity{2.5L} * 2_q_m).number() == 5);
static_assert((dimensionless<percent, long double>(2.5L) * 2_q_m).number() == 5);
static_assert((5._q_m / 2).number() == 2.5);
static_assert((5._q_m / quantity{2}).number() == 2.5);
static_assert((5._q_m / dimensionless<percent, int>(2)).number() == 2.5);
static_assert((5._q_km / 2_q_m).number() == 2.5);
static_assert((5000._q_m / 2_q_m).number() == 2500);
static_assert((1_q_m + 1.5_q_m).count() == 2.5);
static_assert((1_q_m + 1.5_q_km).count() == 1501);
static_assert((1_q_km + 1.5_q_m).count() == 1001.5);
static_assert((2_q_m - 1.5_q_m).count() == 0.5);
static_assert((1_q_km - 1.5_q_m).count() == 998.5);
static_assert((2_q_m * 2.5L).count() == 5);
static_assert((2_q_m * quantity{2.5L}).count() == 5);
static_assert((2_q_m * dimensionless<percent, long double>(2.5L)).count() == 5);
static_assert((2 * 2.5_q_m).count() == 5);
static_assert((quantity{2} * 2.5_q_m).count() == 5);
static_assert((dimensionless<percent, int>(2) * 2.5_q_m).count() == 5);
static_assert((5_q_m / 2.5L).count() == 2);
static_assert((5_q_m / quantity{2.5L}).count() == 2);
static_assert((5_q_m / dimensionless<percent, long double>(2.5L)).count() == 2);
static_assert((5_q_km / 2.5_q_m).count() == 2);
static_assert((5000_q_m / 2.5_q_m).count() == 2000);
static_assert((1_q_m + 1.5_q_m).number() == 2.5);
static_assert((1_q_m + 1.5_q_km).number() == 1501);
static_assert((1_q_km + 1.5_q_m).number() == 1001.5);
static_assert((2_q_m - 1.5_q_m).number() == 0.5);
static_assert((1_q_km - 1.5_q_m).number() == 998.5);
static_assert((2_q_m * 2.5L).number() == 5);
static_assert((2_q_m * quantity{2.5L}).number() == 5);
static_assert((2_q_m * dimensionless<percent, long double>(2.5L)).number() == 5);
static_assert((2 * 2.5_q_m).number() == 5);
static_assert((quantity{2} * 2.5_q_m).number() == 5);
static_assert((dimensionless<percent, int>(2) * 2.5_q_m).number() == 5);
static_assert((5_q_m / 2.5L).number() == 2);
static_assert((5_q_m / quantity{2.5L}).number() == 2);
static_assert((5_q_m / dimensionless<percent, long double>(2.5L)).number() == 2);
static_assert((5_q_km / 2.5_q_m).number() == 2);
static_assert((5000_q_m / 2.5_q_m).number() == 2000);
static_assert((7_q_m % 2).count() == 1);
static_assert((7_q_m % quantity{2}).count() == 1);
static_assert((7_q_m % dimensionless<percent, int>(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((7_q_m % 2).number() == 1);
static_assert((7_q_m % quantity{2}).number() == 1);
static_assert((7_q_m % dimensionless<percent, int>(2)).number() == 1);
static_assert((7_q_m % 2_q_m).number() == 1);
static_assert((7_q_km % 2000_q_m).number() == 1000);
static_assert((10_q_km2 * 10_q_km2) / 50_q_km2 == 2_q_km2);
static_assert((10_q_km / 5_q_m).count() == 2);
static_assert(dimensionless<one>(10_q_km / 5_q_m).count() == 2000);
static_assert((10_q_km / 5_q_m).number() == 2);
static_assert(dimensionless<one>(10_q_km / 5_q_m).number() == 2000);
#if UNITS_DOWNCAST_MODE == 0
static_assert(quantity_cast<dim_one, one>(10_q_km / 5_q_m).count() == 2000);
static_assert(quantity_cast<dim_one, one>(10_q_km / 5_q_m).number() == 2000);
#else
static_assert(quantity_cast<one>(10_q_km / 5_q_m).count() == 2000);
static_assert(quantity_cast<one>(10_q_km / 5_q_m).number() == 2000);
#endif
static_assert((10_q_s * 2_q_kHz).count() == 20);
static_assert((10_q_s * 2_q_kHz).number() == 20);
// unit constants
@@ -592,13 +592,13 @@ static_assert(quantity(1) - 2.3 == quantity(1 - 2.3));
static_assert(1.2 + quantity(3) == quantity(1.2 + 3));
static_assert(1.2 - quantity(3) == quantity(1.2 - 3));
static_assert(is_same_v<decltype((quantity{std::uint8_t(0)} + quantity{std::uint8_t(0)}).count()), int>);
static_assert(is_same_v<decltype((quantity{std::uint8_t(0)} - quantity{std::uint8_t(0)}).count()), int>);
static_assert((quantity{std::uint8_t(128)} + quantity{std::uint8_t(128)}).count() ==
static_assert(is_same_v<decltype((quantity{std::uint8_t(0)} + quantity{std::uint8_t(0)}).number()), int>);
static_assert(is_same_v<decltype((quantity{std::uint8_t(0)} - quantity{std::uint8_t(0)}).number()), int>);
static_assert((quantity{std::uint8_t(128)} + quantity{std::uint8_t(128)}).number() ==
std::uint8_t(128) + std::uint8_t(128));
static_assert((quantity{std::uint8_t(0)} - quantity{std::uint8_t(1)}).count() == std::uint8_t(0) - std::uint8_t(1));
static_assert((quantity{std::uint8_t(0)} - quantity{std::uint8_t(1)}).number() == std::uint8_t(0) - std::uint8_t(1));
static_assert(is_same_v<decltype((quantity{std::uint8_t(0)} % quantity{std::uint8_t(0)}).count()),
static_assert(is_same_v<decltype((quantity{std::uint8_t(0)} % quantity{std::uint8_t(0)}).number()),
decltype(std::uint8_t(0) % std::uint8_t(0))>);
static_assert(quantity{2} * (1 * m) == 2_q_m);
@@ -731,13 +731,13 @@ static_assert(invalid_dimensionless_operations<int>);
static_assert(compare<decltype(10_q_km / 5_q_km), quantity<dim_one, one, std::int64_t>>);
#if UNITS_DOWNCAST_MODE == 0
static_assert(quantity_cast<dim_one, percent>(50._q_m / 100._q_m).count() == 50);
static_assert(quantity_cast<dim_one, percent>(50._q_m / 100._q_m).number() == 50);
#else
static_assert(quantity_cast<percent>(50._q_m / 100._q_m).count() == 50);
static_assert(quantity_cast<percent>(50._q_m / 100._q_m).number() == 50);
#endif
static_assert(50._q_m / 100._q_m == dimensionless<percent>(50));
static_assert(dimensionless<one>(dimensionless<percent>(50)).count() == 0.5);
static_assert(dimensionless<one>(dimensionless<percent>(50)).number() == 0.5);
////////////////
@@ -755,13 +755,13 @@ static_assert(2_q_dm3 + 2_q_cm3 == 2002_q_ml);
// quantity_cast
//////////////////
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);
static_assert(quantity_cast<dim_speed, kilometre_per_hour>(2000.0_q_m / 3600.0_q_s).count() == 2);
static_assert(quantity_cast<length<metre, int>>(2_q_km).number() == 2000);
static_assert(quantity_cast<length<kilometre, int>>(2000_q_m).number() == 2);
static_assert(quantity_cast<length<metre, int>>(1.23_q_m).number() == 1);
static_assert(quantity_cast<metre>(2_q_km).number() == 2000);
static_assert(quantity_cast<kilometre>(2000_q_m).number() == 2);
static_assert(quantity_cast<int>(1.23_q_m).number() == 1);
static_assert(quantity_cast<dim_speed, kilometre_per_hour>(2000.0_q_m / 3600.0_q_s).number() == 2);
static_assert(quantity_cast<dim_length>(1 * cgs_cm) == 1 * cm);