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

refactor: number() and number_in() renamed to value() and value_in()

Browse Source 
Resolves #423
This commit is contained in:
Mateusz Pusz
2023-08-23 17:15:32 +02:00
parent ae92b49775
commit a9204e2473
21 changed files with 349 additions and 351 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/unit_test/static/quantity_test.cpp
+123 -123
View File
@@ -112,12 +112,12 @@ static_assert(is_same_v<quantity<isq::length[m], int>::rep, int>);
// static member functions
////////////////////////////
static_assert(quantity<isq::length[m], int>::zero().number() == 0);
static_assert(quantity<isq::length[m], int>::min().number() == std::numeric_limits<int>::lowest());
static_assert(quantity<isq::length[m], int>::max().number() == std::numeric_limits<int>::max());
static_assert(quantity<isq::length[m], double>::zero().number() == 0.0);
static_assert(quantity<isq::length[m], double>::min().number() == std::numeric_limits<double>::lowest());
static_assert(quantity<isq::length[m], double>::max().number() == std::numeric_limits<double>::max());
static_assert(quantity<isq::length[m], int>::zero().value() == 0);
static_assert(quantity<isq::length[m], int>::min().value() == std::numeric_limits<int>::lowest());
static_assert(quantity<isq::length[m], int>::max().value() == std::numeric_limits<int>::max());
static_assert(quantity<isq::length[m], double>::zero().value() == 0.0);
static_assert(quantity<isq::length[m], double>::min().value() == std::numeric_limits<double>::lowest());
static_assert(quantity<isq::length[m], double>::max().value() == std::numeric_limits<double>::max());
//////////////////////////////
@@ -188,21 +188,21 @@ static_assert(std::convertible_to<quantity<isq::length[m], int>, quantity<isq::l
// obtaining a number
///////////////////////
static_assert(quantity<isq::length[m], int>(123 * m).number() == 123);
static_assert(quantity<isq::length[m], int>(2 * km).number() == 2000);
static_assert(quantity<isq::length[km], int>(2 * km).number() == 2);
static_assert(quantity<isq::length[km]>(1500 * m).number() == 1.5);
static_assert(quantity<isq::length[m], int>(123 * m).value() == 123);
static_assert(quantity<isq::length[m], int>(2 * km).value() == 2000);
static_assert(quantity<isq::length[km], int>(2 * km).value() == 2);
static_assert(quantity<isq::length[km]>(1500 * m).value() == 1.5);
///////////////////////////////////
// converting to a different unit
///////////////////////////////////
static_assert(quantity<isq::length[km]>(2. * km).in(km).number() == 2.);
static_assert(quantity<isq::length[km]>(2. * km).in(m).number() == 2000.);
static_assert(quantity<isq::length[m]>(2000. * m).in(km).number() == 2.);
static_assert(quantity<isq::length[km], int>(2 * km).in(km).number() == 2);
static_assert(quantity<isq::length[km], int>(2 * km).in(m).number() == 2000);
static_assert(quantity<isq::length[km]>(2. * km).in(km).value() == 2.);
static_assert(quantity<isq::length[km]>(2. * km).in(m).value() == 2000.);
static_assert(quantity<isq::length[m]>(2000. * m).in(km).value() == 2.);
static_assert(quantity<isq::length[km], int>(2 * km).in(km).value() == 2);
static_assert(quantity<isq::length[km], int>(2 * km).in(m).value() == 2000);
#if MP_UNITS_COMP_GCC != 10 || MP_UNITS_COMP_GCC_MINOR > 2
template<template<auto, typename> typename Q>
@@ -213,17 +213,17 @@ concept invalid_unit_conversion = requires {
static_assert(invalid_unit_conversion<quantity>);
#endif
static_assert(quantity<isq::length[km]>(2. * km).number_in(km) == 2.);
static_assert(quantity<isq::length[km]>(2. * km).number_in(m) == 2000.);
static_assert(quantity<isq::length[m]>(2000. * m).number_in(km) == 2.);
static_assert(quantity<isq::length[km], int>(2 * km).number_in(km) == 2);
static_assert(quantity<isq::length[km], int>(2 * km).number_in(m) == 2000);
static_assert(quantity<isq::length[km]>(2. * km).value_in(km) == 2.);
static_assert(quantity<isq::length[km]>(2. * km).value_in(m) == 2000.);
static_assert(quantity<isq::length[m]>(2000. * m).value_in(km) == 2.);
static_assert(quantity<isq::length[km], int>(2 * km).value_in(km) == 2);
static_assert(quantity<isq::length[km], int>(2 * km).value_in(m) == 2000);
#if MP_UNITS_COMP_GCC != 10 || MP_UNITS_COMP_GCC_MINOR > 2
template<template<auto, typename> typename Q>
concept invalid_getter_with_unit_conversion = requires {
requires !requires { Q<isq::length[m], int>(2000 * m).number_in(km); }; // truncating conversion
requires !requires { Q<isq::length[m], int>(2 * m).number_in(s); }; // invalid unit
requires !requires { Q<isq::length[m], int>(2000 * m).value_in(km); }; // truncating conversion
requires !requires { Q<isq::length[m], int>(2 * m).value_in(s); }; // invalid unit
};
static_assert(invalid_getter_with_unit_conversion<quantity>);
#endif
@@ -302,28 +302,28 @@ static_assert([] {
auto l1(1 * m), l2(2 * m);
return l2 = l1;
}()
.number() == 1);
.value() == 1);
static_assert([] {
const auto l1(1 * m);
auto l2(2 * m);
return l2 = l1;
}()
.number() == 1);
.value() == 1);
static_assert([]() {
auto l1(1 * m), l2(2 * m);
return l2 = std::move(l1);
}()
.number() == 1);
.value() == 1);
////////////////////
// unary operators
////////////////////
static_assert((+123 * m).number() == 123);
static_assert((-123 * m).number() == -123);
static_assert((+(-123 * m)).number() == -123);
static_assert((-(-123 * m)).number() == 123);
static_assert((+123 * m).value() == 123);
static_assert((-123 * m).value() == -123);
static_assert((+(-123 * m)).value() == -123);
static_assert((-(-123 * m)).value() == 123);
static_assert([](auto v) {
auto vv = v++;
@@ -342,7 +342,7 @@ static_assert([](auto v) {
return std::pair(v, vv);
}(123 * m) == std::pair(122 * m, 122 * m));
static_assert(is_same_v<decltype((+(short{0} * m)).number()), int&&>);
static_assert(is_same_v<decltype((+(short{0} * m)).value()), int&&>);
////////////////////////
@@ -350,29 +350,29 @@ static_assert(is_same_v<decltype((+(short{0} * m)).number()), int&&>);
////////////////////////
// same type
static_assert((1 * m += 1 * m).number() == 2);
static_assert((2 * m -= 1 * m).number() == 1);
static_assert((1 * m *= 2).number() == 2);
static_assert((2 * m /= 2).number() == 1);
static_assert((1 * m *= 2 * one).number() == 2);
static_assert((2 * m /= 2 * one).number() == 1);
static_assert((7 * m %= 2 * m).number() == 1);
static_assert((1 * m += 1 * m).value() == 2);
static_assert((2 * m -= 1 * m).value() == 1);
static_assert((1 * m *= 2).value() == 2);
static_assert((2 * m /= 2).value() == 1);
static_assert((1 * m *= 2 * one).value() == 2);
static_assert((2 * m /= 2 * one).value() == 1);
static_assert((7 * m %= 2 * m).value() == 1);
// different types
static_assert((2.5 * m += 3 * m).number() == 5.5);
static_assert((123 * m += 1 * km).number() == 1123);
static_assert((5.5 * m -= 3 * m).number() == 2.5);
static_assert((1123 * m -= 1 * km).number() == 123);
static_assert((2.5 * m *= 3).number() == 7.5);
static_assert((7.5 * m /= 3).number() == 2.5);
static_assert((2.5 * m *= 3 * one).number() == 7.5);
static_assert((7.5 * m /= 3 * one).number() == 2.5);
static_assert((3500 * m %= 1 * km).number() == 500);
static_assert((2.5 * m += 3 * m).value() == 5.5);
static_assert((123 * m += 1 * km).value() == 1123);
static_assert((5.5 * m -= 3 * m).value() == 2.5);
static_assert((1123 * m -= 1 * km).value() == 123);
static_assert((2.5 * m *= 3).value() == 7.5);
static_assert((7.5 * m /= 3).value() == 2.5);
static_assert((2.5 * m *= 3 * one).value() == 7.5);
static_assert((7.5 * m /= 3 * one).value() == 2.5);
static_assert((3500 * m %= 1 * km).value() == 500);
// static_assert((std::uint8_t(255) * m %= 256 * m).number() != [] { std::uint8_t ui(255); return ui %= 256; }()); //
// static_assert((std::uint8_t(255) * m %= 256 * m).value() != [] { std::uint8_t ui(255); return ui %= 256; }()); //
// UB
// TODO: Fix
static_assert((std::uint8_t(255) * m %= 257 * m).number() != [] {
static_assert((std::uint8_t(255) * m %= 257 * m).value() != [] {
std::uint8_t ui(255);
return ui %= 257;
}());
@@ -382,10 +382,10 @@ static_assert((std::uint8_t(255) * m %= 257 * m).number() != [] {
#ifndef MP_UNITS_COMP_MSVC
// next two lines trigger conversions warnings
// (warning disabled in CMake for this file)
static_assert((22 * m *= 33.33).number() == 733);
static_assert((22 * m /= 3.33).number() == 6);
static_assert((22 * m *= 33.33 * one).number() == 733);
static_assert((22 * m /= 3.33 * one).number() == 6);
static_assert((22 * m *= 33.33).value() == 733);
static_assert((22 * m /= 3.33).value() == 6);
static_assert((22 * m *= 33.33 * one).value() == 733);
static_assert((22 * m /= 3.33 * one).value() == 6);
#endif
template<template<auto, typename> typename Q>
@@ -510,12 +510,12 @@ static_assert(is_of_type<1 * km % (300 * m), quantity<si::metre, int>>);
static_assert(is_of_type<4 * one % (2 * one), quantity<one, int>>);
// check for integral types promotion
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).value()), int&&>);
static_assert(is_same_v<decltype((std::uint8_t(0) * m - std::uint8_t(0) * m).value()), int&&>);
static_assert((std::uint8_t(128) * m + std::uint8_t(128) * m).value() == std::uint8_t(128) + std::uint8_t(128));
static_assert((std::uint8_t(0) * m - std::uint8_t(1) * m).value() == 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()),
static_assert(is_same_v<decltype(((std::uint8_t(0) * m) % (std::uint8_t(0) * m)).value()),
decltype(std::uint8_t(0) % std::uint8_t(0))&&>);
// different representation types
@@ -589,67 +589,67 @@ static_assert(is_of_type<1 * m / (1 * s), quantity<derived_unit<struct si::metre
static_assert(is_of_type<1 * m / (1 * min), quantity<derived_unit<struct si::metre, per<struct si::minute>>{}, int>>);
static_assert(is_of_type<1 * min / (1 * m), quantity<derived_unit<struct si::minute, per<struct si::metre>>{}, int>>);
static_assert((1 * m + 1 * m).number() == 2);
static_assert((1 * m + 1 * km).number() == 1001);
static_assert((1 * km + 1 * m).number() == 1001);
static_assert((2 * m - 1 * m).number() == 1);
static_assert((1 * km - 1 * m).number() == 999);
static_assert((2 * m * 2).number() == 4);
static_assert((2 * m * (2 * one)).number() == 4);
static_assert((2 * m * (2 * percent)).number() == 4);
static_assert((3 * 3 * m).number() == 9);
static_assert(((3 * one) * (3 * m)).number() == 9);
static_assert(((3 * percent) * (3 * m)).number() == 9);
static_assert((4 * m / 2).number() == 2);
static_assert((4 * m / (2 * one)).number() == 2);
static_assert((4 * m / (2 * percent)).number() == 2);
static_assert((4 * km / (2 * m)).number() == 2);
static_assert((4000 * m / (2 * m)).number() == 2000);
static_assert((1 * m + 1 * m).value() == 2);
static_assert((1 * m + 1 * km).value() == 1001);
static_assert((1 * km + 1 * m).value() == 1001);
static_assert((2 * m - 1 * m).value() == 1);
static_assert((1 * km - 1 * m).value() == 999);
static_assert((2 * m * 2).value() == 4);
static_assert((2 * m * (2 * one)).value() == 4);
static_assert((2 * m * (2 * percent)).value() == 4);
static_assert((3 * 3 * m).value() == 9);
static_assert(((3 * one) * (3 * m)).value() == 9);
static_assert(((3 * percent) * (3 * m)).value() == 9);
static_assert((4 * m / 2).value() == 2);
static_assert((4 * m / (2 * one)).value() == 2);
static_assert((4 * m / (2 * percent)).value() == 2);
static_assert((4 * km / (2 * m)).value() == 2);
static_assert((4000 * m / (2 * m)).value() == 2000);
static_assert((1.5 * m + 1 * m).number() == 2.5);
static_assert((1.5 * m + 1 * km).number() == 1001.5);
static_assert((1.5 * km + 1 * m).number() == 1501);
static_assert((2.5 * m - 1 * m).number() == 1.5);
static_assert((1.5 * km - 1 * m).number() == 1499);
static_assert((2.5 * m * 2).number() == 5);
static_assert((2.5 * m * (2 * one)).number() == 5);
static_assert((2.5 * m * (2 * percent)).number() == 5);
static_assert((2.5L * (2 * m)).number() == 5);
static_assert((2.5L * one * (2 * m)).number() == 5);
static_assert((2.5L * percent * (2 * m)).number() == 5);
static_assert((5. * m / 2).number() == 2.5);
static_assert((5. * m / (2 * one)).number() == 2.5);
static_assert((5. * m / (2 * percent)).number() == 2.5);
static_assert((5. * km / (2 * m)).number() == 2.5);
static_assert((5000. * m / (2 * m)).number() == 2500);
static_assert((1.5 * m + 1 * m).value() == 2.5);
static_assert((1.5 * m + 1 * km).value() == 1001.5);
static_assert((1.5 * km + 1 * m).value() == 1501);
static_assert((2.5 * m - 1 * m).value() == 1.5);
static_assert((1.5 * km - 1 * m).value() == 1499);
static_assert((2.5 * m * 2).value() == 5);
static_assert((2.5 * m * (2 * one)).value() == 5);
static_assert((2.5 * m * (2 * percent)).value() == 5);
static_assert((2.5L * (2 * m)).value() == 5);
static_assert((2.5L * one * (2 * m)).value() == 5);
static_assert((2.5L * percent * (2 * m)).value() == 5);
static_assert((5. * m / 2).value() == 2.5);
static_assert((5. * m / (2 * one)).value() == 2.5);
static_assert((5. * m / (2 * percent)).value() == 2.5);
static_assert((5. * km / (2 * m)).value() == 2.5);
static_assert((5000. * m / (2 * m)).value() == 2500);
static_assert((1 * m + 1.5 * m).number() == 2.5);
static_assert((1 * m + 1.5 * km).number() == 1501);
static_assert((1 * km + 1.5 * m).number() == 1001.5);
static_assert((2 * m - 1.5 * m).number() == 0.5);
static_assert((1 * km - 1.5 * m).number() == 998.5);
static_assert((2 * m * 2.5L).number() == 5);
static_assert((2 * m * (2.5L * one)).number() == 5);
static_assert((2 * m * (2.5L * percent)).number() == 5);
static_assert((2 * 2.5 * m).number() == 5);
static_assert((2 * one * (2.5 * m)).number() == 5);
static_assert((2 * percent * (2.5 * m)).number() == 5);
static_assert((5 * m / 2.5L).number() == 2);
static_assert((5 * m / (2.5L * one)).number() == 2);
static_assert((5 * m / (2.5L * percent)).number() == 2);
static_assert((5 * km / (2.5 * m)).number() == 2);
static_assert((5000 * m / (2.5 * m)).number() == 2000);
static_assert((1 * m + 1.5 * m).value() == 2.5);
static_assert((1 * m + 1.5 * km).value() == 1501);
static_assert((1 * km + 1.5 * m).value() == 1001.5);
static_assert((2 * m - 1.5 * m).value() == 0.5);
static_assert((1 * km - 1.5 * m).value() == 998.5);
static_assert((2 * m * 2.5L).value() == 5);
static_assert((2 * m * (2.5L * one)).value() == 5);
static_assert((2 * m * (2.5L * percent)).value() == 5);
static_assert((2 * 2.5 * m).value() == 5);
static_assert((2 * one * (2.5 * m)).value() == 5);
static_assert((2 * percent * (2.5 * m)).value() == 5);
static_assert((5 * m / 2.5L).value() == 2);
static_assert((5 * m / (2.5L * one)).value() == 2);
static_assert((5 * m / (2.5L * percent)).value() == 2);
static_assert((5 * km / (2.5 * m)).value() == 2);
static_assert((5000 * m / (2.5 * m)).value() == 2000);
static_assert((7 * m % (2 * m)).number() == 1);
static_assert((7 * km % (2000 * m)).number() == 1000);
static_assert((1300 * m % (1 * km)).number() == 300);
static_assert((7 * one % (2 * one)).number() == 1);
static_assert((7 * m % (2 * m)).value() == 1);
static_assert((7 * km % (2000 * m)).value() == 1000);
static_assert((1300 * m % (1 * km)).value() == 300);
static_assert((7 * one % (2 * one)).value() == 1);
static_assert((10 * m2 * (10 * m2)) / (50 * m2) == 2 * m2);
static_assert((10 * km / (5 * m)).number() == 2);
static_assert((10 * km / (5 * m)).in(one).number() == 2000);
static_assert((10 * s * (2 * kHz)).number() == 20);
static_assert((10 * km / (5 * m)).value() == 2);
static_assert((10 * km / (5 * m)).in(one).value() == 2000);
static_assert((10 * s * (2 * kHz)).value() == 20);
// commutativity and associativity
static_assert(10 * isq::length[si::metre] / (2 * isq::time[s]) + 5 * isq::speed[m / s] == 10 * isq::speed[m / s]);
@@ -733,12 +733,12 @@ static_assert(is_same_v<decltype(0.0 * one - 0 * one), decltype(0.0 * one)>);
static_assert(1 * one - 30 * percent == (100 - 30) * percent);
static_assert(1 * one + 30 * percent == (100 + 30) * percent);
static_assert(is_same_v<decltype((std::uint8_t(0) * one + std::uint8_t(0) * one).number()), int&&>);
static_assert(is_same_v<decltype((std::uint8_t(0) * one - std::uint8_t(0) * one).number()), int&&>);
static_assert((std::uint8_t(128) * one + std::uint8_t(128) * one).number() == std::uint8_t(128) + std::uint8_t(128));
static_assert((std::uint8_t(0) * one - std::uint8_t(1) * one).number() == std::uint8_t(0) - std::uint8_t(1));
static_assert(is_same_v<decltype((std::uint8_t(0) * one + std::uint8_t(0) * one).value()), int&&>);
static_assert(is_same_v<decltype((std::uint8_t(0) * one - std::uint8_t(0) * one).value()), int&&>);
static_assert((std::uint8_t(128) * one + std::uint8_t(128) * one).value() == std::uint8_t(128) + std::uint8_t(128));
static_assert((std::uint8_t(0) * one - std::uint8_t(1) * one).value() == std::uint8_t(0) - std::uint8_t(1));
static_assert(is_same_v<decltype((std::uint8_t(0) * one % (std::uint8_t(0) * one)).number()),
static_assert(is_same_v<decltype((std::uint8_t(0) * one % (std::uint8_t(0) * one)).value()),
decltype(std::uint8_t(0) % std::uint8_t(0))&&>);
static_assert(2 * one * (1 * m) == 2 * m);
@@ -872,20 +872,20 @@ static_assert(!(123 * km >= 321'000 * m));
static_assert(is_of_type<10 * km / (5 * km), quantity<one, int>>);
static_assert((50. * m / (100. * m)).in(percent).number() == 50);
static_assert((50. * m / (100. * m)).in(percent).value() == 50);
static_assert(50. * m / (100. * m) == 50 * percent);
static_assert((50. * percent).in(one).number() == 0.5);
static_assert((50. * percent).in(one).value() == 0.5);
//////////////////
// value_cast
//////////////////
static_assert(value_cast<m>(2 * km).number() == 2000);
static_assert(value_cast<km>(2000 * m).number() == 2);
static_assert(value_cast<int>(1.23 * m).number() == 1);
static_assert(value_cast<km / h>(2000.0 * m / (3600.0 * s)).number() == 2);
static_assert(value_cast<m>(2 * km).value() == 2000);
static_assert(value_cast<km>(2000 * m).value() == 2);
static_assert(value_cast<int>(1.23 * m).value() == 1);
static_assert(value_cast<km / h>(2000.0 * m / (3600.0 * s)).value() == 2);
//////////////////
// quantity_cast