mpusz/mp-units
1
0
Fork 1
mirror of https://github.com/mpusz/mp-units.git synced 2025-08-05 13:14:29 +02:00
Code Issues Packages Projects Releases Wiki Activity

refactor: quantity_point::quantity_from_origin() refactored to quantity_point::quantity_ref_from(PO)

Browse Source 
Resolves #479 and relates to #477
This commit is contained in:
Mateusz Pusz
2023-08-27 21:16:29 +02:00
parent a7711cb301
commit 3b2ca4084a
9 changed files with 191 additions and 147 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
example/currency.cpp
View File

@@ -93,6 +93,6 @@ int main()
quantity_point price_usd = zero + 100 * us_dollar; quantity_point price_usd = zero + 100 * us_dollar;
quantity_point price_euro = exchange_to<euro>(price_usd); quantity_point price_euro = exchange_to<euro>(price_usd);
std::cout << price_usd.quantity_from_origin() << " -> " << price_euro.quantity_from_origin() << "\n"; std::cout << price_usd.quantity_ref_from(zero) << " -> " << price_euro.quantity_ref_from(zero) << "\n";
// std::cout << price_usd.quantity_from_origin() + price_euro.quantity_from_origin() << "\n"; // does not compile // std::cout << price_usd.quantity_ref_from(zero) + price_euro.quantity_ref_from(zero) << "\n"; // does not compile
} }

14
example/include/geographic.h
View File

@@ -138,7 +138,7 @@ struct MP_UNITS_STD_FMT::formatter<geographic::latitude<T>> :
auto format(geographic::latitude<T> lat, FormatContext& ctx) auto format(geographic::latitude<T> lat, FormatContext& ctx)
{ {
formatter<typename geographic::latitude<T>::quantity_type>::format( formatter<typename geographic::latitude<T>::quantity_type>::format(
is_gt_zero(lat) ? lat.quantity_from_origin() : -lat.quantity_from_origin(), ctx); is_gt_zero(lat) ? lat.quantity_ref_from(geographic::equator) : -lat.quantity_ref_from(geographic::equator), ctx);
MP_UNITS_STD_FMT::format_to(ctx.out(), "{}", is_gt_zero(lat) ? " N" : "S"); MP_UNITS_STD_FMT::format_to(ctx.out(), "{}", is_gt_zero(lat) ? " N" : "S");
return ctx.out(); return ctx.out();
} }
@@ -151,7 +151,9 @@ struct MP_UNITS_STD_FMT::formatter<geographic::longitude<T>> :
auto format(geographic::longitude<T> lon, FormatContext& ctx) auto format(geographic::longitude<T> lon, FormatContext& ctx)
{ {
formatter<typename geographic::longitude<T>::quantity_type>::format( formatter<typename geographic::longitude<T>::quantity_type>::format(
is_gt_zero(lon) ? lon.quantity_from_origin() : -lon.quantity_from_origin(), ctx); is_gt_zero(lon) ? lon.quantity_ref_from(geographic::prime_meridian)
: -lon.quantity_ref_from(geographic::prime_meridian),
ctx);
MP_UNITS_STD_FMT::format_to(ctx.out(), "{}", is_gt_zero(lon) ? " E" : " W"); MP_UNITS_STD_FMT::format_to(ctx.out(), "{}", is_gt_zero(lon) ? " E" : " W");
return ctx.out(); return ctx.out();
} }
@@ -175,10 +177,10 @@ distance spherical_distance(position<T> from, position<T> to)
using isq::sin, isq::cos, isq::asin, isq::acos; using isq::sin, isq::cos, isq::asin, isq::acos;
const auto& from_lat = from.lat.quantity_from_origin(); const auto& from_lat = from.lat.quantity_ref_from(equator);
const auto& from_lon = from.lon.quantity_from_origin(); const auto& from_lon = from.lon.quantity_ref_from(prime_meridian);
const auto& to_lat = to.lat.quantity_from_origin(); const auto& to_lat = to.lat.quantity_ref_from(equator);
const auto& to_lon = to.lon.quantity_from_origin(); const auto& to_lon = to.lon.quantity_ref_from(prime_meridian);
// https://en.wikipedia.org/wiki/Great-circle_distance#Formulae // https://en.wikipedia.org/wiki/Great-circle_distance#Formulae
if constexpr (sizeof(T) >= 8) { if constexpr (sizeof(T) >= 8) {

2
example/kalman_filter/kalman.h
View File

@@ -212,7 +212,7 @@ struct MP_UNITS_STD_FMT::formatter<kalman::estimation<Q>> {
if constexpr (mp_units::Quantity<Q>) if constexpr (mp_units::Quantity<Q>)
return t; return t;
else else
return t.quantity_from_origin(); return t.quantity_ref_from(t.point_origin);
}(kalman::get<0>(e.state)); }(kalman::get<0>(e.state));
std::string value_buffer; std::string value_buffer;

2
example/kalman_filter/kalman_filter-example_6.cpp
View File

@@ -45,7 +45,7 @@ template<QuantityPoint QP, QuantityOf<dimensionless> K>
void print(auto iteration, K gain, QP measured, kalman::estimation<QP> current, kalman::estimation<QP> next) void print(auto iteration, K gain, QP measured, kalman::estimation<QP> current, kalman::estimation<QP> next)
{ {
std::cout << MP_UNITS_STD_FMT::format("{:2} | {:7%.4Q} | {:10%.3Q %q} | {:>18.3} | {:>18.3}\n", iteration, gain, std::cout << MP_UNITS_STD_FMT::format("{:2} | {:7%.4Q} | {:10%.3Q %q} | {:>18.3} | {:>18.3}\n", iteration, gain,
measured.quantity_from_origin(), current, next); measured.quantity_ref_from(QP::point_origin), current, next);
} }
int main() int main()

2
example/kalman_filter/kalman_filter-example_7.cpp
View File

@@ -45,7 +45,7 @@ template<QuantityPoint QP, QuantityOf<dimensionless> K>
void print(auto iteration, K gain, QP measured, kalman::estimation<QP> current, kalman::estimation<QP> next) void print(auto iteration, K gain, QP measured, kalman::estimation<QP> current, kalman::estimation<QP> next)
{ {
std::cout << MP_UNITS_STD_FMT::format("{:2} | {:7%.4Q} | {:10%.3Q %q} | {:>18.3} | {:>18.3}\n", iteration, gain, std::cout << MP_UNITS_STD_FMT::format("{:2} | {:7%.4Q} | {:10%.3Q %q} | {:>18.3} | {:>18.3}\n", iteration, gain,
measured.quantity_from_origin(), current, next); measured.quantity_ref_from(QP::point_origin), current, next);
} }
int main() int main()

2
example/kalman_filter/kalman_filter-example_8.cpp
View File

@@ -45,7 +45,7 @@ template<QuantityPoint QP, QuantityOf<dimensionless> K>
void print(auto iteration, K gain, QP measured, kalman::estimation<QP> current, kalman::estimation<QP> next) void print(auto iteration, K gain, QP measured, kalman::estimation<QP> current, kalman::estimation<QP> next)
{ {
std::cout << MP_UNITS_STD_FMT::format("{:2} | {:7%.3Q} | {:10%.3Q %q} | {:>16.2} | {:>16.2}\n", iteration, gain, std::cout << MP_UNITS_STD_FMT::format("{:2} | {:7%.3Q} | {:10%.3Q %q} | {:>16.2} | {:>16.2}\n", iteration, gain,
measured.quantity_from_origin(), current, next); measured.quantity_ref_from(QP::point_origin), current, next);
} }
int main() int main()

8
example/unmanned_aerial_vehicle.cpp
View File

@@ -97,8 +97,8 @@ template<earth_gravity_model M>
hae_altitude<M> to_hae(msl_altitude msl, position<long double> pos) hae_altitude<M> to_hae(msl_altitude msl, position<long double> pos)
{ {
const auto geoid_undulation = const auto geoid_undulation =
isq::height(GeographicLibWhatsMyOffset(pos.lat.quantity_from_origin().numerical_value_in(si::degree), isq::height(GeographicLibWhatsMyOffset(pos.lat.quantity_ref_from(equator).numerical_value_in(si::degree),
pos.lon.quantity_from_origin().numerical_value_in(si::degree)) * pos.lon.quantity_ref_from(prime_meridian).numerical_value_in(si::degree)) *
si::metre); si::metre);
return height_above_ellipsoid<M> + (msl - mean_sea_level - geoid_undulation); return height_above_ellipsoid<M> + (msl - mean_sea_level - geoid_undulation);
} }
@@ -115,7 +115,7 @@ using hal_altitude = quantity_point<isq::altitude[si::metre], height_above_launc
template<class CharT, class Traits> template<class CharT, class Traits>
std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& os, const hal_altitude& a) std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& os, const hal_altitude& a)
{ {
return os << a.quantity_from_origin() << " HAL"; return os << a.quantity_ref_from(height_above_launch) << " HAL";
} }
template<> template<>
@@ -123,7 +123,7 @@ struct MP_UNITS_STD_FMT::formatter<hal_altitude> : formatter<hal_altitude::quant
template<typename FormatContext> template<typename FormatContext>
auto format(const hal_altitude& a, FormatContext& ctx) auto format(const hal_altitude& a, FormatContext& ctx)
{ {
formatter<hal_altitude::quantity_type>::format(a.quantity_from_origin(), ctx); formatter<hal_altitude::quantity_type>::format(a.quantity_ref_from(height_above_launch), ctx);
return MP_UNITS_STD_FMT::format_to(ctx.out(), " HAL"); return MP_UNITS_STD_FMT::format_to(ctx.out(), " HAL");
} }
}; };

