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/runtime/almost_equals.h
+2 -2
View File
@@ -36,8 +36,8 @@ struct AlmostEqualsMatcher : Catch::Matchers::MatcherGenericBase {
{
using std::abs;
using common = std::common_type_t<T, U>;
const auto x = common(target_).number();
const auto y = common(other).number();
const auto x = common(target_).value();
const auto y = common(other).value();
const auto maxXYOne = std::max({typename T::rep{1}, abs(x), abs(y)});
return abs(x - y) <= std::numeric_limits<typename T::rep>::epsilon() * maxXYOne;
}
test/unit_test/runtime/distribution_test.cpp
+4 -4
View File
@@ -559,7 +559,7 @@ TEST_CASE("piecewise_constant_distribution")
3.0 * isq::length[si::metre]};
auto stl_dist = std::piecewise_constant_distribution<rep>(intervals_rep, [](rep val) { return val; });
auto units_dist = mp_units::piecewise_constant_distribution<q>(intervals_qty, [](q qty) { return qty.number(); });
auto units_dist = mp_units::piecewise_constant_distribution<q>(intervals_qty, [](q qty) { return qty.value(); });
CHECK(units_dist.intervals() == intervals_qty_vec);
CHECK(units_dist.densities() == stl_dist.densities());
@@ -573,7 +573,7 @@ TEST_CASE("piecewise_constant_distribution")
auto stl_dist = std::piecewise_constant_distribution<rep>(nw, xmin_rep, xmax_rep, [](rep val) { return val; });
auto units_dist =
mp_units::piecewise_constant_distribution<q>(nw, xmin_qty, xmax_qty, [](q qty) { return qty.number(); });
mp_units::piecewise_constant_distribution<q>(nw, xmin_qty, xmax_qty, [](q qty) { return qty.value(); });
CHECK(units_dist.intervals() == intervals_qty_vec);
CHECK(units_dist.densities() == stl_dist.densities());
@@ -626,7 +626,7 @@ TEST_CASE("piecewise_linear_distribution")
3.0 * isq::length[si::metre]};
auto stl_dist = std::piecewise_linear_distribution<rep>(intervals_rep, [](rep val) { return val; });
auto units_dist = mp_units::piecewise_linear_distribution<q>(intervals_qty, [](q qty) { return qty.number(); });
auto units_dist = mp_units::piecewise_linear_distribution<q>(intervals_qty, [](q qty) { return qty.value(); });
CHECK(units_dist.intervals() == intervals_qty_vec);
CHECK(units_dist.densities() == stl_dist.densities());
@@ -640,7 +640,7 @@ TEST_CASE("piecewise_linear_distribution")
auto stl_dist = std::piecewise_linear_distribution<rep>(nw, xmin_rep, xmax_rep, [](rep val) { return val; });
auto units_dist =
mp_units::piecewise_linear_distribution<q>(nw, xmin_qty, xmax_qty, [](q qty) { return qty.number(); });
mp_units::piecewise_linear_distribution<q>(nw, xmin_qty, xmax_qty, [](q qty) { return qty.value(); });
CHECK(units_dist.intervals() == intervals_qty_vec);
CHECK(units_dist.densities() == stl_dist.densities());
test/unit_test/runtime/linear_algebra_test.cpp
+35 -35
View File
@@ -71,7 +71,7 @@ template<Quantity Q1, Quantity Q2>
requires(typename Q1::rep v1, typename Q2::rep v2) { cross_product(v1, v2); }
[[nodiscard]] QuantityOf<Q1::quantity_spec * Q2::quantity_spec> auto cross_product(const Q1& q1, const Q2& q2)
{
return cross_product(q1.number(), q2.number()) * (Q1::reference * Q2::reference);
return cross_product(q1.value(), q2.value()) * (Q1::reference * Q2::reference);
}
} // namespace
@@ -83,21 +83,21 @@ TEST_CASE("vector quantity", "[la]")
SECTION("non-truncating")
{
const auto v = vector<int>{3, 2, 1} * isq::position_vector[km];
CHECK(v.in(m).number() == vector<int>{3000, 2000, 1000});
CHECK(v.in(m).value() == vector<int>{3000, 2000, 1000});
}
SECTION("truncating")
{
const auto v = vector<int>{1001, 1002, 1003} * isq::position_vector[m];
CHECK(value_cast<km>(v).number() == vector<int>{1, 1, 1});
CHECK(value_cast<km>(v).value() == vector<int>{1, 1, 1});
}
}
SECTION("to scalar magnitude")
{
const auto v = vector<int>{2, 3, 6} * isq::velocity[km / h];
const auto speed = get_magnitude(v.number()) * isq::speed[v.unit]; // TODO can we do better here?
CHECK(speed.number() == 7);
const auto speed = get_magnitude(v.value()) * isq::speed[v.unit]; // TODO can we do better here?
CHECK(speed.value() == 7);
}
SECTION("multiply by scalar value")
@@ -106,14 +106,14 @@ TEST_CASE("vector quantity", "[la]")
SECTION("integral")
{
SECTION("scalar on LHS") { CHECK((2 * v).number() == vector<int>{2, 4, 6}); }
SECTION("scalar on RHS") { CHECK((v * 2).number() == vector<int>{2, 4, 6}); }
SECTION("scalar on LHS") { CHECK((2 * v).value() == vector<int>{2, 4, 6}); }
SECTION("scalar on RHS") { CHECK((v * 2).value() == vector<int>{2, 4, 6}); }
}
SECTION("floating-point")
{
SECTION("scalar on LHS") { CHECK((0.5 * v).number() == vector<double>{0.5, 1., 1.5}); }
SECTION("scalar on RHS") { CHECK((v * 0.5).number() == vector<double>{0.5, 1., 1.5}); }
SECTION("scalar on LHS") { CHECK((0.5 * v).value() == vector<double>{0.5, 1., 1.5}); }
SECTION("scalar on RHS") { CHECK((v * 0.5).value() == vector<double>{0.5, 1., 1.5}); }
}
}
@@ -121,8 +121,8 @@ TEST_CASE("vector quantity", "[la]")
{
const auto v = vector<int>{2, 4, 6} * isq::position_vector[m];
SECTION("integral") { CHECK((v / 2).number() == vector<int>{1, 2, 3}); }
SECTION("floating-point") { CHECK((v / 0.5).number() == vector<double>{4., 8., 12.}); }
SECTION("integral") { CHECK((v / 2).value() == vector<int>{1, 2, 3}); }
SECTION("floating-point") { CHECK((v / 0.5).value() == vector<double>{4., 8., 12.}); }
}
SECTION("add")
@@ -132,12 +132,12 @@ TEST_CASE("vector quantity", "[la]")
SECTION("same unit")
{
const auto u = vector<int>{3, 2, 1} * isq::position_vector[m];
CHECK((v + u).number() == vector<int>{4, 4, 4});
CHECK((v + u).value() == vector<int>{4, 4, 4});
}
SECTION("different units")
{
const auto u = vector<int>{3, 2, 1} * isq::position_vector[km];
CHECK((v + u).number() == vector<int>{3001, 2002, 1003});
CHECK((v + u).value() == vector<int>{3001, 2002, 1003});
}
}
@@ -148,12 +148,12 @@ TEST_CASE("vector quantity", "[la]")
SECTION("same unit")
{
const auto u = vector<int>{3, 2, 1} * isq::position_vector[m];
CHECK((v - u).number() == vector<int>{-2, 0, 2});
CHECK((v - u).value() == vector<int>{-2, 0, 2});
}
SECTION("different units")
{
const auto u = vector<int>{3, 2, 1} * isq::position_vector[km];
CHECK((v - u).number() == vector<int>{-2999, -1998, -997});
CHECK((v - u).value() == vector<int>{-2999, -1998, -997});
}
}
@@ -167,25 +167,25 @@ TEST_CASE("vector quantity", "[la]")
SECTION("derived_quantity_spec")
{
SECTION("scalar on LHS") { CHECK((mass * v).number() == vector<int>{2, 4, 6}); }
SECTION("scalar on RHS") { CHECK((v * mass).number() == vector<int>{2, 4, 6}); }
SECTION("scalar on LHS") { CHECK((mass * v).value() == vector<int>{2, 4, 6}); }
SECTION("scalar on RHS") { CHECK((v * mass).value() == vector<int>{2, 4, 6}); }
}
SECTION("quantity_cast to momentum")
{
SECTION("scalar on LHS") { CHECK(quantity_cast<isq::momentum>(mass * v).number() == vector<int>{2, 4, 6}); }
SECTION("scalar on RHS") { CHECK(quantity_cast<isq::momentum>(v * mass).number() == vector<int>{2, 4, 6}); }
SECTION("scalar on LHS") { CHECK(quantity_cast<isq::momentum>(mass * v).value() == vector<int>{2, 4, 6}); }
SECTION("scalar on RHS") { CHECK(quantity_cast<isq::momentum>(v * mass).value() == vector<int>{2, 4, 6}); }
}
SECTION("quantity of momentum")
{
SECTION("scalar on LHS")
{
const quantity<isq::momentum[N * s], vector<int>> momentum = mass * v;
CHECK(momentum.number() == vector<int>{2, 4, 6});
CHECK(momentum.value() == vector<int>{2, 4, 6});
}
SECTION("scalar on RHS")
{
const quantity<isq::momentum[N * s], vector<int>> momentum = v * mass;
CHECK(momentum.number() == vector<int>{2, 4, 6});
CHECK(momentum.value() == vector<int>{2, 4, 6});
}
}
}
@@ -196,18 +196,18 @@ TEST_CASE("vector quantity", "[la]")
SECTION("derived_quantity_spec")
{
SECTION("scalar on LHS") { CHECK((mass * v).number() == vector<double>{0.5, 1., 1.5}); }
SECTION("scalar on RHS") { CHECK((v * mass).number() == vector<double>{0.5, 1., 1.5}); }
SECTION("scalar on LHS") { CHECK((mass * v).value() == vector<double>{0.5, 1., 1.5}); }
SECTION("scalar on RHS") { CHECK((v * mass).value() == vector<double>{0.5, 1., 1.5}); }
}
SECTION("quantity_cast to momentum")
{
SECTION("scalar on LHS")
{
CHECK(quantity_cast<isq::momentum>(mass * v).number() == vector<double>{0.5, 1., 1.5});
CHECK(quantity_cast<isq::momentum>(mass * v).value() == vector<double>{0.5, 1., 1.5});
}
SECTION("scalar on RHS")
{
CHECK(quantity_cast<isq::momentum>(v * mass).number() == vector<double>{0.5, 1., 1.5});
CHECK(quantity_cast<isq::momentum>(v * mass).value() == vector<double>{0.5, 1., 1.5});
}
}
SECTION("quantity of momentum")
@@ -215,12 +215,12 @@ TEST_CASE("vector quantity", "[la]")
SECTION("scalar on LHS")
{
const quantity<isq::momentum[N * s], vector<double>> momentum = mass * v;
CHECK(momentum.number() == vector<double>{0.5, 1., 1.5});
CHECK(momentum.value() == vector<double>{0.5, 1., 1.5});
}
SECTION("scalar on RHS")
{
const quantity<isq::momentum[N * s], vector<double>> momentum = v * mass;
CHECK(momentum.number() == vector<double>{0.5, 1., 1.5});
CHECK(momentum.value() == vector<double>{0.5, 1., 1.5});
}
}
}
@@ -234,15 +234,15 @@ TEST_CASE("vector quantity", "[la]")
{
const auto dur = 2 * isq::duration[h];
SECTION("derived_quantity_spec") { CHECK((pos / dur).number() == vector<int>{15, 10, 5}); }
SECTION("derived_quantity_spec") { CHECK((pos / dur).value() == vector<int>{15, 10, 5}); }
SECTION("quantity_cast to velocity")
{
CHECK(quantity_cast<isq::velocity>(pos / dur).number() == vector<int>{15, 10, 5});
CHECK(quantity_cast<isq::velocity>(pos / dur).value() == vector<int>{15, 10, 5});
}
SECTION("quantity of velocity")
{
const quantity<isq::velocity[km / h], vector<int>> v = pos / dur;
CHECK(v.number() == vector<int>{15, 10, 5});
CHECK(v.value() == vector<int>{15, 10, 5});
}
}
@@ -250,15 +250,15 @@ TEST_CASE("vector quantity", "[la]")
{
const auto dur = 0.5 * isq::duration[h];
SECTION("derived_quantity_spec") { CHECK((pos / dur).number() == vector<double>{60, 40, 20}); }
SECTION("derived_quantity_spec") { CHECK((pos / dur).value() == vector<double>{60, 40, 20}); }
SECTION("quantity_cast to velocity")
{
CHECK(quantity_cast<isq::velocity>(pos / dur).number() == vector<double>{60, 40, 20});
CHECK(quantity_cast<isq::velocity>(pos / dur).value() == vector<double>{60, 40, 20});
}
SECTION("quantity of velocity")
{
const quantity<isq::velocity[km / h], vector<double>> v = pos / dur;
CHECK(v.number() == vector<double>{60, 40, 20});
CHECK(v.value() == vector<double>{60, 40, 20});
}
}
}
@@ -294,8 +294,8 @@ TEST_CASE("vector of quantities", "[la]")
SECTION("to scalar magnitude")
{
const vector<quantity<isq::velocity[km / h], int>> v = {2 * (km / h), 3 * (km / h), 6 * (km / h)};
const auto speed = get_magnitude(v).number() * isq::speed[v(0).unit]; // TODO can we do better here?
CHECK(speed.number() == 7);
const auto speed = get_magnitude(v).value() * isq::speed[v(0).unit]; // TODO can we do better here?
CHECK(speed.value() == 7);
}
SECTION("multiply by scalar value")
test/unit_test/runtime/math_test.cpp
+2 -2
View File
@@ -90,12 +90,12 @@ TEST_CASE("numeric_limits functions", "[limits]")
{
SECTION("'epsilon' works as expected using default floating type")
{
REQUIRE(epsilon<double>(isq::length[m]).number() ==
REQUIRE(epsilon<double>(isq::length[m]).value() ==
std::numeric_limits<decltype(1. * isq::length[m])::rep>::epsilon());
}
SECTION("'epsilon' works as expected using integers")
{
REQUIRE(epsilon<int>(isq::length[m]).number() == std::numeric_limits<decltype(1 * isq::length[m])::rep>::epsilon());
REQUIRE(epsilon<int>(isq::length[m]).value() == std::numeric_limits<decltype(1 * isq::length[m])::rep>::epsilon());
}
}
test/unit_test/static/quantity_point_test.cpp
+59 -59
View File
@@ -241,16 +241,16 @@ static_assert(
// static member functions
////////////////////////////
static_assert(quantity_point<isq::height[m], mean_sea_level>::zero().quantity_from_origin().number() == 0);
static_assert(quantity_point<isq::height[m], mean_sea_level>::min().quantity_from_origin().number() ==
static_assert(quantity_point<isq::height[m], mean_sea_level>::zero().quantity_from_origin().value() == 0);
static_assert(quantity_point<isq::height[m], mean_sea_level>::min().quantity_from_origin().value() ==
std::numeric_limits<double>::lowest());
static_assert(quantity_point<isq::height[m], mean_sea_level>::max().quantity_from_origin().number() ==
static_assert(quantity_point<isq::height[m], mean_sea_level>::max().quantity_from_origin().value() ==
std::numeric_limits<double>::max());
static_assert(quantity_point<isq::height[m], ground_level, int>::zero().quantity_from_origin().number() == 0);
static_assert(quantity_point<isq::height[m], ground_level, int>::min().quantity_from_origin().number() ==
static_assert(quantity_point<isq::height[m], ground_level, int>::zero().quantity_from_origin().value() == 0);
static_assert(quantity_point<isq::height[m], ground_level, int>::min().quantity_from_origin().value() ==
std::numeric_limits<int>::lowest());
static_assert(quantity_point<isq::height[m], ground_level, int>::max().quantity_from_origin().number() ==
static_assert(quantity_point<isq::height[m], ground_level, int>::max().quantity_from_origin().value() ==
std::numeric_limits<int>::max());
@@ -576,15 +576,15 @@ static_assert(is_of_type<(ground_level + isq::height(short(42) * m)).point_for(m
// converting to a different unit
///////////////////////////////////
static_assert((mean_sea_level + 2. * km).in(km).quantity_from_origin().number() == 2.);
static_assert((mean_sea_level + 2. * km).in(m).quantity_from_origin().number() == 2000.);
static_assert((mean_sea_level + 2000. * m).in(km).quantity_from_origin().number() == 2.);
static_assert((ground_level + 2. * km).in(km).quantity_from_origin().number() == 2.);
static_assert((ground_level + 2. * km).in(m).quantity_from_origin().number() == 2000.);
static_assert((ground_level + 2000. * m).in(km).quantity_from_origin().number() == 2.);
static_assert((tower_peak + 2. * km).in(km).quantity_from_origin().number() == 2.);
static_assert((tower_peak + 2. * km).in(m).quantity_from_origin().number() == 2000.);
static_assert((tower_peak + 2000. * m).in(km).quantity_from_origin().number() == 2.);
static_assert((mean_sea_level + 2. * km).in(km).quantity_from_origin().value() == 2.);
static_assert((mean_sea_level + 2. * km).in(m).quantity_from_origin().value() == 2000.);
static_assert((mean_sea_level + 2000. * m).in(km).quantity_from_origin().value() == 2.);
static_assert((ground_level + 2. * km).in(km).quantity_from_origin().value() == 2.);
static_assert((ground_level + 2. * km).in(m).quantity_from_origin().value() == 2000.);
static_assert((ground_level + 2000. * m).in(km).quantity_from_origin().value() == 2.);
static_assert((tower_peak + 2. * km).in(km).quantity_from_origin().value() == 2.);
static_assert((tower_peak + 2. * km).in(m).quantity_from_origin().value() == 2000.);
static_assert((tower_peak + 2000. * m).in(km).quantity_from_origin().value() == 2.);
#if MP_UNITS_COMP_GCC != 10 || MP_UNITS_COMP_GCC_MINOR > 2
template<template<auto, auto, typename> typename QP>
@@ -657,14 +657,14 @@ static_assert([](auto v) {
////////////////////////
// same type
static_assert((mean_sea_level + 1 * m += 1 * m).quantity_from_origin().number() == 2);
static_assert((mean_sea_level + 2 * m -= 1 * m).quantity_from_origin().number() == 1);
static_assert((mean_sea_level + 1 * m += 1 * m).quantity_from_origin().value() == 2);
static_assert((mean_sea_level + 2 * m -= 1 * m).quantity_from_origin().value() == 1);
// different types
static_assert((mean_sea_level + 2.5 * m += 3 * m).quantity_from_origin().number() == 5.5);
static_assert((mean_sea_level + 123 * m += 1 * km).quantity_from_origin().number() == 1123);
static_assert((mean_sea_level + 5.5 * m -= 3 * m).quantity_from_origin().number() == 2.5);
static_assert((mean_sea_level + 1123 * m -= 1 * km).quantity_from_origin().number() == 123);
static_assert((mean_sea_level + 2.5 * m += 3 * m).quantity_from_origin().value() == 5.5);
static_assert((mean_sea_level + 123 * m += 1 * km).quantity_from_origin().value() == 1123);
static_assert((mean_sea_level + 5.5 * m -= 3 * m).quantity_from_origin().value() == 2.5);
static_assert((mean_sea_level + 1123 * m -= 1 * km).quantity_from_origin().value() == 123);
template<template<auto, auto, typename> typename QP>
@@ -930,24 +930,24 @@ static_assert(is_of_type<(1 * m + tower_peak) - (1 * m + other_ground_level), qu
// check for integral types promotion
static_assert(
is_same_v<decltype(((mean_sea_level + std::uint8_t(0) * m) + std::uint8_t(0) * m).quantity_from_origin().number()),
is_same_v<decltype(((mean_sea_level + std::uint8_t(0) * m) + std::uint8_t(0) * m).quantity_from_origin().value()),
int&&>);
static_assert(
is_same_v<decltype((std::uint8_t(0) * m + (mean_sea_level + std::uint8_t(0) * m)).quantity_from_origin().number()),
is_same_v<decltype((std::uint8_t(0) * m + (mean_sea_level + std::uint8_t(0) * m)).quantity_from_origin().value()),
int&&>);
static_assert(
is_same_v<decltype(((mean_sea_level + std::uint8_t(0) * m) - std::uint8_t(0) * m).quantity_from_origin().number()),
is_same_v<decltype(((mean_sea_level + std::uint8_t(0) * m) - std::uint8_t(0) * m).quantity_from_origin().value()),
int&&>);
static_assert(
is_same_v<decltype(((mean_sea_level + std::uint8_t(0) * m) - (mean_sea_level + std::uint8_t(0) * m)).number()),
is_same_v<decltype(((mean_sea_level + std::uint8_t(0) * m) - (mean_sea_level + std::uint8_t(0) * m)).value()),
int&&>);
static_assert(((mean_sea_level + std::uint8_t(128) * m) + std::uint8_t(128) * m).quantity_from_origin().number() ==
static_assert(((mean_sea_level + std::uint8_t(128) * m) + std::uint8_t(128) * m).quantity_from_origin().value() ==
std::uint8_t(128) + std::uint8_t(128));
static_assert((std::uint8_t(128) * m + (mean_sea_level + std::uint8_t(128) * m)).quantity_from_origin().number() ==
static_assert((std::uint8_t(128) * m + (mean_sea_level + std::uint8_t(128) * m)).quantity_from_origin().value() ==
std::uint8_t(128) + std::uint8_t(128));
static_assert(((mean_sea_level + std::uint8_t(0) * m) - std::uint8_t(1) * m).quantity_from_origin().number() ==
static_assert(((mean_sea_level + std::uint8_t(0) * m) - std::uint8_t(1) * m).quantity_from_origin().value() ==
std::uint8_t(0) - std::uint8_t(1));
static_assert(((mean_sea_level + std::uint8_t(0) * m) - (mean_sea_level + std::uint8_t(1) * m)).number() ==
static_assert(((mean_sea_level + std::uint8_t(0) * m) - (mean_sea_level + std::uint8_t(1) * m)).value() ==
std::uint8_t(0) - std::uint8_t(1));
// different representation types
@@ -1002,39 +1002,39 @@ static_assert(is_of_type<(mean_sea_level + 1 * km) - (mean_sea_level + 1. * m),
static_assert(is_of_type<(mean_sea_level + 1. * km) - (mean_sea_level + 1. * m), quantity<si::metre, double>>);
static_assert(((mean_sea_level + 1 * m) + 1 * m).quantity_from_origin().number() == 2);
static_assert((1 * m + (mean_sea_level + 1 * m)).quantity_from_origin().number() == 2);
static_assert(((mean_sea_level + 1 * m) + 1 * km).quantity_from_origin().number() == 1001);
static_assert((1 * m + (mean_sea_level + 1 * km)).quantity_from_origin().number() == 1001);
static_assert(((mean_sea_level + 1 * km) + 1 * m).quantity_from_origin().number() == 1001);
static_assert((1 * km + (mean_sea_level + 1 * m)).quantity_from_origin().number() == 1001);
static_assert(((mean_sea_level + 2 * m) - 1 * m).quantity_from_origin().number() == 1);
static_assert(((mean_sea_level + 1 * km) - 1 * m).quantity_from_origin().number() == 999);
static_assert(((mean_sea_level + 1 * m) + 1 * m).quantity_from_origin().value() == 2);
static_assert((1 * m + (mean_sea_level + 1 * m)).quantity_from_origin().value() == 2);
static_assert(((mean_sea_level + 1 * m) + 1 * km).quantity_from_origin().value() == 1001);
static_assert((1 * m + (mean_sea_level + 1 * km)).quantity_from_origin().value() == 1001);
static_assert(((mean_sea_level + 1 * km) + 1 * m).quantity_from_origin().value() == 1001);
static_assert((1 * km + (mean_sea_level + 1 * m)).quantity_from_origin().value() == 1001);
static_assert(((mean_sea_level + 2 * m) - 1 * m).quantity_from_origin().value() == 1);
static_assert(((mean_sea_level + 1 * km) - 1 * m).quantity_from_origin().value() == 999);
static_assert(((mean_sea_level + 1.5 * m) + 1 * m).quantity_from_origin().number() == 2.5);
static_assert((1.5 * m + (mean_sea_level + 1 * m)).quantity_from_origin().number() == 2.5);
static_assert(((mean_sea_level + 1.5 * m) + 1 * km).quantity_from_origin().number() == 1001.5);
static_assert((1.5 * m + (mean_sea_level + 1 * km)).quantity_from_origin().number() == 1001.5);
static_assert(((mean_sea_level + 1.5 * km) + 1 * m).quantity_from_origin().number() == 1501);
static_assert((1.5 * km + (mean_sea_level + 1 * m)).quantity_from_origin().number() == 1501);
static_assert(((mean_sea_level + 2.5 * m) - 1 * m).quantity_from_origin().number() == 1.5);
static_assert(((mean_sea_level + 1.5 * km) - 1 * m).quantity_from_origin().number() == 1499);
static_assert(((mean_sea_level + 1.5 * m) + 1 * m).quantity_from_origin().value() == 2.5);
static_assert((1.5 * m + (mean_sea_level + 1 * m)).quantity_from_origin().value() == 2.5);
static_assert(((mean_sea_level + 1.5 * m) + 1 * km).quantity_from_origin().value() == 1001.5);
static_assert((1.5 * m + (mean_sea_level + 1 * km)).quantity_from_origin().value() == 1001.5);
static_assert(((mean_sea_level + 1.5 * km) + 1 * m).quantity_from_origin().value() == 1501);
static_assert((1.5 * km + (mean_sea_level + 1 * m)).quantity_from_origin().value() == 1501);
static_assert(((mean_sea_level + 2.5 * m) - 1 * m).quantity_from_origin().value() == 1.5);
static_assert(((mean_sea_level + 1.5 * km) - 1 * m).quantity_from_origin().value() == 1499);
static_assert(((mean_sea_level + 1 * m) + 1.5 * m).quantity_from_origin().number() == 2.5);
static_assert((1 * m + (mean_sea_level + 1.5 * m)).quantity_from_origin().number() == 2.5);
static_assert(((mean_sea_level + 1 * m) + 1.5 * km).quantity_from_origin().number() == 1501);
static_assert((1 * m + (mean_sea_level + 1.5 * km)).quantity_from_origin().number() == 1501);
static_assert(((mean_sea_level + 1 * km) + 1.5 * m).quantity_from_origin().number() == 1001.5);
static_assert((1 * km + (mean_sea_level + 1.5 * m)).quantity_from_origin().number() == 1001.5);
static_assert(((mean_sea_level + 2 * m) - 1.5 * m).quantity_from_origin().number() == 0.5);
static_assert(((mean_sea_level + 1 * km) - 1.5 * m).quantity_from_origin().number() == 998.5);
static_assert(((mean_sea_level + 1 * m) + 1.5 * m).quantity_from_origin().value() == 2.5);
static_assert((1 * m + (mean_sea_level + 1.5 * m)).quantity_from_origin().value() == 2.5);
static_assert(((mean_sea_level + 1 * m) + 1.5 * km).quantity_from_origin().value() == 1501);
static_assert((1 * m + (mean_sea_level + 1.5 * km)).quantity_from_origin().value() == 1501);
static_assert(((mean_sea_level + 1 * km) + 1.5 * m).quantity_from_origin().value() == 1001.5);
static_assert((1 * km + (mean_sea_level + 1.5 * m)).quantity_from_origin().value() == 1001.5);
static_assert(((mean_sea_level + 2 * m) - 1.5 * m).quantity_from_origin().value() == 0.5);
static_assert(((mean_sea_level + 1 * km) - 1.5 * m).quantity_from_origin().value() == 998.5);
static_assert(((mean_sea_level + 2 * m) - (mean_sea_level + 1 * m)).number() == 1);
static_assert(((mean_sea_level + 1 * km) - (mean_sea_level + 1 * m)).number() == 999);
static_assert(((mean_sea_level + 2.5 * m) - (mean_sea_level + 1 * m)).number() == 1.5);
static_assert(((mean_sea_level + 1.5 * km) - (mean_sea_level + 1 * m)).number() == 1499);
static_assert(((mean_sea_level + 2 * m) - (mean_sea_level + 1.5 * m)).number() == 0.5);
static_assert(((mean_sea_level + 1 * km) - (mean_sea_level + 1.5 * m)).number() == 998.5);
static_assert(((mean_sea_level + 2 * m) - (mean_sea_level + 1 * m)).value() == 1);
static_assert(((mean_sea_level + 1 * km) - (mean_sea_level + 1 * m)).value() == 999);
static_assert(((mean_sea_level + 2.5 * m) - (mean_sea_level + 1 * m)).value() == 1.5);
static_assert(((mean_sea_level + 1.5 * km) - (mean_sea_level + 1 * m)).value() == 1499);
static_assert(((mean_sea_level + 2 * m) - (mean_sea_level + 1.5 * m)).value() == 0.5);
static_assert(((mean_sea_level + 1 * km) - (mean_sea_level + 1.5 * m)).value() == 998.5);
static_assert((mean_sea_level + 42 * m) - (ground_level + 42 * m) == -42 * m);
static_assert((ground_level + 42 * m) - (mean_sea_level + 42 * m) == 42 * m);
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