65
src/core/include/mp-units/quantity_point.h
View File

@@ -115,7 +115,7 @@ public:
q_([&] { q_([&] {
if constexpr (is_same_v<std::remove_const_t<decltype(point_origin)>, if constexpr (is_same_v<std::remove_const_t<decltype(point_origin)>,
std::remove_const_t<decltype(QP::point_origin)>>) std::remove_const_t<decltype(QP::point_origin)>>)
return qp.quantity_from_origin(); return qp.quantity_ref_from(point_origin);
else else
return qp - point_origin; return qp - point_origin;
}()) }())
@@ -146,23 +146,39 @@ public:
// data access // data access
#ifdef __cpp_explicit_this_parameter #ifdef __cpp_explicit_this_parameter
template<typename Self> template<typename Self, std::same_as<std::remove_const_t<decltype(PO)>> PO2>
[[nodiscard]] constexpr auto&& quantity_from_origin(this Self&& self) noexcept [[nodiscard]] constexpr auto&& quantity_ref_from(this Self&& self, PO2) noexcept
{ {
return std::forward<Self>(self).q_; return std::forward<Self>(self).q_;
} }
#else #else
[[nodiscard]] constexpr quantity_type& quantity_from_origin() & noexcept { return q_; } template<std::same_as<std::remove_const_t<decltype(PO)>> PO2>
[[nodiscard]] constexpr const quantity_type& quantity_from_origin() const& noexcept { return q_; } [[nodiscard]] constexpr quantity_type& quantity_ref_from(PO2) & noexcept
[[nodiscard]] constexpr quantity_type&& quantity_from_origin() && noexcept { return std::move(q_); } {
[[nodiscard]] constexpr const quantity_type&& quantity_from_origin() const&& noexcept { return std::move(q_); } return q_;
}
template<std::same_as<std::remove_const_t<decltype(PO)>> PO2>
[[nodiscard]] constexpr const quantity_type& quantity_ref_from(PO2) const& noexcept
{
return q_;
}
template<std::same_as<std::remove_const_t<decltype(PO)>> PO2>
[[nodiscard]] constexpr quantity_type&& quantity_ref_from(PO2) && noexcept
{
return std::move(q_);
}
template<std::same_as<std::remove_const_t<decltype(PO)>> PO2>
[[nodiscard]] constexpr const quantity_type&& quantity_ref_from(PO2) const&& noexcept
{
return std::move(q_);
}
#endif #endif
template<Unit U> template<Unit U>
requires detail::QuantityConvertibleTo<quantity_type, quantity<::mp_units::reference<quantity_spec, U{}>{}, Rep>> requires detail::QuantityConvertibleTo<quantity_type, quantity<::mp_units::reference<quantity_spec, U{}>{}, Rep>>
[[nodiscard]] constexpr quantity_point<::mp_units::reference<quantity_spec, U{}>{}, PO, Rep> in(U) const [[nodiscard]] constexpr quantity_point<::mp_units::reference<quantity_spec, U{}>{}, PO, Rep> in(U) const
{ {
return make_quantity_point<PO>(quantity_from_origin().in(U{})); return make_quantity_point<PO>(quantity_ref_from(PO).in(U{}));
} }
// member unary operators // member unary operators
@@ -235,9 +251,9 @@ template<auto R1, auto PO1, typename Rep1, auto R2, typename Rep2>
requires ReferenceOf<std::remove_const_t<decltype(R2)>, PO1.quantity_spec> requires ReferenceOf<std::remove_const_t<decltype(R2)>, PO1.quantity_spec>
[[nodiscard]] constexpr QuantityPoint auto operator+(const quantity_point<R1, PO1, Rep1>& qp, [[nodiscard]] constexpr QuantityPoint auto operator+(const quantity_point<R1, PO1, Rep1>& qp,
const quantity<R2, Rep2>& q) const quantity<R2, Rep2>& q)
requires requires { qp.quantity_from_origin() + q; } requires requires { qp.quantity_ref_from(PO1) + q; }
{ {
return make_quantity_point<PO1>(qp.quantity_from_origin() + q); return make_quantity_point<PO1>(qp.quantity_ref_from(PO1) + q);
} }
template<auto R1, typename Rep1, auto R2, auto PO2, typename Rep2> template<auto R1, typename Rep1, auto R2, auto PO2, typename Rep2>
@@ -245,7 +261,7 @@ template<auto R1, typename Rep1, auto R2, auto PO2, typename Rep2>
requires ReferenceOf<std::remove_const_t<decltype(R1)>, PO2.quantity_spec> requires ReferenceOf<std::remove_const_t<decltype(R1)>, PO2.quantity_spec>
[[nodiscard]] constexpr QuantityPoint auto operator+(const quantity<R1, Rep1>& q, [[nodiscard]] constexpr QuantityPoint auto operator+(const quantity<R1, Rep1>& q,
const quantity_point<R2, PO2, Rep2>& qp) const quantity_point<R2, PO2, Rep2>& qp)
requires requires { q + qp.quantity_from_origin(); } requires requires { q + qp.quantity_ref_from(PO2); }
{ {
return qp + q; return qp + q;
} }
@@ -269,9 +285,9 @@ template<auto R1, auto PO1, typename Rep1, auto R2, typename Rep2>
requires ReferenceOf<std::remove_const_t<decltype(R2)>, PO1.quantity_spec> requires ReferenceOf<std::remove_const_t<decltype(R2)>, PO1.quantity_spec>
[[nodiscard]] constexpr QuantityPoint auto operator-(const quantity_point<R1, PO1, Rep1>& qp, [[nodiscard]] constexpr QuantityPoint auto operator-(const quantity_point<R1, PO1, Rep1>& qp,
const quantity<R2, Rep2>& q) const quantity<R2, Rep2>& q)
requires requires { qp.quantity_from_origin() - q; } requires requires { qp.quantity_ref_from(PO1) - q; }
{ {
return make_quantity_point<PO1>(qp.quantity_from_origin() - q); return make_quantity_point<PO1>(qp.quantity_ref_from(PO1) - q);
} }
template<PointOrigin PO, Quantity Q> template<PointOrigin PO, Quantity Q>
@@ -285,13 +301,14 @@ template<PointOrigin PO, Quantity Q>
template<QuantityPoint QP1, QuantityPointOf<QP1::absolute_point_origin> QP2> template<QuantityPoint QP1, QuantityPointOf<QP1::absolute_point_origin> QP2>
[[nodiscard]] constexpr Quantity auto operator-(const QP1& lhs, const QP2& rhs) [[nodiscard]] constexpr Quantity auto operator-(const QP1& lhs, const QP2& rhs)
// TODO consider constraining it for both branches // TODO consider constraining it for both branches
requires requires { lhs.quantity_from_origin() - rhs.quantity_from_origin(); } requires requires { lhs.quantity_ref_from(QP1::point_origin) - rhs.quantity_ref_from(QP2::point_origin); }
{ {
if constexpr (is_same_v<std::remove_const_t<decltype(QP1::point_origin)>, if constexpr (is_same_v<std::remove_const_t<decltype(QP1::point_origin)>,
std::remove_const_t<decltype(QP2::point_origin)>>) std::remove_const_t<decltype(QP2::point_origin)>>)
return lhs.quantity_from_origin() - rhs.quantity_from_origin(); return lhs.quantity_ref_from(QP1::point_origin) - rhs.quantity_ref_from(QP2::point_origin);
else else
return lhs.quantity_from_origin() - rhs.quantity_from_origin() + (lhs.point_origin - rhs.point_origin); return lhs.quantity_ref_from(QP1::point_origin) - rhs.quantity_ref_from(QP2::point_origin) +
(lhs.point_origin - rhs.point_origin);
} }
template<PointOrigin PO, QuantityPointOf<PO{}> QP> template<PointOrigin PO, QuantityPointOf<PO{}> QP>
@@ -299,19 +316,21 @@ template<PointOrigin PO, QuantityPointOf<PO{}> QP>
[[nodiscard]] constexpr Quantity auto operator-(const QP& qp, PO po) [[nodiscard]] constexpr Quantity auto operator-(const QP& qp, PO po)
{ {
if constexpr (is_same_v<std::remove_const_t<decltype(QP::point_origin)>, std::remove_const_t<PO>>) if constexpr (is_same_v<std::remove_const_t<decltype(QP::point_origin)>, std::remove_const_t<PO>>)
return qp.quantity_from_origin(); return qp.quantity_ref_from(QP::point_origin);
else if constexpr (detail::is_derived_from_specialization_of_absolute_point_origin<PO>) { else if constexpr (detail::is_derived_from_specialization_of_absolute_point_origin<PO>) {
if constexpr (is_same_v<std::remove_const_t<decltype(QP::point_origin)>, if constexpr (is_same_v<std::remove_const_t<decltype(QP::point_origin)>,
std::remove_const_t<decltype(QP::absolute_point_origin)>>) std::remove_const_t<decltype(QP::absolute_point_origin)>>)
return qp.quantity_from_origin(); return qp.quantity_ref_from(QP::point_origin);
else else
return qp.quantity_from_origin() + (qp.point_origin - qp.absolute_point_origin); return qp.quantity_ref_from(QP::point_origin) + (qp.point_origin - qp.absolute_point_origin);
} else { } else {
if constexpr (is_same_v<std::remove_const_t<decltype(QP::point_origin)>, if constexpr (is_same_v<std::remove_const_t<decltype(QP::point_origin)>,
std::remove_const_t<decltype(po.quantity_point.point_origin)>>) std::remove_const_t<decltype(po.quantity_point.point_origin)>>)
return qp.quantity_from_origin() - po.quantity_point.quantity_from_origin(); return qp.quantity_ref_from(QP::point_origin) -
po.quantity_point.quantity_ref_from(po.quantity_point.point_origin);
else else
return qp.quantity_from_origin() - po.quantity_point.quantity_from_origin() + return qp.quantity_ref_from(QP::point_origin) -
po.quantity_point.quantity_ref_from(po.quantity_point.point_origin) +
(qp.point_origin - po.quantity_point.point_origin); (qp.point_origin - po.quantity_point.point_origin);
} }
} }
@@ -344,7 +363,7 @@ template<QuantityPoint QP1, QuantityPointOf<QP1::absolute_point_origin> QP2>
{ {
if constexpr (is_same_v<std::remove_const_t<decltype(QP1::point_origin)>, if constexpr (is_same_v<std::remove_const_t<decltype(QP1::point_origin)>,
std::remove_const_t<decltype(QP2::point_origin)>>) std::remove_const_t<decltype(QP2::point_origin)>>)
return lhs.quantity_from_origin() <=> rhs.quantity_from_origin(); return lhs.quantity_ref_from(QP1::point_origin) <=> rhs.quantity_ref_from(QP2::point_origin);
else else
return lhs - lhs.absolute_point_origin <=> rhs - rhs.absolute_point_origin; return lhs - lhs.absolute_point_origin <=> rhs - rhs.absolute_point_origin;
} }
@@ -355,7 +374,7 @@ template<QuantityPoint QP1, QuantityPointOf<QP1::absolute_point_origin> QP2>
{ {
if constexpr (is_same_v<std::remove_const_t<decltype(QP1::point_origin)>, if constexpr (is_same_v<std::remove_const_t<decltype(QP1::point_origin)>,
std::remove_const_t<decltype(QP2::point_origin)>>) std::remove_const_t<decltype(QP2::point_origin)>>)
return lhs.quantity_from_origin() == rhs.quantity_from_origin(); return lhs.quantity_ref_from(QP1::point_origin) == rhs.quantity_ref_from(QP2::point_origin);
else else
return lhs - lhs.absolute_point_origin == rhs - rhs.absolute_point_origin; return lhs - lhs.absolute_point_origin == rhs - rhs.absolute_point_origin;
} }

239
test/unit_test/static/quantity_point_test.cpp
View File

@@ -241,19 +241,26 @@ static_assert(
// static member functions // static member functions
//////////////////////////// ////////////////////////////
static_assert(quantity_point<isq::height[m], mean_sea_level>::zero().quantity_from_origin().numerical_value_ref_in(m) == static_assert(
0); quantity_point<isq::height[m], mean_sea_level>::zero().quantity_ref_from(mean_sea_level).numerical_value_ref_in(m) ==
static_assert(quantity_point<isq::height[m], mean_sea_level>::min().quantity_from_origin().numerical_value_ref_in(m) == 0);
std::numeric_limits<double>::lowest()); static_assert(
static_assert(quantity_point<isq::height[m], mean_sea_level>::max().quantity_from_origin().numerical_value_ref_in(m) == quantity_point<isq::height[m], mean_sea_level>::min().quantity_ref_from(mean_sea_level).numerical_value_ref_in(m) ==
std::numeric_limits<double>::max()); std::numeric_limits<double>::lowest());
static_assert(
quantity_point<isq::height[m], mean_sea_level>::max().quantity_ref_from(mean_sea_level).numerical_value_ref_in(m) ==
std::numeric_limits<double>::max());
static_assert( static_assert(
quantity_point<isq::height[m], ground_level, int>::zero().quantity_from_origin().numerical_value_ref_in(m) == 0);
static_assert(quantity_point<isq::height[m], ground_level, int>::min().quantity_from_origin().numerical_value_ref_in( quantity_point<isq::height[m], ground_level, int>::zero().quantity_ref_from(ground_level).numerical_value_ref_in(m) ==
m) == std::numeric_limits<int>::lowest()); 0);
static_assert(quantity_point<isq::height[m], ground_level, int>::max().quantity_from_origin().numerical_value_ref_in( static_assert(
m) == std::numeric_limits<int>::max()); quantity_point<isq::height[m], ground_level, int>::min().quantity_ref_from(ground_level).numerical_value_ref_in(m) ==
std::numeric_limits<int>::lowest());
static_assert(
quantity_point<isq::height[m], ground_level, int>::max().quantity_ref_from(ground_level).numerical_value_ref_in(m) ==
std::numeric_limits<int>::max());
////////////////////////////// //////////////////////////////
@@ -539,36 +546,42 @@ static_assert(
// obtaining a relative quantity // obtaining a relative quantity
////////////////////////////////// //////////////////////////////////
static_assert((mean_sea_level + 42 * m).quantity_from_origin() == 42 * m); static_assert((mean_sea_level + 42 * m).quantity_ref_from(mean_sea_level) == 42 * m);
static_assert((mean_sea_level + isq::height(42 * m)).quantity_from_origin() == 42 * m); static_assert((mean_sea_level + isq::height(42 * m)).quantity_ref_from(mean_sea_level) == 42 * m);
static_assert((zero + 1 * one).quantity_from_origin() == 1 * one); static_assert((zero + 1 * one).quantity_ref_from(zero) == 1 * one);
static_assert((zero + dimensionless(1 * one)).quantity_from_origin() == 1 * one); static_assert((zero + dimensionless(1 * one)).quantity_ref_from(zero) == 1 * one);
static_assert((mean_sea_level + 42 * m).quantity_from_origin() == 42 * m); static_assert((mean_sea_level + 42 * m).quantity_ref_from(mean_sea_level) == 42 * m);
static_assert((ground_level + 42 * m).quantity_from_origin() == 42 * m); static_assert((ground_level + 42 * m).quantity_ref_from(ground_level) == 42 * m);
static_assert((tower_peak + 42 * m).quantity_from_origin() == 42 * m); static_assert((tower_peak + 42 * m).quantity_ref_from(tower_peak) == 42 * m);
static_assert(quantity_point<isq::height[m], mean_sea_level>(ground_level + 42 * m).quantity_from_origin() == 84 * m); static_assert(quantity_point<isq::height[m], mean_sea_level>(ground_level + 42 * m).quantity_ref_from(mean_sea_level) ==
static_assert(quantity_point<isq::height[m], mean_sea_level>(tower_peak + 42 * m).quantity_from_origin() == 126 * m); 84 * m);
static_assert(quantity_point<isq::height[m], mean_sea_level>(tower_peak + 42 * m).quantity_ref_from(mean_sea_level) ==
126 * m);
static_assert(quantity_point<isq::height[m], ground_level>(mean_sea_level + 84 * m).quantity_from_origin() == 42 * m); static_assert(quantity_point<isq::height[m], ground_level>(mean_sea_level + 84 * m).quantity_ref_from(ground_level) ==
static_assert(quantity_point<isq::height[m], ground_level>(tower_peak + 42 * m).quantity_from_origin() == 84 * m); 42 * m);
static_assert(quantity_point<isq::height[m], ground_level>(tower_peak + 42 * m).quantity_ref_from(ground_level) ==
84 * m);
static_assert(quantity_point<isq::height[m], tower_peak>(mean_sea_level + 42 * m).quantity_from_origin() == -42 * m); static_assert(quantity_point<isq::height[m], tower_peak>(mean_sea_level + 42 * m).quantity_ref_from(tower_peak) ==
static_assert(quantity_point<isq::height[m], tower_peak>(ground_level + 84 * m).quantity_from_origin() == 42 * m); -42 * m);
static_assert(quantity_point<isq::height[m], tower_peak>(ground_level + 84 * m).quantity_ref_from(tower_peak) ==
42 * m);
static_assert((mean_sea_level + 42 * m).point_for(mean_sea_level).quantity_from_origin() == 42 * m); static_assert((mean_sea_level + 42 * m).point_for(mean_sea_level).quantity_ref_from(mean_sea_level) == 42 * m);
static_assert((ground_level + 42 * m).point_for(mean_sea_level).quantity_from_origin() == 84 * m); static_assert((ground_level + 42 * m).point_for(mean_sea_level).quantity_ref_from(mean_sea_level) == 84 * m);
static_assert((tower_peak + 42 * m).point_for(mean_sea_level).quantity_from_origin() == 126 * m); static_assert((tower_peak + 42 * m).point_for(mean_sea_level).quantity_ref_from(mean_sea_level) == 126 * m);
static_assert((ground_level + 84 * m).point_for(ground_level).quantity_from_origin() == 84 * m); static_assert((ground_level + 84 * m).point_for(ground_level).quantity_ref_from(ground_level) == 84 * m);
static_assert((mean_sea_level + 84 * m).point_for(ground_level).quantity_from_origin() == 42 * m); static_assert((mean_sea_level + 84 * m).point_for(ground_level).quantity_ref_from(ground_level) == 42 * m);
static_assert((tower_peak + 42 * m).point_for(ground_level).quantity_from_origin() == 84 * m); static_assert((tower_peak + 42 * m).point_for(ground_level).quantity_ref_from(ground_level) == 84 * m);
static_assert((tower_peak + 42 * m).point_for(tower_peak).quantity_from_origin() == 42 * m); static_assert((tower_peak + 42 * m).point_for(tower_peak).quantity_ref_from(tower_peak) == 42 * m);
static_assert((mean_sea_level + 42 * m).point_for(tower_peak).quantity_from_origin() == -42 * m); static_assert((mean_sea_level + 42 * m).point_for(tower_peak).quantity_ref_from(tower_peak) == -42 * m);
static_assert((ground_level + 84 * m).point_for(tower_peak).quantity_from_origin() == 42 * m); static_assert((ground_level + 84 * m).point_for(tower_peak).quantity_ref_from(tower_peak) == 42 * m);
static_assert(is_of_type<(ground_level + isq::height(short(42) * m)).point_for(mean_sea_level), static_assert(is_of_type<(ground_level + isq::height(short(42) * m)).point_for(mean_sea_level),
quantity_point<isq::height[m], mean_sea_level, int>>); quantity_point<isq::height[m], mean_sea_level, int>>);
@@ -578,15 +591,15 @@ static_assert(is_of_type<(ground_level + isq::height(short(42) * m)).point_for(m
// converting to a different unit // converting to a different unit
/////////////////////////////////// ///////////////////////////////////
static_assert((mean_sea_level + 2. * km).in(km).quantity_from_origin().numerical_value_ref_in(km) == 2.); static_assert((mean_sea_level + 2. * km).in(km).quantity_ref_from(mean_sea_level).numerical_value_ref_in(km) == 2.);
static_assert((mean_sea_level + 2. * km).in(m).quantity_from_origin().numerical_value_ref_in(m) == 2000.); static_assert((mean_sea_level + 2. * km).in(m).quantity_ref_from(mean_sea_level).numerical_value_ref_in(m) == 2000.);
static_assert((mean_sea_level + 2000. * m).in(km).quantity_from_origin().numerical_value_ref_in(km) == 2.); static_assert((mean_sea_level + 2000. * m).in(km).quantity_ref_from(mean_sea_level).numerical_value_ref_in(km) == 2.);
static_assert((ground_level + 2. * km).in(km).quantity_from_origin().numerical_value_ref_in(km) == 2.); static_assert((ground_level + 2. * km).in(km).quantity_ref_from(ground_level).numerical_value_ref_in(km) == 2.);
static_assert((ground_level + 2. * km).in(m).quantity_from_origin().numerical_value_ref_in(m) == 2000.); static_assert((ground_level + 2. * km).in(m).quantity_ref_from(ground_level).numerical_value_ref_in(m) == 2000.);
static_assert((ground_level + 2000. * m).in(km).quantity_from_origin().numerical_value_ref_in(km) == 2.); static_assert((ground_level + 2000. * m).in(km).quantity_ref_from(ground_level).numerical_value_ref_in(km) == 2.);
static_assert((tower_peak + 2. * km).in(km).quantity_from_origin().numerical_value_ref_in(km) == 2.); static_assert((tower_peak + 2. * km).in(km).quantity_ref_from(tower_peak).numerical_value_ref_in(km) == 2.);
static_assert((tower_peak + 2. * km).in(m).quantity_from_origin().numerical_value_ref_in(m) == 2000.); static_assert((tower_peak + 2. * km).in(m).quantity_ref_from(tower_peak).numerical_value_ref_in(m) == 2000.);
static_assert((tower_peak + 2000. * m).in(km).quantity_from_origin().numerical_value_ref_in(km) == 2.); static_assert((tower_peak + 2000. * m).in(km).quantity_ref_from(tower_peak).numerical_value_ref_in(km) == 2.);
#if MP_UNITS_COMP_GCC != 10 || MP_UNITS_COMP_GCC_MINOR > 2 #if MP_UNITS_COMP_GCC != 10 || MP_UNITS_COMP_GCC_MINOR > 2
template<template<auto, auto, typename> typename QP> template<template<auto, auto, typename> typename QP>
@@ -618,18 +631,18 @@ static_assert(([]() {
quantity_point l1{mean_sea_level + 1 * m}, l2{mean_sea_level + 2 * m}; quantity_point l1{mean_sea_level + 1 * m}, l2{mean_sea_level + 2 * m};
return l2 = l1; return l2 = l1;
}()) }())
.quantity_from_origin() == 1 * m); .quantity_ref_from(mean_sea_level) == 1 * m);
static_assert(([]() { static_assert(([]() {
const quantity_point l1{mean_sea_level + 1 * m}; const quantity_point l1{mean_sea_level + 1 * m};
quantity_point l2{mean_sea_level + 2 * m}; quantity_point l2{mean_sea_level + 2 * m};
return l2 = l1; return l2 = l1;
}()) }())
.quantity_from_origin() == 1 * m); .quantity_ref_from(mean_sea_level) == 1 * m);
static_assert(([]() { static_assert(([]() {
quantity_point l1{mean_sea_level + 1 * m}, l2{mean_sea_level + 2 * m}; quantity_point l1{mean_sea_level + 1 * m}, l2{mean_sea_level + 2 * m};
return l2 = std::move(l1); return l2 = std::move(l1);
}()) }())
.quantity_from_origin() == 1 * m); .quantity_ref_from(mean_sea_level) == 1 * m);
//////////////////// ////////////////////
@@ -659,14 +672,14 @@ static_assert([](auto v) {
//////////////////////// ////////////////////////
// same type // same type
static_assert((mean_sea_level + 1 * m += 1 * m).quantity_from_origin().numerical_value_ref_in(m) == 2); static_assert((mean_sea_level + 1 * m += 1 * m).quantity_ref_from(mean_sea_level).numerical_value_ref_in(m) == 2);
static_assert((mean_sea_level + 2 * m -= 1 * m).quantity_from_origin().numerical_value_ref_in(m) == 1); static_assert((mean_sea_level + 2 * m -= 1 * m).quantity_ref_from(mean_sea_level).numerical_value_ref_in(m) == 1);
// different types // different types
static_assert((mean_sea_level + 2.5 * m += 3 * m).quantity_from_origin().numerical_value_ref_in(m) == 5.5); static_assert((mean_sea_level + 2.5 * m += 3 * m).quantity_ref_from(mean_sea_level).numerical_value_ref_in(m) == 5.5);
static_assert((mean_sea_level + 123 * m += 1 * km).quantity_from_origin().numerical_value_ref_in(m) == 1123); static_assert((mean_sea_level + 123 * m += 1 * km).quantity_ref_from(mean_sea_level).numerical_value_ref_in(m) == 1123);
static_assert((mean_sea_level + 5.5 * m -= 3 * m).quantity_from_origin().numerical_value_ref_in(m) == 2.5); static_assert((mean_sea_level + 5.5 * m -= 3 * m).quantity_ref_from(mean_sea_level).numerical_value_ref_in(m) == 2.5);
static_assert((mean_sea_level + 1123 * m -= 1 * km).quantity_from_origin().numerical_value_ref_in(m) == 123); static_assert((mean_sea_level + 1123 * m -= 1 * km).quantity_ref_from(mean_sea_level).numerical_value_ref_in(m) == 123);
template<template<auto, auto, typename> typename QP> template<template<auto, auto, typename> typename QP>
@@ -938,29 +951,29 @@ static_assert(is_of_type<(1 * m + tower_peak) - (1 * m + other_ground_level), qu
// check for integral types promotion // check for integral types promotion
static_assert(is_same_v<decltype(((mean_sea_level + std::uint8_t(0) * m) + std::uint8_t(0) * m) static_assert(is_same_v<decltype(((mean_sea_level + std::uint8_t(0) * m) + std::uint8_t(0) * m)
.quantity_from_origin() .quantity_ref_from(mean_sea_level)
.numerical_value_ref_in(m)), .numerical_value_ref_in(m)),
int&&>); int&&>);
static_assert(is_same_v<decltype((std::uint8_t(0) * m + (mean_sea_level + std::uint8_t(0) * m)) static_assert(is_same_v<decltype((std::uint8_t(0) * m + (mean_sea_level + std::uint8_t(0) * m))
.quantity_from_origin() .quantity_ref_from(mean_sea_level)
.numerical_value_ref_in(m)), .numerical_value_ref_in(m)),
int&&>); int&&>);
static_assert(is_same_v<decltype(((mean_sea_level + std::uint8_t(0) * m) - std::uint8_t(0) * m) static_assert(is_same_v<decltype(((mean_sea_level + std::uint8_t(0) * m) - std::uint8_t(0) * m)
.quantity_from_origin() .quantity_ref_from(mean_sea_level)
.numerical_value_ref_in(m)), .numerical_value_ref_in(m)),
int&&>); int&&>);
static_assert(is_same_v<decltype(((mean_sea_level + std::uint8_t(0) * m) - (mean_sea_level + std::uint8_t(0) * m)) static_assert(is_same_v<decltype(((mean_sea_level + std::uint8_t(0) * m) - (mean_sea_level + std::uint8_t(0) * m))
.numerical_value_ref_in(m)), .numerical_value_ref_in(m)),
int&&>); int&&>);
static_assert( static_assert(((mean_sea_level + std::uint8_t(128) * m) + std::uint8_t(128) * m)
((mean_sea_level + std::uint8_t(128) * m) + std::uint8_t(128) * m).quantity_from_origin().numerical_value_ref_in(m) == .quantity_ref_from(mean_sea_level)
std::uint8_t(128) + std::uint8_t(128)); .numerical_value_ref_in(m) == std::uint8_t(128) + std::uint8_t(128));
static_assert( static_assert((std::uint8_t(128) * m + (mean_sea_level + std::uint8_t(128) * m))
(std::uint8_t(128) * m + (mean_sea_level + std::uint8_t(128) * m)).quantity_from_origin().numerical_value_ref_in(m) == .quantity_ref_from(mean_sea_level)
std::uint8_t(128) + std::uint8_t(128)); .numerical_value_ref_in(m) == std::uint8_t(128) + std::uint8_t(128));
static_assert( static_assert(((mean_sea_level + std::uint8_t(0) * m) - std::uint8_t(1) * m)
((mean_sea_level + std::uint8_t(0) * m) - std::uint8_t(1) * m).quantity_from_origin().numerical_value_ref_in(m) == .quantity_ref_from(mean_sea_level)
std::uint8_t(0) - std::uint8_t(1)); .numerical_value_ref_in(m) == 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)) static_assert(((mean_sea_level + std::uint8_t(0) * m) - (mean_sea_level + std::uint8_t(1) * m))
.numerical_value_ref_in(m) == std::uint8_t(0) - std::uint8_t(1)); .numerical_value_ref_in(m) == std::uint8_t(0) - std::uint8_t(1));
@@ -1016,32 +1029,42 @@ 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(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().numerical_value_ref_in(m) == 2); static_assert(((mean_sea_level + 1 * m) + 1 * m).quantity_ref_from(mean_sea_level).numerical_value_ref_in(m) == 2);
static_assert((1 * m + (mean_sea_level + 1 * m)).quantity_from_origin().numerical_value_ref_in(m) == 2); static_assert((1 * m + (mean_sea_level + 1 * m)).quantity_ref_from(mean_sea_level).numerical_value_ref_in(m) == 2);
static_assert(((mean_sea_level + 1 * m) + 1 * km).quantity_from_origin().numerical_value_ref_in(m) == 1001); static_assert(((mean_sea_level + 1 * m) + 1 * km).quantity_ref_from(mean_sea_level).numerical_value_ref_in(m) == 1001);
static_assert((1 * m + (mean_sea_level + 1 * km)).quantity_from_origin().numerical_value_ref_in(m) == 1001); static_assert((1 * m + (mean_sea_level + 1 * km)).quantity_ref_from(mean_sea_level).numerical_value_ref_in(m) == 1001);
static_assert(((mean_sea_level + 1 * km) + 1 * m).quantity_from_origin().numerical_value_ref_in(m) == 1001); static_assert(((mean_sea_level + 1 * km) + 1 * m).quantity_ref_from(mean_sea_level).numerical_value_ref_in(m) == 1001);
static_assert((1 * km + (mean_sea_level + 1 * m)).quantity_from_origin().numerical_value_ref_in(m) == 1001); static_assert((1 * km + (mean_sea_level + 1 * m)).quantity_ref_from(mean_sea_level).numerical_value_ref_in(m) == 1001);
static_assert(((mean_sea_level + 2 * m) - 1 * m).quantity_from_origin().numerical_value_ref_in(m) == 1); static_assert(((mean_sea_level + 2 * m) - 1 * m).quantity_ref_from(mean_sea_level).numerical_value_ref_in(m) == 1);
static_assert(((mean_sea_level + 1 * km) - 1 * m).quantity_from_origin().numerical_value_ref_in(m) == 999); static_assert(((mean_sea_level + 1 * km) - 1 * m).quantity_ref_from(mean_sea_level).numerical_value_ref_in(m) == 999);
static_assert(((mean_sea_level + 1.5 * m) + 1 * m).quantity_from_origin().numerical_value_ref_in(m) == 2.5); static_assert(((mean_sea_level + 1.5 * m) + 1 * m).quantity_ref_from(mean_sea_level).numerical_value_ref_in(m) == 2.5);
static_assert((1.5 * m + (mean_sea_level + 1 * m)).quantity_from_origin().numerical_value_ref_in(m) == 2.5); static_assert((1.5 * m + (mean_sea_level + 1 * m)).quantity_ref_from(mean_sea_level).numerical_value_ref_in(m) == 2.5);
static_assert(((mean_sea_level + 1.5 * m) + 1 * km).quantity_from_origin().numerical_value_ref_in(m) == 1001.5); static_assert(((mean_sea_level + 1.5 * m) + 1 * km).quantity_ref_from(mean_sea_level).numerical_value_ref_in(m) ==
static_assert((1.5 * m + (mean_sea_level + 1 * km)).quantity_from_origin().numerical_value_ref_in(m) == 1001.5); 1001.5);
static_assert(((mean_sea_level + 1.5 * km) + 1 * m).quantity_from_origin().numerical_value_ref_in(m) == 1501); static_assert((1.5 * m + (mean_sea_level + 1 * km)).quantity_ref_from(mean_sea_level).numerical_value_ref_in(m) ==
static_assert((1.5 * km + (mean_sea_level + 1 * m)).quantity_from_origin().numerical_value_ref_in(m) == 1501); 1001.5);
static_assert(((mean_sea_level + 2.5 * m) - 1 * m).quantity_from_origin().numerical_value_ref_in(m) == 1.5); static_assert(((mean_sea_level + 1.5 * km) + 1 * m).quantity_ref_from(mean_sea_level).numerical_value_ref_in(m) ==
static_assert(((mean_sea_level + 1.5 * km) - 1 * m).quantity_from_origin().numerical_value_ref_in(m) == 1499); 1501);
static_assert((1.5 * km + (mean_sea_level + 1 * m)).quantity_ref_from(mean_sea_level).numerical_value_ref_in(m) ==
1501);
static_assert(((mean_sea_level + 2.5 * m) - 1 * m).quantity_ref_from(mean_sea_level).numerical_value_ref_in(m) == 1.5);
static_assert(((mean_sea_level + 1.5 * km) - 1 * m).quantity_ref_from(mean_sea_level).numerical_value_ref_in(m) ==
1499);
static_assert(((mean_sea_level + 1 * m) + 1.5 * m).quantity_from_origin().numerical_value_ref_in(m) == 2.5); static_assert(((mean_sea_level + 1 * m) + 1.5 * m).quantity_ref_from(mean_sea_level).numerical_value_ref_in(m) == 2.5);
static_assert((1 * m + (mean_sea_level + 1.5 * m)).quantity_from_origin().numerical_value_ref_in(m) == 2.5); static_assert((1 * m + (mean_sea_level + 1.5 * m)).quantity_ref_from(mean_sea_level).numerical_value_ref_in(m) == 2.5);
static_assert(((mean_sea_level + 1 * m) + 1.5 * km).quantity_from_origin().numerical_value_ref_in(m) == 1501); static_assert(((mean_sea_level + 1 * m) + 1.5 * km).quantity_ref_from(mean_sea_level).numerical_value_ref_in(m) ==
static_assert((1 * m + (mean_sea_level + 1.5 * km)).quantity_from_origin().numerical_value_ref_in(m) == 1501); 1501);
static_assert(((mean_sea_level + 1 * km) + 1.5 * m).quantity_from_origin().numerical_value_ref_in(m) == 1001.5); static_assert((1 * m + (mean_sea_level + 1.5 * km)).quantity_ref_from(mean_sea_level).numerical_value_ref_in(m) ==
static_assert((1 * km + (mean_sea_level + 1.5 * m)).quantity_from_origin().numerical_value_ref_in(m) == 1001.5); 1501);
static_assert(((mean_sea_level + 2 * m) - 1.5 * m).quantity_from_origin().numerical_value_ref_in(m) == 0.5); static_assert(((mean_sea_level + 1 * km) + 1.5 * m).quantity_ref_from(mean_sea_level).numerical_value_ref_in(m) ==
static_assert(((mean_sea_level + 1 * km) - 1.5 * m).quantity_from_origin().numerical_value_ref_in(m) == 998.5); 1001.5);
static_assert((1 * km + (mean_sea_level + 1.5 * m)).quantity_ref_from(mean_sea_level).numerical_value_ref_in(m) ==
1001.5);
static_assert(((mean_sea_level + 2 * m) - 1.5 * m).quantity_ref_from(mean_sea_level).numerical_value_ref_in(m) == 0.5);
static_assert(((mean_sea_level + 1 * km) - 1.5 * m).quantity_ref_from(mean_sea_level).numerical_value_ref_in(m) ==
998.5);
static_assert(((mean_sea_level + 2 * m) - (mean_sea_level + 1 * m)).numerical_value_ref_in(m) == 1); static_assert(((mean_sea_level + 2 * m) - (mean_sea_level + 1 * m)).numerical_value_ref_in(m) == 1);
static_assert(((mean_sea_level + 1 * km) - (mean_sea_level + 1 * m)).numerical_value_ref_in(m) == 999); static_assert(((mean_sea_level + 1 * km) - (mean_sea_level + 1 * m)).numerical_value_ref_in(m) == 999);
@@ -1061,15 +1084,15 @@ static_assert((ground_level + 42 * m) - (other_ground_level + 42 * m) == -81 * m
static_assert((other_ground_level + 42 * m) - (tower_peak + 42 * m) == 39 * m); static_assert((other_ground_level + 42 * m) - (tower_peak + 42 * m) == 39 * m);
static_assert((tower_peak + 42 * m) - (other_ground_level + 42 * m) == -39 * m); static_assert((tower_peak + 42 * m) - (other_ground_level + 42 * m) == -39 * m);
static_assert((mean_sea_level + 42 * m).quantity_from_origin() == 42 * m); static_assert((mean_sea_level + 42 * m).quantity_ref_from(mean_sea_level) == 42 * m);
static_assert((42 * m + mean_sea_level).quantity_from_origin() == 42 * m); static_assert((42 * m + mean_sea_level).quantity_ref_from(mean_sea_level) == 42 * m);
static_assert((mean_sea_level - 42 * m).quantity_from_origin() == -42 * m); static_assert((mean_sea_level - 42 * m).quantity_ref_from(mean_sea_level) == -42 * m);
static_assert((ground_level + 42 * m).quantity_from_origin() == 42 * m); static_assert((ground_level + 42 * m).quantity_ref_from(ground_level) == 42 * m);
static_assert((42 * m + ground_level).quantity_from_origin() == 42 * m); static_assert((42 * m + ground_level).quantity_ref_from(ground_level) == 42 * m);
static_assert((ground_level - 42 * m).quantity_from_origin() == -42 * m); static_assert((ground_level - 42 * m).quantity_ref_from(ground_level) == -42 * m);
static_assert((tower_peak + 42 * m).quantity_from_origin() == 42 * m); static_assert((tower_peak + 42 * m).quantity_ref_from(tower_peak) == 42 * m);
static_assert((42 * m + tower_peak).quantity_from_origin() == 42 * m); static_assert((42 * m + tower_peak).quantity_ref_from(tower_peak) == 42 * m);
static_assert((tower_peak - 42 * m).quantity_from_origin() == -42 * m); static_assert((tower_peak - 42 * m).quantity_ref_from(tower_peak) == -42 * m);
static_assert((mean_sea_level + 42 * m) - ground_level == 0 * m); static_assert((mean_sea_level + 42 * m) - ground_level == 0 * m);
static_assert((ground_level + 42 * m) - mean_sea_level == 84 * m); static_assert((ground_level + 42 * m) - mean_sea_level == 84 * m);
@@ -1109,17 +1132,17 @@ inline constexpr struct zero_m_per_s : absolute_point_origin<kind_of<isq::speed>
// commutativity and associativity // commutativity and associativity
static_assert(((zero_m_per_s + 10 * isq::height[m] / (2 * isq::time[s])) + 5 * isq::speed[m / s]) static_assert(((zero_m_per_s + 10 * isq::height[m] / (2 * isq::time[s])) + 5 * isq::speed[m / s])
.quantity_from_origin() == 10 * isq::speed[m / s]); .quantity_ref_from(zero_m_per_s) == 10 * isq::speed[m / s]);
static_assert((10 * isq::height[m] / (2 * isq::time[s]) + (zero_m_per_s + 5 * isq::speed[m / s])) static_assert((10 * isq::height[m] / (2 * isq::time[s]) + (zero_m_per_s + 5 * isq::speed[m / s]))
.quantity_from_origin() == 10 * isq::speed[m / s]); .quantity_ref_from(zero_m_per_s) == 10 * isq::speed[m / s]);
static_assert(((zero_m_per_s + 5 * isq::speed[m / s]) + 10 * isq::height[m] / (2 * isq::time[s])) static_assert(((zero_m_per_s + 5 * isq::speed[m / s]) + 10 * isq::height[m] / (2 * isq::time[s]))
.quantity_from_origin() == 10 * isq::speed[m / s]); .quantity_ref_from(zero_m_per_s) == 10 * isq::speed[m / s]);
static_assert((5 * isq::speed[m / s] + (zero_m_per_s + 10 * isq::height[m] / (2 * isq::time[s]))) static_assert((5 * isq::speed[m / s] + (zero_m_per_s + 10 * isq::height[m] / (2 * isq::time[s])))
.quantity_from_origin() == 10 * isq::speed[m / s]); .quantity_ref_from(zero_m_per_s) == 10 * isq::speed[m / s]);
static_assert(((zero_m_per_s + 10 * isq::height[m] / (2 * isq::time[s])) - 5 * isq::speed[m / s]) static_assert(((zero_m_per_s + 10 * isq::height[m] / (2 * isq::time[s])) - 5 * isq::speed[m / s])
.quantity_from_origin() == 0 * isq::speed[m / s]); .quantity_ref_from(zero_m_per_s) == 0 * isq::speed[m / s]);
static_assert(((zero_m_per_s + 5 * isq::speed[m / s]) - 10 * isq::height[m] / (2 * isq::time[s])) static_assert(((zero_m_per_s + 5 * isq::speed[m / s]) - 10 * isq::height[m] / (2 * isq::time[s]))
.quantity_from_origin() == 0 * isq::speed[m / s]); .quantity_ref_from(zero_m_per_s) == 0 * isq::speed[m / s]);
static_assert((zero_m_per_s + 10 * isq::height[m] / (2 * isq::time[s])) - (zero_m_per_s + 5 * isq::speed[m / s]) == static_assert((zero_m_per_s + 10 * isq::height[m] / (2 * isq::time[s])) - (zero_m_per_s + 5 * isq::speed[m / s]) ==
0 * isq::speed[m / s]); 0 * isq::speed[m / s]);
static_assert((zero_m_per_s + 5 * isq::speed[m / s]) - (zero_m_per_s + 10 * isq::height[m] / (2 * isq::time[s])) == static_assert((zero_m_per_s + 5 * isq::speed[m / s]) - (zero_m_per_s + 10 * isq::height[m] / (2 * isq::time[s])) ==
@@ -1151,17 +1174,17 @@ static_assert(
inline constexpr struct zero_Hz : absolute_point_origin<kind_of<isq::frequency>> { inline constexpr struct zero_Hz : absolute_point_origin<kind_of<isq::frequency>> {
} zero_Hz; } zero_Hz;
static_assert(((zero_Hz + 10 / (2 * isq::period_duration[s])) + 5 * isq::frequency[Hz]).quantity_from_origin() == static_assert(((zero_Hz + 10 / (2 * isq::period_duration[s])) + 5 * isq::frequency[Hz]).quantity_ref_from(zero_Hz) ==
10 * isq::frequency[Hz]); 10 * isq::frequency[Hz]);
static_assert((10 / (2 * isq::period_duration[s]) + (zero_Hz + 5 * isq::frequency[Hz])).quantity_from_origin() == static_assert((10 / (2 * isq::period_duration[s]) + (zero_Hz + 5 * isq::frequency[Hz])).quantity_ref_from(zero_Hz) ==
10 * isq::frequency[Hz]); 10 * isq::frequency[Hz]);
static_assert(((zero_Hz + 5 * isq::frequency[Hz]) + 10 / (2 * isq::period_duration[s])).quantity_from_origin() == static_assert(((zero_Hz + 5 * isq::frequency[Hz]) + 10 / (2 * isq::period_duration[s])).quantity_ref_from(zero_Hz) ==
10 * isq::frequency[Hz]); 10 * isq::frequency[Hz]);
static_assert((5 * isq::frequency[Hz] + (zero_Hz + 10 / (2 * isq::period_duration[s]))).quantity_from_origin() == static_assert((5 * isq::frequency[Hz] + (zero_Hz + 10 / (2 * isq::period_duration[s]))).quantity_ref_from(zero_Hz) ==
10 * isq::frequency[Hz]); 10 * isq::frequency[Hz]);
static_assert(((zero_Hz + 10 / (2 * isq::period_duration[s])) - 5 * isq::frequency[Hz]).quantity_from_origin() == static_assert(((zero_Hz + 10 / (2 * isq::period_duration[s])) - 5 * isq::frequency[Hz]).quantity_ref_from(zero_Hz) ==
0 * isq::frequency[Hz]); 0 * isq::frequency[Hz]);
static_assert(((zero_Hz + 5 * isq::frequency[Hz]) - 10 / (2 * isq::period_duration[s])).quantity_from_origin() == static_assert(((zero_Hz + 5 * isq::frequency[Hz]) - 10 / (2 * isq::period_duration[s])).quantity_ref_from(zero_Hz) ==
0 * isq::frequency[Hz]); 0 * isq::frequency[Hz]);
static_assert((zero_Hz + 10 / (2 * isq::period_duration[s])) - (zero_Hz + 5 * isq::frequency[Hz]) == static_assert((zero_Hz + 10 / (2 * isq::period_duration[s])) - (zero_Hz + 5 * isq::frequency[Hz]) ==
0 * isq::frequency[Hz]); 0 * isq::frequency[Hz]);