mpusz/mp-units
1
0
Fork 1
mirror of https://github.com/mpusz/mp-units.git synced 2025-07-30 18:37:15 +02:00
Code Issues Packages Projects Releases Wiki Activity

Revert "Merge branch 'master-msvc-194-only-lib' into master-msvc-194"

Browse Source 
This reverts commit e3034c5554, reversing
changes made to 8be458b0b7.
This commit is contained in:
Jonas Hoppe
2024-09-09 12:10:39 +02:00
parent 1d0dbf48b1
commit aebf55c09a
34 changed files with 864 additions and 855 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
example/avg_speed.cpp
View File

@ -45,26 +45,26 @@ namespace {
using namespace mp_units; using namespace mp_units;
constexpr quantity<si::metre / si::second, int> fixed_int_si_avg_speed(quantity<si::metre, int> d, constexpr quantity<si::metre / si::second, int> fixed_int_si_avg_speed(quantity<(si::metre), int> d,
quantity<si::second, int> t) quantity<(si::second), int> t)
{ {
return d / t; return d / t;
} }
constexpr quantity<si::metre / si::second> fixed_double_si_avg_speed(quantity<si::metre> d, quantity<si::second> t) constexpr quantity<si::metre / si::second> fixed_double_si_avg_speed(quantity<(si::metre)> d, quantity<(si::second)> t)
{ {
return d / t; return d / t;
} }
constexpr QuantityOf<isq::speed> auto avg_speed(QuantityOf<isq::length> auto d, QuantityOf<isq::time> auto t) constexpr QuantityOf<(isq::speed)> auto avg_speed(QuantityOf<(isq::length)> auto d, QuantityOf<(isq::time)> auto t)
{ {
return d / t; return d / t;
} }
template<QuantityOf<isq::length> D, QuantityOf<isq::time> T, QuantityOf<isq::speed> V> template<QuantityOf<(isq::length)> D, QuantityOf<(isq::time)> T, QuantityOf<(isq::speed)> V>
void print_result(D distance, T duration, V speed) void print_result(D distance, T duration, V speed)
{ {
const auto result_in_kmph = speed.force_in(si::kilo<si::metre> / non_si::hour); const auto result_in_kmph = speed.force_in((si::kilo<(si::metre)> / non_si::hour));
std::cout << "Average speed of a car that makes " << distance << " in " << duration << " is " << result_in_kmph std::cout << "Average speed of a car that makes " << distance << " in " << duration << " is " << result_in_kmph
<< ".\n"; << ".\n";
} }

2
example/capacitor_time_curve.cpp
View File

@ -48,7 +48,7 @@ int main()
constexpr auto RR = isq::resistance(4.7 * si::kilo<si::ohm>); constexpr auto RR = isq::resistance(4.7 * si::kilo<si::ohm>);
for (auto tt = 0 * ms; tt <= 50 * ms; ++tt) { for (auto tt = 0 * ms; tt <= 50 * ms; ++tt) {
const QuantityOf<isq::voltage> auto Vt = V0 * exp(dimensionless(-tt / (RR * CC))); const QuantityOf<(isq::voltage)> auto Vt = V0 * exp(dimensionless(-tt / (RR * CC)));
// TODO try to make the below work instead // TODO try to make the below work instead
// const QuantityOf<isq::voltage> auto Vt = V0 * exp(-tt / (RR * CC)); // const QuantityOf<isq::voltage> auto Vt = V0 * exp(-tt / (RR * CC));

4
example/clcpp_response.cpp
View File

@ -44,8 +44,8 @@ void simple_quantities()
using namespace mp_units::si; using namespace mp_units::si;
using namespace mp_units::international; using namespace mp_units::international;
using distance = quantity<isq::distance[kilo<metre>]>; using distance = quantity<(isq::distance[kilo<metre>])>;
using duration = quantity<isq::duration[second]>; using duration = quantity<(isq::duration[second])>;
constexpr distance km = 1. * kilo<metre>; constexpr distance km = 1. * kilo<metre>;
constexpr distance miles = 1. * mile; constexpr distance miles = 1. * mile;

14
example/currency.cpp
View File

@ -90,11 +90,11 @@ template<Unit auto From, Unit auto To>
#endif #endif
template<ReferenceOf<currency> auto To, ReferenceOf<currency> auto From, typename Rep> // template<ReferenceOf<currency> auto To, ReferenceOf<currency> auto From, typename Rep>
quantity<To, Rep> exchange_to(quantity<From, Rep> q) // quantity<To, Rep> exchange_to(quantity<From, Rep> q)
{ // {
return static_cast<Rep>(exchange_rate<q.unit, get_unit(To)>() * q.numerical_value()) * To; // return static_cast<Rep>(exchange_rate<q.unit, get_unit(To)>() * q.numerical_value()) * To;
} // }
template<ReferenceOf<currency> auto To, ReferenceOf<currency> auto From, auto PO, typename Rep> template<ReferenceOf<currency> auto To, ReferenceOf<currency> auto From, auto PO, typename Rep>
quantity_point<To, PO, Rep> exchange_to(quantity_point<From, PO, Rep> q) quantity_point<To, PO, Rep> exchange_to(quantity_point<From, PO, Rep> q)
@ -107,8 +107,8 @@ int main()
{ {
using namespace unit_symbols; using namespace unit_symbols;
const quantity_point price_usd{100 * USD}; const mp_units::quantity_point price_usd{100 * USD};
const quantity_point price_euro = exchange_to<euro>(price_usd); const mp_units::quantity_point<euro, default_point_origin(euro), int> price_euro = exchange_to<euro>(price_usd);
std::cout << price_usd.quantity_from_zero() << " -> " << price_euro.quantity_from_zero() << "\n"; std::cout << price_usd.quantity_from_zero() << " -> " << price_euro.quantity_from_zero() << "\n";
// std::cout << price_usd.quantity_from_zero() + price_euro.quantity_from_zero() << "\n"; // does // std::cout << price_usd.quantity_from_zero() + price_euro.quantity_from_zero() << "\n"; // does

10
example/glide_computer.cpp
View File

@ -169,7 +169,7 @@ void example()
const auto gliders = get_gliders(); const auto gliders = get_gliders();
const auto waypoints = get_waypoints(); const auto waypoints = get_waypoints();
const auto weather_conditions = get_weather_conditions(); const auto weather_conditions = get_weather_conditions();
const task t = {waypoints[0], waypoints[1], waypoints[0]}; const task glider_task = {waypoints[0], waypoints[1], waypoints[0]};
const aircraft_tow tow = {400 * m, 1.6 * m / s}; const aircraft_tow tow = {400 * m, 1.6 * m / s};
const timestamp start_time(std::chrono::system_clock::now()); const timestamp start_time(std::chrono::system_clock::now());
@ -177,16 +177,16 @@ void example()
print(gliders); print(gliders);
print(waypoints); print(waypoints);
print(weather_conditions); print(weather_conditions);
print(t); print(glider_task);
print(tow); print(tow);
for (const auto& g : gliders) { for (const auto& glider : gliders) {
for (const auto& c : weather_conditions) { for (const auto& c : weather_conditions) {
const std::string txt = "Scenario: Glider = " + g.name + ", Weather = " + c.first; const std::string txt = "Scenario: Glider = " + glider.name + ", Weather = " + c.first;
std::cout << txt << "\n"; std::cout << txt << "\n";
std::cout << MP_UNITS_STD_FMT::format("{0:=^{1}}\n\n", "", txt.size()); std::cout << MP_UNITS_STD_FMT::format("{0:=^{1}}\n\n", "", txt.size());
estimate(start_time, g, c.second, t, sfty, tow); estimate(start_time, glider, c.second, glider_task, sfty, tow);
std::cout << "\n\n"; std::cout << "\n\n";
} }

2
example/glide_computer_lib/include/glide_computer_lib.h
View File

@ -90,7 +90,7 @@ struct glider {
std::array<polar_point, 1> polar; std::array<polar_point, 1> polar;
}; };
constexpr mp_units::QuantityOf<mp_units::dimensionless> auto glide_ratio(const glider::polar_point& polar) constexpr mp_units::QuantityOf<(mp_units::dimensionless)> auto glide_ratio(const glider::polar_point& polar)
{ {
return polar.v / -polar.climb; return polar.v / -polar.climb;
} }

2
example/hello_units.cpp
View File

@ -45,7 +45,7 @@ import mp_units;
using namespace mp_units; using namespace mp_units;
constexpr QuantityOf<isq::speed> auto avg_speed(QuantityOf<isq::length> auto d, QuantityOf<isq::time> auto t) constexpr QuantityOf<(isq::speed)> auto avg_speed(QuantityOf<(isq::length)> auto d, QuantityOf<(isq::time)> auto t)
{ {
return d / t; return d / t;
} }

8
example/include/geographic.h
View File

@ -79,10 +79,10 @@ inline constexpr struct prime_meridian final : mp_units::absolute_point_origin<m
template<typename T = double> template<typename T = double>
using latitude = mp_units::quantity_point<mp_units::si::degree, equator, ranged_representation<T, -90, 90>>; using latitude = mp_units::quantity_point<(mp_units::si::degree), equator, ranged_representation<T, -90, 90>>;
template<typename T = double> template<typename T = double>
using longitude = mp_units::quantity_point<mp_units::si::degree, prime_meridian, ranged_representation<T, -180, 180>>; using longitude = mp_units::quantity_point<(mp_units::si::degree), prime_meridian, ranged_representation<T, -180, 180>>;
template<class CharT, class Traits, typename T> template<class CharT, class Traits, typename T>
std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& os, const latitude<T>& lat) std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& os, const latitude<T>& lat)
@ -176,7 +176,7 @@ template<typename T>
distance spherical_distance(position<T> from, position<T> to) distance spherical_distance(position<T> from, position<T> to)
{ {
using namespace mp_units; using namespace mp_units;
constexpr quantity earth_radius = 6'371 * isq::radius[si::kilo<si::metre>]; constexpr quantity earth_radius = 6'371 * isq::radius[si::kilo<(si::metre)>];
using si::sin, si::cos, si::asin, si::acos; using si::sin, si::cos, si::asin, si::acos;
@ -193,7 +193,7 @@ distance spherical_distance(position<T> from, position<T> to)
// const auto central_angle = 2 * asin(sqrt(0.5 - cos(to_lat - from_lat) / 2 + cos(from_lat) * cos(to_lat) * (1 // const auto central_angle = 2 * asin(sqrt(0.5 - cos(to_lat - from_lat) / 2 + cos(from_lat) * cos(to_lat) * (1
// - cos(lon2_rad - from_lon)) / 2)); // - cos(lon2_rad - from_lon)) / 2));
return quantity_cast<isq::distance>(earth_radius * central_angle); return quantity_cast<(isq::distance)>(earth_radius * central_angle);
} else { } else {
// the haversine formula // the haversine formula
const quantity sin_lat = sin((to_lat - from_lat) / 2); const quantity sin_lat = sin((to_lat - from_lat) / 2);

16
example/kalman_filter/kalman.h
View File

@ -116,15 +116,15 @@ template<mp_units::Quantity Q1, mp_units::Quantity Q2>
} }
// state update // state update
template<typename QP, mp_units::QuantityPoint QM, mp_units::QuantityOf<mp_units::dimensionless> K> template<typename QP, mp_units::QuantityPoint QM, mp_units::QuantityOf<(mp_units::dimensionless)> K>
requires(implicitly_convertible(QM::quantity_spec, QP::quantity_spec)) requires(implicitly_convertible(QM::quantity_spec, QP::quantity_spec))
[[nodiscard]] constexpr system_state<QP> state_update(const system_state<QP>& predicted, QM measured, K gain) [[nodiscard]] constexpr system_state<QP> state_update(const system_state<QP>& predicted, QM measured, K gain)
{ {
return system_state<QP>{get<0>(predicted) + gain * (measured - get<0>(predicted))}; return system_state<QP>{get<0>(predicted) + gain * (measured - get<0>(predicted))};
} }
template<typename QP1, typename QP2, mp_units::QuantityPoint QM, mp_units::QuantityOf<mp_units::dimensionless> K, template<typename QP1, typename QP2, mp_units::QuantityPoint QM, mp_units::QuantityOf<(mp_units::dimensionless)> K,
mp_units::QuantityOf<mp_units::isq::time> T> mp_units::QuantityOf<(mp_units::isq::time)> T>
requires(implicitly_convertible(QM::quantity_spec, QP1::quantity_spec)) requires(implicitly_convertible(QM::quantity_spec, QP1::quantity_spec))
[[nodiscard]] constexpr system_state<QP1, QP2> state_update(const system_state<QP1, QP2>& predicted, QM measured, [[nodiscard]] constexpr system_state<QP1, QP2> state_update(const system_state<QP1, QP2>& predicted, QM measured,
std::array<K, 2> gain, T interval) std::array<K, 2> gain, T interval)
@ -135,7 +135,7 @@ template<typename QP1, typename QP2, mp_units::QuantityPoint QM, mp_units::Quant
} }
template<typename QP1, typename QP2, typename QP3, mp_units::QuantityPoint QM, template<typename QP1, typename QP2, typename QP3, mp_units::QuantityPoint QM,
mp_units::QuantityOf<mp_units::dimensionless> K, mp_units::QuantityOf<mp_units::isq::time> T> mp_units::QuantityOf<(mp_units::dimensionless)> K, mp_units::QuantityOf<(mp_units::isq::time)> T>
requires(implicitly_convertible(QM::quantity_spec, QP1::quantity_spec)) requires(implicitly_convertible(QM::quantity_spec, QP1::quantity_spec))
[[nodiscard]] constexpr system_state<QP1, QP2, QP3> state_update(const system_state<QP1, QP2, QP3>& predicted, [[nodiscard]] constexpr system_state<QP1, QP2, QP3> state_update(const system_state<QP1, QP2, QP3>& predicted,
QM measured, std::array<K, 3> gain, T interval) QM measured, std::array<K, 3> gain, T interval)
@ -147,13 +147,13 @@ template<typename QP1, typename QP2, typename QP3, mp_units::QuantityPoint QM,
} }
// covariance update // covariance update
template<mp_units::Quantity Q, mp_units::QuantityOf<mp_units::dimensionless> K> template<mp_units::Quantity Q, mp_units::QuantityOf<(mp_units::dimensionless)> K>
[[nodiscard]] constexpr Q covariance_update(Q uncertainty, K gain) [[nodiscard]] constexpr Q covariance_update(Q uncertainty, K gain)
{ {
return (1 * mp_units::one - gain) * uncertainty; return (1 * mp_units::one - gain) * uncertainty;
} }
template<mp_units::QuantityPoint... QPs, mp_units::QuantityPoint QP, mp_units::QuantityOf<mp_units::dimensionless> K> template<mp_units::QuantityPoint... QPs, mp_units::QuantityPoint QP, mp_units::QuantityOf<(mp_units::dimensionless)> K>
[[nodiscard]] constexpr system_state_estimate<QPs...> state_estimate_update( [[nodiscard]] constexpr system_state_estimate<QPs...> state_estimate_update(
const system_state_estimate<QPs...>& previous, QP measurement, K gain) const system_state_estimate<QPs...>& previous, QP measurement, K gain)
{ {
@ -162,7 +162,7 @@ template<mp_units::QuantityPoint... QPs, mp_units::QuantityPoint QP, mp_units::Q
// state extrapolation // state extrapolation
template<typename QP1, typename QP2, mp_units::QuantityOf<mp_units::isq::time> T> template<typename QP1, typename QP2, mp_units::QuantityOf<(mp_units::isq::time)> T>
[[nodiscard]] constexpr system_state<QP1, QP2> state_extrapolation(const system_state<QP1, QP2>& estimated, T interval) [[nodiscard]] constexpr system_state<QP1, QP2> state_extrapolation(const system_state<QP1, QP2>& estimated, T interval)
{ {
auto to_quantity = [](const auto& qp) { return qp.quantity_ref_from(qp.point_origin); }; auto to_quantity = [](const auto& qp) { return qp.quantity_ref_from(qp.point_origin); };
@ -171,7 +171,7 @@ template<typename QP1, typename QP2, mp_units::QuantityOf<mp_units::isq::time> T
return system_state<QP1, QP2>{qp1, qp2}; return system_state<QP1, QP2>{qp1, qp2};
} }
template<typename QP1, typename QP2, typename QP3, mp_units::QuantityOf<mp_units::isq::time> T> template<typename QP1, typename QP2, typename QP3, mp_units::QuantityOf<(mp_units::isq::time)> T>
[[nodiscard]] constexpr system_state<QP1, QP2, QP3> state_extrapolation(const system_state<QP1, QP2, QP3>& estimated, [[nodiscard]] constexpr system_state<QP1, QP2, QP3> state_extrapolation(const system_state<QP1, QP2, QP3>& estimated,
T interval) T interval)
{ {

2
example/measurement.cpp
View File

@ -151,7 +151,7 @@ void example()
const auto acceleration = isq::acceleration(measurement{9.8, 0.1} * m / s2); const auto acceleration = isq::acceleration(measurement{9.8, 0.1} * m / s2);
const auto time = measurement{1.2, 0.1} * s; const auto time = measurement{1.2, 0.1} * s;
const QuantityOf<isq::velocity> auto velocity = acceleration * time; const QuantityOf<(isq::velocity)> auto velocity = acceleration * time;
std::cout << acceleration << " * " << time << " = " << velocity << " = " << velocity.in(km / h) << '\n'; std::cout << acceleration << " * " << time << " = " << velocity << " = " << velocity.in(km / h) << '\n';
const auto length = measurement{123., 1.} * m; const auto length = measurement{123., 1.} * m;

8
example/spectroscopy_units.cpp
View File

@ -54,8 +54,8 @@ constexpr auto h = 1 * si::si2019::planck_constant;
constexpr auto kb = 1 * si::si2019::boltzmann_constant; constexpr auto kb = 1 * si::si2019::boltzmann_constant;
// prints quantities in the resulting unit // prints quantities in the resulting unit
template<QuantityOf<isq::energy> T1, QuantityOf<isq::wavenumber> T2, QuantityOf<isq::frequency> T3, template<QuantityOf<(isq::energy)> T1, QuantityOf<(isq::wavenumber)> T2, QuantityOf<(isq::frequency)> T3,
QuantityOf<isq::thermodynamic_temperature> T4, QuantityOf<isq::wavelength> T5> QuantityOf<(isq::thermodynamic_temperature)> T4, QuantityOf<(isq::wavelength)> T5>
void print_line(const std::tuple<T1, T2, T3, T4, T5>& t) void print_line(const std::tuple<T1, T2, T3, T4, T5>& t)
{ {
std::cout << MP_UNITS_STD_FMT::format( std::cout << MP_UNITS_STD_FMT::format(
@ -65,8 +65,8 @@ void print_line(const std::tuple<T1, T2, T3, T4, T5>& t)
// prints quantities in semi-SI units // prints quantities in semi-SI units
// (eV is not an official SI unit) // (eV is not an official SI unit)
template<QuantityOf<isq::energy> T1, QuantityOf<isq::wavenumber> T2, QuantityOf<isq::frequency> T3, template<QuantityOf<(isq::energy)> T1, QuantityOf<(isq::wavenumber)> T2, QuantityOf<(isq::frequency)> T3,
QuantityOf<isq::thermodynamic_temperature> T4, QuantityOf<isq::wavelength> T5> QuantityOf<(isq::thermodynamic_temperature)> T4, QuantityOf<(isq::wavelength)> T5>
void print_line_si(const std::tuple<T1, T2, T3, T4, T5>& t) void print_line_si(const std::tuple<T1, T2, T3, T4, T5>& t)
{ {
std::cout << MP_UNITS_STD_FMT::format( std::cout << MP_UNITS_STD_FMT::format(

10
example/storage_tank.cpp
View File

@ -77,10 +77,10 @@ public:
density_ = density; density_ = density;
} }
[[nodiscard]] constexpr QuantityOf<isq::weight> auto filled_weight() const [[nodiscard]] constexpr QuantityOf<(isq::weight)> auto filled_weight() const
{ {
const auto volume = isq::volume(base_ * height_); // TODO check if we can remove that cast const auto volume = isq::volume(base_ * height_); // TODO check if we can remove that cast
const QuantityOf<isq::mass> auto mass = density_ * volume; const QuantityOf<(isq::mass)> auto mass = density_ * volume;
return isq::weight(mass * g); return isq::weight(mass * g);
} }
@ -130,9 +130,9 @@ int main()
const quantity spare_capacity = tank.spare_capacity(measured_mass); const quantity spare_capacity = tank.spare_capacity(measured_mass);
const quantity filled_weight = tank.filled_weight(); const quantity filled_weight = tank.filled_weight();
const QuantityOf<isq::mass_change_rate> auto input_flow_rate = measured_mass / fill_time; const QuantityOf<(isq::mass_change_rate)> auto input_flow_rate = measured_mass / fill_time;
const QuantityOf<isq::speed> auto float_rise_rate = fill_level / fill_time; const QuantityOf<(isq::speed)> auto float_rise_rate = fill_level / fill_time;
const QuantityOf<isq::time> auto fill_time_left = (height / fill_level - 1 * one) * fill_time; const QuantityOf<(isq::time)> auto fill_time_left = (height / fill_level - 1 * one) * fill_time;
const quantity fill_ratio = fill_level / height; const quantity fill_ratio = fill_level / height;

18
example/total_energy.cpp
View File

@ -45,8 +45,8 @@ namespace {
using namespace mp_units; using namespace mp_units;
QuantityOf<isq::mechanical_energy> auto total_energy(QuantityOf<isq::momentum> auto p, QuantityOf<isq::mass> auto m, QuantityOf<(isq::mechanical_energy)> auto total_energy(QuantityOf<(isq::momentum)> auto p,
QuantityOf<isq::speed> auto c) QuantityOf<(isq::mass)> auto m, QuantityOf<(isq::speed)> auto c)
{ {
return isq::mechanical_energy(sqrt(pow<2>(p * c) + pow<2>(m * pow<2>(c)))); return isq::mechanical_energy(sqrt(pow<2>(p * c) + pow<2>(m * pow<2>(c))));
} }
@ -59,19 +59,19 @@ void si_example()
const quantity c2 = pow<2>(c); const quantity c2 = pow<2>(c);
const quantity p1 = isq::momentum(4. * GeV / c); const quantity p1 = isq::momentum(4. * GeV / c);
const QuantityOf<isq::mass> auto m1 = 3. * GeV / c2; const QuantityOf<(isq::mass)> auto m1 = 3. * GeV / c2;
const quantity E = total_energy(p1, m1, c); const quantity E1 = total_energy(p1, m1, c);
std::cout << "\n*** SI units (c = " << c << " = " << c.in(si::metre / s) << ") ***\n"; std::cout << "\n*** SI units (c = " << c << " = " << c.in(si::metre / s) << ") ***\n";
std::cout << "\n[in `GeV` and `c`]\n" std::cout << "\n[in `GeV` and `c`]\n"
<< "p = " << p1 << "\n" << "p = " << p1 << "\n"
<< "m = " << m1 << "\n" << "m = " << m1 << "\n"
<< "E = " << E << "\n"; << "E = " << E1 << "\n";
const quantity p2 = p1.in(GeV / (m / s)); const quantity p2 = p1.in(GeV / (m / s));
const quantity m2 = m1.in(GeV / pow<2>(m / s)); const quantity metre2 = m1.in(GeV / pow<2>(m / s));
const quantity E2 = total_energy(p2, m2, c).in(GeV); const quantity E2 = total_energy(p2, metre2, c).in(GeV);
std::cout << "\n[in `GeV`]\n" std::cout << "\n[in `GeV`]\n"
<< "p = " << p2 << "\n" << "p = " << p2 << "\n"
@ -79,8 +79,8 @@ void si_example()
<< "E = " << E2 << "\n"; << "E = " << E2 << "\n";
const quantity p3 = p1.in(kg * m / s); const quantity p3 = p1.in(kg * m / s);
const quantity m3 = m1.in(kg); const quantity metre3 = m1.in(kg);
const quantity E3 = total_energy(p3, m3, c).in(J); const quantity E3 = total_energy(p3, metre3, c).in(J);
std::cout << "\n[in SI base units]\n" std::cout << "\n[in SI base units]\n"
<< "p = " << p3 << "\n" << "p = " << p3 << "\n"

1
example/unmanned_aerial_vehicle.cpp
View File

@ -70,6 +70,7 @@ constexpr const char* to_text(earth_gravity_model m)
return "EGM2008-1"; return "EGM2008-1";
} }
assert(false && "unsupported enum value"); assert(false && "unsupported enum value");
return "unsupported enum value";
} }
template<earth_gravity_model M> template<earth_gravity_model M>

2
src/core/include/mp-units/bits/hacks.h
View File

@ -124,7 +124,7 @@ inline constexpr from_range_t from_range{};
#else #else
#define MP_UNITS_CONSTRAINED_NTTP_WORKAROUND(X) X #define MP_UNITS_CONSTRAINED_NTTP_WORKAROUND(X) X
#define MP_UNITS_EXPRESSION_WORKAROUND(x) x #define MP_UNITS_EXPRESSION_WORKAROUND(x) x
#define MP_UNITS_IS_VALUE_WORKAROUND(x) x #define MP_UNITS_IS_VALUE_WORKAROUND(x) x
#define MP_UNITS_IS_CONST_EXPR_WORKAROUND(x) x #define MP_UNITS_IS_CONST_EXPR_WORKAROUND(x) x

26
src/core/include/mp-units/bits/type_list.h
View File

@ -68,7 +68,7 @@ struct type_list_map_impl<From<Args...>, To> {
}; };
template<TypeList From, template<typename...> typename To> template<TypeList From, template<typename...> typename To>
using type_list_map = type_list_map_impl<From, To>::type; using type_list_map = type_list_map_impl<From, To>::type;
// element // element
@ -105,7 +105,7 @@ struct type_list_front_impl<List<T, Ts...>> {
}; };
template<TypeList List> template<TypeList List>
using type_list_front = type_list_front_impl<List>::type; using type_list_front = type_list_front_impl<List>::type;
// back // back
template<TypeList List> template<TypeList List>
@ -121,7 +121,7 @@ struct type_list_push_front_impl<List<OldTypes...>, NewTypes...> {
}; };
template<TypeList List, typename... Types> template<TypeList List, typename... Types>
using type_list_push_front = type_list_push_front_impl<List, Types...>::type; using type_list_push_front = type_list_push_front_impl<List, Types...>::type;
// push_back // push_back
template<typename List, typename... Types> template<typename List, typename... Types>
@ -133,7 +133,7 @@ struct type_list_push_back_impl<List<OldTypes...>, NewTypes...> {
}; };
template<TypeList List, typename... Types> template<TypeList List, typename... Types>
using type_list_push_back = type_list_push_back_impl<List, Types...>::type; using type_list_push_back = type_list_push_back_impl<List, Types...>::type;
// join // join
template<typename List, typename... Rest> template<typename List, typename... Rest>
@ -143,11 +143,11 @@ struct type_list_join_impl {
template<template<typename...> typename List, typename... First, typename... Second, typename... Rest> template<template<typename...> typename List, typename... First, typename... Second, typename... Rest>
struct type_list_join_impl<List<First...>, List<Second...>, Rest...> { struct type_list_join_impl<List<First...>, List<Second...>, Rest...> {
using type = type_list_join_impl<List<First..., Second...>, Rest...>::type; using type = type_list_join_impl<List<First..., Second...>, Rest...>::type;
}; };
template<TypeList... Lists> template<TypeList... Lists>
using type_list_join = type_list_join_impl<Lists...>::type; using type_list_join = type_list_join_impl<Lists...>::type;
// split // split
template<typename List, typename First, typename Second> template<typename List, typename First, typename Second>
@ -195,19 +195,19 @@ template<template<typename...> typename List, typename Lhs1, typename... LhsRest
template<typename, typename> typename Pred> template<typename, typename> typename Pred>
requires Pred<Lhs1, Rhs1>::value requires Pred<Lhs1, Rhs1>::value
struct type_list_merge_sorted_impl<List<Lhs1, LhsRest...>, List<Rhs1, RhsRest...>, Pred> { struct type_list_merge_sorted_impl<List<Lhs1, LhsRest...>, List<Rhs1, RhsRest...>, Pred> {
using type = type_list_push_front_impl< using type = type_list_push_front_impl<
typename type_list_merge_sorted_impl<List<LhsRest...>, List<Rhs1, RhsRest...>, Pred>::type, Lhs1>::type; typename type_list_merge_sorted_impl<List<LhsRest...>, List<Rhs1, RhsRest...>, Pred>::type, Lhs1>::type;
}; };
template<template<typename...> typename List, typename Lhs1, typename... LhsRest, typename Rhs1, typename... RhsRest, template<template<typename...> typename List, typename Lhs1, typename... LhsRest, typename Rhs1, typename... RhsRest,
template<typename, typename> typename Pred> template<typename, typename> typename Pred>
struct type_list_merge_sorted_impl<List<Lhs1, LhsRest...>, List<Rhs1, RhsRest...>, Pred> { struct type_list_merge_sorted_impl<List<Lhs1, LhsRest...>, List<Rhs1, RhsRest...>, Pred> {
using type = type_list_push_front_impl< using type = type_list_push_front_impl<
typename type_list_merge_sorted_impl<List<Lhs1, LhsRest...>, List<RhsRest...>, Pred>::type, Rhs1>::type; typename type_list_merge_sorted_impl<List<Lhs1, LhsRest...>, List<RhsRest...>, Pred>::type, Rhs1>::type;
}; };
template<TypeList SortedList1, TypeList SortedList2, template<typename, typename> typename Pred> template<TypeList SortedList1, TypeList SortedList2, template<typename, typename> typename Pred>
using type_list_merge_sorted = type_list_merge_sorted_impl<SortedList1, SortedList2, Pred>::type; using type_list_merge_sorted = type_list_merge_sorted_impl<SortedList1, SortedList2, Pred>::type;
// sort // sort
template<typename List, template<typename, typename> typename Pred> template<typename List, template<typename, typename> typename Pred>
@ -227,13 +227,13 @@ template<template<typename...> typename List, typename... Types, template<typena
struct type_list_sort_impl<List<Types...>, Pred> { struct type_list_sort_impl<List<Types...>, Pred> {
using types = List<Types...>; using types = List<Types...>;
using split = type_list_split_half<List<Types...>>; using split = type_list_split_half<List<Types...>>;
using sorted_left = type_list_sort_impl<typename split::first_list, Pred>::type; using sorted_left = type_list_sort_impl<typename split::first_list, Pred>::type;
using sorted_right = type_list_sort_impl<typename split::second_list, Pred>::type; using sorted_right = type_list_sort_impl<typename split::second_list, Pred>::type;
using type = type_list_merge_sorted_impl<sorted_left, sorted_right, Pred>::type; using type = type_list_merge_sorted_impl<sorted_left, sorted_right, Pred>::type;
}; };
template<TypeList List, template<typename, typename> typename Pred> template<TypeList List, template<typename, typename> typename Pred>
using type_list_sort = type_list_sort_impl<List, Pred>::type; using type_list_sort = type_list_sort_impl<List, Pred>::type;
} // namespace mp_units::detail } // namespace mp_units::detail

12
src/core/include/mp-units/ext/type_traits.h
View File

@ -56,7 +56,7 @@ struct conditional_impl<true> {
MP_UNITS_EXPORT_BEGIN MP_UNITS_EXPORT_BEGIN
template<bool B, typename T, typename F> template<bool B, typename T, typename F>
using conditional = detail::conditional_impl<B>::template type<T, F>; using conditional = detail::conditional_impl<B>::template type<T, F>;
// is_same // is_same
template<class T, class U> template<class T, class U>
@ -98,7 +98,7 @@ namespace detail {
template<typename T> template<typename T>
struct get_value_type { struct get_value_type {
using type = T::value_type; using type = T::value_type;
}; };
template<typename T> template<typename T>
@ -111,13 +111,13 @@ struct get_element_type {
template<typename T> template<typename T>
requires requires { typename T::value_type; } || requires { typename T::element_type; } requires requires { typename T::value_type; } || requires { typename T::element_type; }
struct wrapped_type { struct wrapped_type {
using type = using type =
conditional<requires { typename T::value_type; }, detail::get_value_type<T>, detail::get_element_type<T>>::type; conditional<requires { typename T::value_type; }, detail::get_value_type<T>, detail::get_element_type<T>>::type;
}; };
template<typename T> template<typename T>
requires requires { typename T::value_type; } || requires { typename T::element_type; } requires requires { typename T::value_type; } || requires { typename T::element_type; }
using wrapped_type_t = wrapped_type<T>::type; using wrapped_type_t = wrapped_type<T>::type;
template<typename T> template<typename T>
struct value_type { struct value_type {
@ -127,11 +127,11 @@ struct value_type {
template<typename T> template<typename T>
requires requires { typename wrapped_type_t<T>; } requires requires { typename wrapped_type_t<T>; }
struct value_type<T> { struct value_type<T> {
using type = wrapped_type_t<T>; using type = wrapped_type_t<T>;
}; };
template<typename T> template<typename T>
using value_type_t = value_type<T>::type; using value_type_t = value_type<T>::type;
template<typename T, typename... Ts> template<typename T, typename... Ts>
concept one_of = (false || ... || std::same_as<T, Ts>); concept one_of = (false || ... || std::same_as<T, Ts>);

11
src/core/include/mp-units/framework/expression_template.h
View File

@ -122,7 +122,7 @@ struct expr_type_impl<power<T, Ints...>> : std::type_identity<T> {};
} // namespace detail } // namespace detail
template<typename T> template<typename T>
using expr_type = detail::expr_type_impl<T>::type; using expr_type = detail::expr_type_impl<T>::type;
namespace detail { namespace detail {
@ -182,24 +182,25 @@ struct expr_consolidate_impl<type_list<T, Rest...>> {
template<typename T, typename... Rest> template<typename T, typename... Rest>
requires(!is_specialization_of_power<T>) requires(!is_specialization_of_power<T>)
struct expr_consolidate_impl<type_list<T, T, Rest...>> { struct expr_consolidate_impl<type_list<T, T, Rest...>> {
using type = expr_consolidate_impl<type_list<power<T, 2>, Rest...>>::type; using type = expr_consolidate_impl<type_list<power<T, 2>, Rest...>>::type;
}; };
// replaces the instance of a type and a power of it with one with incremented power // replaces the instance of a type and a power of it with one with incremented power
template<typename T, int... Ints, typename... Rest> template<typename T, int... Ints, typename... Rest>
struct expr_consolidate_impl<type_list<T, power<T, Ints...>, Rest...>> { struct expr_consolidate_impl<type_list<T, power<T, Ints...>, Rest...>> {
using type = expr_consolidate_impl<type_list<power_or_T<T, power<T, Ints...>::exponent + 1>, Rest...>>::type; using type =
expr_consolidate_impl<type_list<power_or_T<T, power<T, Ints...>::exponent + 1>, Rest...>>::type;
}; };
// accumulates the powers of instances of the same type (removes the element in case the accumulation result is `0`) // accumulates the powers of instances of the same type (removes the element in case the accumulation result is `0`)
template<typename T, int... Ints1, int... Ints2, typename... Rest> template<typename T, int... Ints1, int... Ints2, typename... Rest>
struct expr_consolidate_impl<type_list<power<T, Ints1...>, power<T, Ints2...>, Rest...>> { struct expr_consolidate_impl<type_list<power<T, Ints1...>, power<T, Ints2...>, Rest...>> {
static constexpr ratio r = power<T, Ints1...>::exponent + power<T, Ints2...>::exponent; static constexpr ratio r = power<T, Ints1...>::exponent + power<T, Ints2...>::exponent;
using type = expr_consolidate_impl<type_list<power_or_T<T, r>, Rest...>>::type; using type = expr_consolidate_impl<type_list<power_or_T<T, r>, Rest...>>::type;
}; };
template<typename List> template<typename List>
using expr_consolidate = expr_consolidate_impl<List>::type; using expr_consolidate = expr_consolidate_impl<List>::type;
/** /**

33
src/core/include/mp-units/framework/quantity_spec.h
View File

@ -1343,22 +1343,19 @@ template<QuantitySpec From, QuantitySpec To>
}; };
if constexpr ((NamedQuantitySpec<decltype(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from_kind))> && if constexpr ((NamedQuantitySpec<decltype(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from_kind))> &&
NamedQuantitySpec<decltype(MP_UNITS_IS_CONST_EXPR_WORKAROUND(to_kind))>) || NamedQuantitySpec<decltype(MP_UNITS_IS_CONST_EXPR_WORKAROUND(to_kind))>) ||
get_complexity(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from_kind)) == get_complexity(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from_kind)) == get_complexity(MP_UNITS_IS_CONST_EXPR_WORKAROUND(to_kind)))
get_complexity(MP_UNITS_IS_CONST_EXPR_WORKAROUND(to_kind)))
return convertible_impl(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from_kind), MP_UNITS_IS_CONST_EXPR_WORKAROUND(to_kind)); return convertible_impl(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from_kind), MP_UNITS_IS_CONST_EXPR_WORKAROUND(to_kind));
else if constexpr (get_complexity(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from_kind)) > else if constexpr (get_complexity(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from_kind)) >
get_complexity(MP_UNITS_IS_CONST_EXPR_WORKAROUND(to_kind))) get_complexity(MP_UNITS_IS_CONST_EXPR_WORKAROUND(to_kind)))
return exploded_kind_result( return exploded_kind_result(convertible_impl(
convertible_impl(get_kind_tree_root(explode<get_complexity(MP_UNITS_IS_CONST_EXPR_WORKAROUND(to_kind))>( get_kind_tree_root(
MP_UNITS_IS_CONST_EXPR_WORKAROUND(from_kind)) explode<get_complexity(MP_UNITS_IS_CONST_EXPR_WORKAROUND(to_kind))>(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from_kind)).quantity),
.quantity), MP_UNITS_IS_CONST_EXPR_WORKAROUND(to_kind)));
MP_UNITS_IS_CONST_EXPR_WORKAROUND(to_kind)));
else else
return exploded_kind_result( return exploded_kind_result(convertible_impl(
convertible_impl(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from_kind), MP_UNITS_IS_CONST_EXPR_WORKAROUND(from_kind),
get_kind_tree_root(explode<get_complexity(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from_kind))>( get_kind_tree_root(
MP_UNITS_IS_CONST_EXPR_WORKAROUND(to_kind)) explode<get_complexity(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from_kind))>(MP_UNITS_IS_CONST_EXPR_WORKAROUND(to_kind)).quantity)));
.quantity)));
} }
template<NamedQuantitySpec From, NamedQuantitySpec To> template<NamedQuantitySpec From, NamedQuantitySpec To>
@ -1376,12 +1373,10 @@ template<NamedQuantitySpec From, NamedQuantitySpec To>
else if constexpr (get_complexity(From{}) != get_complexity(To{})) { else if constexpr (get_complexity(From{}) != get_complexity(To{})) {
if constexpr (get_complexity(From{}) > get_complexity(To{})) if constexpr (get_complexity(From{}) > get_complexity(To{}))
return convertible_impl( return convertible_impl(
explode<get_complexity(MP_UNITS_IS_CONST_EXPR_WORKAROUND(to))>(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from)) explode<get_complexity(MP_UNITS_IS_CONST_EXPR_WORKAROUND(to))>(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from)).quantity,
.quantity,
MP_UNITS_IS_CONST_EXPR_WORKAROUND(to)); MP_UNITS_IS_CONST_EXPR_WORKAROUND(to));
else { else {
auto res = auto res = explode<get_complexity(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from))>(MP_UNITS_IS_CONST_EXPR_WORKAROUND(to));
explode<get_complexity(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from))>(MP_UNITS_IS_CONST_EXPR_WORKAROUND(to));
return min(res.result, convertible_impl(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from), res.quantity)); return min(res.result, convertible_impl(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from), res.quantity));
} }
} }
@ -1414,8 +1409,7 @@ template<QuantitySpec From, QuantitySpec To>
auto eq = explode_to_equation(MP_UNITS_IS_CONST_EXPR_WORKAROUND(to)); auto eq = explode_to_equation(MP_UNITS_IS_CONST_EXPR_WORKAROUND(to));
return min(eq.result, convertible_impl(res.quantity, eq.equation)); return min(eq.result, convertible_impl(res.quantity, eq.equation));
} else } else
return are_ingredients_convertible(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from), return are_ingredients_convertible(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from), MP_UNITS_IS_CONST_EXPR_WORKAROUND(to));
MP_UNITS_IS_CONST_EXPR_WORKAROUND(to));
} else if constexpr (DerivedQuantitySpec<To>) { } else if constexpr (DerivedQuantitySpec<To>) {
auto res = explode<get_complexity(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from))>(MP_UNITS_IS_CONST_EXPR_WORKAROUND(to)); auto res = explode<get_complexity(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from))>(MP_UNITS_IS_CONST_EXPR_WORKAROUND(to));
if constexpr (NamedQuantitySpec<decltype(res.quantity)>) if constexpr (NamedQuantitySpec<decltype(res.quantity)>)
@ -1423,8 +1417,7 @@ template<QuantitySpec From, QuantitySpec To>
else if constexpr (requires { MP_UNITS_IS_CONST_EXPR_WORKAROUND(from)._equation_; }) else if constexpr (requires { MP_UNITS_IS_CONST_EXPR_WORKAROUND(from)._equation_; })
return min(res.result, convertible_impl(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from)._equation_, res.quantity)); return min(res.result, convertible_impl(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from)._equation_, res.quantity));
else else
return min(res.result, are_ingredients_convertible(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from), return min(res.result, are_ingredients_convertible(MP_UNITS_IS_CONST_EXPR_WORKAROUND(from), MP_UNITS_IS_CONST_EXPR_WORKAROUND(to)));
MP_UNITS_IS_CONST_EXPR_WORKAROUND(to)));
} }
// NOLINTEND(bugprone-branch-clone) // NOLINTEND(bugprone-branch-clone)
return no; return no;

31
src/core/include/mp-units/framework/reference.h
View File

@ -87,48 +87,46 @@ struct reference {
} }
template<typename Q2, typename U2> template<typename Q2, typename U2>
[[nodiscard]] friend consteval detail::reference_t<MP_UNITS_EXPRESSION_WORKAROUND(Q{} * Q2{}), [[nodiscard]] friend consteval detail::reference_t< MP_UNITS_EXPRESSION_WORKAROUND(Q{} * Q2{}), MP_UNITS_EXPRESSION_WORKAROUND(U{} * U2{})>
MP_UNITS_EXPRESSION_WORKAROUND(U{} * U2{})>
operator*(reference, reference<Q2, U2>) operator*(reference, reference<Q2, U2>)
{ {
return {}; return {};
} }
template<AssociatedUnit U2> template<AssociatedUnit U2>
[[nodiscard]] friend consteval detail::reference_t<(MP_UNITS_EXPRESSION_WORKAROUND(Q{} * get_quantity_spec(U2{}))), [[nodiscard]] friend consteval detail::reference_t<( MP_UNITS_EXPRESSION_WORKAROUND(Q{} * get_quantity_spec(U2{}))),
MP_UNITS_EXPRESSION_WORKAROUND(U{} * U2{})> MP_UNITS_EXPRESSION_WORKAROUND(U{} * U2{})>
operator*(reference, U2) operator*(reference, U2)
{ {
return {}; return {};
} }
template<AssociatedUnit U1> template<AssociatedUnit U1>
[[nodiscard]] friend consteval detail::reference_t<MP_UNITS_EXPRESSION_WORKAROUND(get_quantity_spec(U1{}) * Q{}), [[nodiscard]] friend consteval detail::reference_t< MP_UNITS_EXPRESSION_WORKAROUND(get_quantity_spec(U1{}) * Q{}),
MP_UNITS_EXPRESSION_WORKAROUND(U1{} * U{})> MP_UNITS_EXPRESSION_WORKAROUND(U1{} * U{})>
operator*(U1, reference) operator*(U1, reference)
{ {
return {}; return {};
} }
template<typename Q2, typename U2> template<typename Q2, typename U2>
[[nodiscard]] friend consteval detail::reference_t<MP_UNITS_EXPRESSION_WORKAROUND(Q{} / Q2{}), [[nodiscard]] friend consteval detail::reference_t< MP_UNITS_EXPRESSION_WORKAROUND(Q{} / Q2{}), MP_UNITS_EXPRESSION_WORKAROUND(U{} / U2{})>
MP_UNITS_EXPRESSION_WORKAROUND(U{} / U2{})>
operator/(reference, reference<Q2, U2>) operator/(reference, reference<Q2, U2>)
{ {
return {}; return {};
} }
template<AssociatedUnit U2> template<AssociatedUnit U2>
[[nodiscard]] friend consteval detail::reference_t<MP_UNITS_EXPRESSION_WORKAROUND(Q{} / get_quantity_spec(U2{})), [[nodiscard]] friend consteval detail::reference_t< MP_UNITS_EXPRESSION_WORKAROUND(Q{} / get_quantity_spec(U2{})),
MP_UNITS_EXPRESSION_WORKAROUND(U{} / U2{})> MP_UNITS_EXPRESSION_WORKAROUND(U{} / U2{})>
operator/(reference, U2) operator/(reference, U2)
{ {
return {}; return {};
} }
template<AssociatedUnit U1> template<AssociatedUnit U1>
[[nodiscard]] friend consteval detail::reference_t<MP_UNITS_EXPRESSION_WORKAROUND(get_quantity_spec(U1{}) / Q{}), [[nodiscard]] friend consteval detail::reference_t< MP_UNITS_EXPRESSION_WORKAROUND(get_quantity_spec(U1{}) / Q{}),
MP_UNITS_EXPRESSION_WORKAROUND(U1{} / U{})> MP_UNITS_EXPRESSION_WORKAROUND(U1{} / U{})>
operator/(U1, reference) operator/(U1, reference)
{ {
return {}; return {};
@ -293,11 +291,10 @@ template<Reference R1, Reference R2, Reference... Rest>
} -> Unit; } -> Unit;
} }
{ {
return detail::reference_t<common_quantity_spec(get_quantity_spec(MP_UNITS_IS_CONST_EXPR_WORKAROUND(r1)), return detail::reference_t<
get_quantity_spec(MP_UNITS_IS_CONST_EXPR_WORKAROUND(r2)), common_quantity_spec(get_quantity_spec(MP_UNITS_IS_CONST_EXPR_WORKAROUND(r1)), get_quantity_spec(MP_UNITS_IS_CONST_EXPR_WORKAROUND(r2)),
get_quantity_spec(rest)...), get_quantity_spec(rest)...),
common_unit(get_unit(MP_UNITS_IS_CONST_EXPR_WORKAROUND(r1)), common_unit(get_unit(MP_UNITS_IS_CONST_EXPR_WORKAROUND(r1)), get_unit(MP_UNITS_IS_CONST_EXPR_WORKAROUND(r2)), get_unit(rest)...)>{};
get_unit(MP_UNITS_IS_CONST_EXPR_WORKAROUND(r2)), get_unit(rest)...)>{};
} }
MP_UNITS_EXPORT_END MP_UNITS_EXPORT_END

78
src/core/include/mp-units/random.h
View File

@ -61,7 +61,7 @@ std::vector<typename Q::rep> bl_qty_to_rep(std::initializer_list<Q>& bl)
template<Quantity Q, typename UnaryOperation> template<Quantity Q, typename UnaryOperation>
std::vector<typename Q::rep> fw_bl_pwc(std::initializer_list<Q>& bl, UnaryOperation fw) std::vector<typename Q::rep> fw_bl_pwc(std::initializer_list<Q>& bl, UnaryOperation fw)
{ {
using rep = Q::rep; using rep = Q::rep;
std::vector<rep> w_bl; std::vector<rep> w_bl;
w_bl.reserve(bl.size()); w_bl.reserve(bl.size());
for (const Q& qty : bl) { for (const Q& qty : bl) {
@ -93,8 +93,8 @@ MP_UNITS_EXPORT_BEGIN
template<Quantity Q> template<Quantity Q>
requires std::integral<typename Q::rep> requires std::integral<typename Q::rep>
struct uniform_int_distribution : public std::uniform_int_distribution<typename Q::rep> { struct uniform_int_distribution : public std::uniform_int_distribution<typename Q::rep> {
using rep = Q::rep; using rep = Q::rep;
using base = std::uniform_int_distribution<rep>; using base = std::uniform_int_distribution<rep>;
uniform_int_distribution() : base() {} uniform_int_distribution() : base() {}
uniform_int_distribution(const Q& a, const Q& b) : uniform_int_distribution(const Q& a, const Q& b) :
@ -118,8 +118,8 @@ struct uniform_int_distribution : public std::uniform_int_distribution<typename
template<Quantity Q> template<Quantity Q>
requires std::floating_point<typename Q::rep> requires std::floating_point<typename Q::rep>
struct uniform_real_distribution : public std::uniform_real_distribution<typename Q::rep> { struct uniform_real_distribution : public std::uniform_real_distribution<typename Q::rep> {
using rep = Q::rep; using rep = Q::rep;
using base = std::uniform_real_distribution<rep>; using base = std::uniform_real_distribution<rep>;
uniform_real_distribution() : base() {} uniform_real_distribution() : base() {}
uniform_real_distribution(const Q& a, const Q& b) : uniform_real_distribution(const Q& a, const Q& b) :
@ -143,8 +143,8 @@ struct uniform_real_distribution : public std::uniform_real_distribution<typenam
template<Quantity Q> template<Quantity Q>
requires std::integral<typename Q::rep> requires std::integral<typename Q::rep>
struct binomial_distribution : public std::binomial_distribution<typename Q::rep> { struct binomial_distribution : public std::binomial_distribution<typename Q::rep> {
using rep = Q::rep; using rep = Q::rep;
using base = std::binomial_distribution<rep>; using base = std::binomial_distribution<rep>;
binomial_distribution() : base() {} binomial_distribution() : base() {}
binomial_distribution(const Q& t, double p) : base(t.numerical_value_ref_in(Q::unit), p) {} binomial_distribution(const Q& t, double p) : base(t.numerical_value_ref_in(Q::unit), p) {}
@ -164,8 +164,8 @@ struct binomial_distribution : public std::binomial_distribution<typename Q::rep
template<Quantity Q> template<Quantity Q>
requires std::integral<typename Q::rep> requires std::integral<typename Q::rep>
struct negative_binomial_distribution : public std::negative_binomial_distribution<typename Q::rep> { struct negative_binomial_distribution : public std::negative_binomial_distribution<typename Q::rep> {
using rep = Q::rep; using rep = Q::rep;
using base = std::negative_binomial_distribution<rep>; using base = std::negative_binomial_distribution<rep>;
negative_binomial_distribution() : base() {} negative_binomial_distribution() : base() {}
negative_binomial_distribution(const Q& k, double p) : base(k.numerical_value_ref_in(Q::unit), p) {} negative_binomial_distribution(const Q& k, double p) : base(k.numerical_value_ref_in(Q::unit), p) {}
@ -185,8 +185,8 @@ struct negative_binomial_distribution : public std::negative_binomial_distributi
template<Quantity Q> template<Quantity Q>
requires std::integral<typename Q::rep> requires std::integral<typename Q::rep>
struct geometric_distribution : public std::geometric_distribution<typename Q::rep> { struct geometric_distribution : public std::geometric_distribution<typename Q::rep> {
using rep = Q::rep; using rep = Q::rep;
using base = std::geometric_distribution<rep>; using base = std::geometric_distribution<rep>;
geometric_distribution() : base() {} geometric_distribution() : base() {}
explicit geometric_distribution(double p) : base(p) {} explicit geometric_distribution(double p) : base(p) {}
@ -204,8 +204,8 @@ struct geometric_distribution : public std::geometric_distribution<typename Q::r
template<Quantity Q> template<Quantity Q>
requires std::integral<typename Q::rep> requires std::integral<typename Q::rep>
struct poisson_distribution : public std::poisson_distribution<typename Q::rep> { struct poisson_distribution : public std::poisson_distribution<typename Q::rep> {
using rep = Q::rep; using rep = Q::rep;
using base = std::poisson_distribution<rep>; using base = std::poisson_distribution<rep>;
poisson_distribution() : base() {} poisson_distribution() : base() {}
explicit poisson_distribution(double p) : base(p) {} explicit poisson_distribution(double p) : base(p) {}
@ -223,8 +223,8 @@ struct poisson_distribution : public std::poisson_distribution<typename Q::rep>
template<Quantity Q> template<Quantity Q>
requires std::floating_point<typename Q::rep> requires std::floating_point<typename Q::rep>
struct exponential_distribution : public std::exponential_distribution<typename Q::rep> { struct exponential_distribution : public std::exponential_distribution<typename Q::rep> {
using rep = Q::rep; using rep = Q::rep;
using base = std::exponential_distribution<rep>; using base = std::exponential_distribution<rep>;
exponential_distribution() : base() {} exponential_distribution() : base() {}
explicit exponential_distribution(const rep& lambda) : base(lambda) {} explicit exponential_distribution(const rep& lambda) : base(lambda) {}
@ -242,8 +242,8 @@ struct exponential_distribution : public std::exponential_distribution<typename
template<Quantity Q> template<Quantity Q>
requires std::floating_point<typename Q::rep> requires std::floating_point<typename Q::rep>
struct gamma_distribution : public std::gamma_distribution<typename Q::rep> { struct gamma_distribution : public std::gamma_distribution<typename Q::rep> {
using rep = Q::rep; using rep = Q::rep;
using base = std::gamma_distribution<rep>; using base = std::gamma_distribution<rep>;
gamma_distribution() : base() {} gamma_distribution() : base() {}
gamma_distribution(const rep& alpha, const rep& beta) : base(alpha, beta) {} gamma_distribution(const rep& alpha, const rep& beta) : base(alpha, beta) {}
@ -261,8 +261,8 @@ struct gamma_distribution : public std::gamma_distribution<typename Q::rep> {
template<Quantity Q> template<Quantity Q>
requires std::floating_point<typename Q::rep> requires std::floating_point<typename Q::rep>
struct weibull_distribution : public std::weibull_distribution<typename Q::rep> { struct weibull_distribution : public std::weibull_distribution<typename Q::rep> {
using rep = Q::rep; using rep = Q::rep;
using base = std::weibull_distribution<rep>; using base = std::weibull_distribution<rep>;
weibull_distribution() : base() {} weibull_distribution() : base() {}
weibull_distribution(const rep& a, const rep& b) : base(a, b) {} weibull_distribution(const rep& a, const rep& b) : base(a, b) {}
@ -280,8 +280,8 @@ struct weibull_distribution : public std::weibull_distribution<typename Q::rep>
template<Quantity Q> template<Quantity Q>
requires std::floating_point<typename Q::rep> requires std::floating_point<typename Q::rep>
struct extreme_value_distribution : public std::extreme_value_distribution<typename Q::rep> { struct extreme_value_distribution : public std::extreme_value_distribution<typename Q::rep> {
using rep = Q::rep; using rep = Q::rep;
using base = std::extreme_value_distribution<rep>; using base = std::extreme_value_distribution<rep>;
extreme_value_distribution() : base() {} extreme_value_distribution() : base() {}
extreme_value_distribution(const Q& a, const rep& b) : base(a.numerical_value_ref_in(Q::unit), b) {} extreme_value_distribution(const Q& a, const rep& b) : base(a.numerical_value_ref_in(Q::unit), b) {}
@ -301,8 +301,8 @@ struct extreme_value_distribution : public std::extreme_value_distribution<typen
template<Quantity Q> template<Quantity Q>
requires std::floating_point<typename Q::rep> requires std::floating_point<typename Q::rep>
struct normal_distribution : public std::normal_distribution<typename Q::rep> { struct normal_distribution : public std::normal_distribution<typename Q::rep> {
using rep = Q::rep; using rep = Q::rep;
using base = std::normal_distribution<rep>; using base = std::normal_distribution<rep>;
normal_distribution() : base() {} normal_distribution() : base() {}
normal_distribution(const Q& mean, const Q& stddev) : normal_distribution(const Q& mean, const Q& stddev) :
@ -326,8 +326,8 @@ struct normal_distribution : public std::normal_distribution<typename Q::rep> {
template<Quantity Q> template<Quantity Q>
requires std::floating_point<typename Q::rep> requires std::floating_point<typename Q::rep>
struct lognormal_distribution : public std::lognormal_distribution<typename Q::rep> { struct lognormal_distribution : public std::lognormal_distribution<typename Q::rep> {
using rep = Q::rep; using rep = Q::rep;
using base = std::lognormal_distribution<rep>; using base = std::lognormal_distribution<rep>;
lognormal_distribution() : base() {} lognormal_distribution() : base() {}
lognormal_distribution(const Q& m, const Q& s) : lognormal_distribution(const Q& m, const Q& s) :
@ -351,8 +351,8 @@ struct lognormal_distribution : public std::lognormal_distribution<typename Q::r
template<Quantity Q> template<Quantity Q>
requires std::floating_point<typename Q::rep> requires std::floating_point<typename Q::rep>
struct chi_squared_distribution : public std::chi_squared_distribution<typename Q::rep> { struct chi_squared_distribution : public std::chi_squared_distribution<typename Q::rep> {
using rep = Q::rep; using rep = Q::rep;
using base = std::chi_squared_distribution<rep>; using base = std::chi_squared_distribution<rep>;
chi_squared_distribution() : base() {} chi_squared_distribution() : base() {}
explicit chi_squared_distribution(const rep& n) : base(n) {} explicit chi_squared_distribution(const rep& n) : base(n) {}
@ -370,8 +370,8 @@ struct chi_squared_distribution : public std::chi_squared_distribution<typename
template<Quantity Q> template<Quantity Q>
requires std::floating_point<typename Q::rep> requires std::floating_point<typename Q::rep>
struct cauchy_distribution : public std::cauchy_distribution<typename Q::rep> { struct cauchy_distribution : public std::cauchy_distribution<typename Q::rep> {
using rep = Q::rep; using rep = Q::rep;
using base = std::cauchy_distribution<rep>; using base = std::cauchy_distribution<rep>;
cauchy_distribution() : base() {} cauchy_distribution() : base() {}
cauchy_distribution(const Q& a, const Q& b) : cauchy_distribution(const Q& a, const Q& b) :
@ -395,8 +395,8 @@ struct cauchy_distribution : public std::cauchy_distribution<typename Q::rep> {
template<Quantity Q> template<Quantity Q>
requires std::floating_point<typename Q::rep> requires std::floating_point<typename Q::rep>
struct fisher_f_distribution : public std::fisher_f_distribution<typename Q::rep> { struct fisher_f_distribution : public std::fisher_f_distribution<typename Q::rep> {
using rep = Q::rep; using rep = Q::rep;
using base = std::fisher_f_distribution<rep>; using base = std::fisher_f_distribution<rep>;
fisher_f_distribution() : base() {} fisher_f_distribution() : base() {}
fisher_f_distribution(const rep& m, const rep& n) : base(m, n) {} fisher_f_distribution(const rep& m, const rep& n) : base(m, n) {}
@ -414,8 +414,8 @@ struct fisher_f_distribution : public std::fisher_f_distribution<typename Q::rep
template<Quantity Q> template<Quantity Q>
requires std::floating_point<typename Q::rep> requires std::floating_point<typename Q::rep>
struct student_t_distribution : public std::student_t_distribution<typename Q::rep> { struct student_t_distribution : public std::student_t_distribution<typename Q::rep> {
using rep = Q::rep; using rep = Q::rep;
using base = std::student_t_distribution<rep>; using base = std::student_t_distribution<rep>;
student_t_distribution() : base() {} student_t_distribution() : base() {}
explicit student_t_distribution(const rep& n) : base(n) {} explicit student_t_distribution(const rep& n) : base(n) {}
@ -433,8 +433,8 @@ struct student_t_distribution : public std::student_t_distribution<typename Q::r
template<Quantity Q> template<Quantity Q>
requires std::integral<typename Q::rep> requires std::integral<typename Q::rep>
struct discrete_distribution : public std::discrete_distribution<typename Q::rep> { struct discrete_distribution : public std::discrete_distribution<typename Q::rep> {
using rep = Q::rep; using rep = Q::rep;
using base = std::discrete_distribution<rep>; using base = std::discrete_distribution<rep>;
discrete_distribution() : base() {} discrete_distribution() : base() {}
@ -464,8 +464,8 @@ struct discrete_distribution : public std::discrete_distribution<typename Q::rep
template<Quantity Q> template<Quantity Q>
requires std::floating_point<typename Q::rep> requires std::floating_point<typename Q::rep>
class piecewise_constant_distribution : public std::piecewise_constant_distribution<typename Q::rep> { class piecewise_constant_distribution : public std::piecewise_constant_distribution<typename Q::rep> {
using rep = Q::rep; using rep = Q::rep;
using base = std::piecewise_constant_distribution<rep>; using base = std::piecewise_constant_distribution<rep>;
template<typename InputIt> template<typename InputIt>
piecewise_constant_distribution(const std::vector<rep>& i, InputIt first_w) : base(i.cbegin(), i.cend(), first_w) piecewise_constant_distribution(const std::vector<rep>& i, InputIt first_w) : base(i.cbegin(), i.cend(), first_w)
@ -523,8 +523,8 @@ public:
template<Quantity Q> template<Quantity Q>
requires std::floating_point<typename Q::rep> requires std::floating_point<typename Q::rep>
class piecewise_linear_distribution : public std::piecewise_linear_distribution<typename Q::rep> { class piecewise_linear_distribution : public std::piecewise_linear_distribution<typename Q::rep> {
using rep = Q::rep; using rep = Q::rep;
using base = std::piecewise_linear_distribution<rep>; using base = std::piecewise_linear_distribution<rep>;
template<typename InputIt> template<typename InputIt>
piecewise_linear_distribution(const std::vector<rep>& i, InputIt first_w) : base(i.cbegin(), i.cend(), first_w) piecewise_linear_distribution(const std::vector<rep>& i, InputIt first_w) : base(i.cbegin(), i.cend(), first_w)

4
src/systems/include/mp-units/systems/si/chrono.h
View File

@ -137,8 +137,8 @@ template<QuantityPointOf<MP_UNITS_IS_VALUE_WORKAROUND(isq::time)> QP>
requires is_specialization_of<std::remove_const_t<decltype(QP::absolute_point_origin)>, chrono_point_origin_> requires is_specialization_of<std::remove_const_t<decltype(QP::absolute_point_origin)>, chrono_point_origin_>
[[nodiscard]] constexpr auto to_chrono_time_point(const QP& qp) [[nodiscard]] constexpr auto to_chrono_time_point(const QP& qp)
{ {
using clock = decltype(QP::absolute_point_origin)::clock; using clock = decltype(QP::absolute_point_origin)::clock;
using rep = QP::rep; using rep = QP::rep;
using ret_type = using ret_type =
std::chrono::time_point<clock, std::chrono::time_point<clock,
std::chrono::duration<rep, decltype(detail::as_ratio(get_canonical_unit(QP::unit).mag))>>; std::chrono::duration<rep, decltype(detail::as_ratio(get_canonical_unit(QP::unit).mag))>>;

9
src/systems/include/mp-units/systems/si/math.h
View File

@ -87,8 +87,7 @@ template<ReferenceOf<MP_UNITS_IS_VALUE_WORKAROUND(isq::angular_measure)> auto R,
template<ReferenceOf<dimensionless> auto R, typename Rep> template<ReferenceOf<dimensionless> auto R, typename Rep>
requires requires(Rep v) { asin(v); } || requires(Rep v) { std::asin(v); } requires requires(Rep v) { asin(v); } || requires(Rep v) { std::asin(v); }
[[nodiscard]] inline QuantityOf<MP_UNITS_IS_VALUE_WORKAROUND(isq::angular_measure)> auto asin( [[nodiscard]] inline QuantityOf<MP_UNITS_IS_VALUE_WORKAROUND(isq::angular_measure)> auto asin(const quantity<R, Rep>& q) noexcept
const quantity<R, Rep>& q) noexcept
{ {
using std::asin; using std::asin;
if constexpr (!treat_as_floating_point<Rep>) { if constexpr (!treat_as_floating_point<Rep>) {
@ -102,8 +101,7 @@ template<ReferenceOf<dimensionless> auto R, typename Rep>
template<ReferenceOf<dimensionless> auto R, typename Rep> template<ReferenceOf<dimensionless> auto R, typename Rep>
requires requires(Rep v) { acos(v); } || requires(Rep v) { std::acos(v); } requires requires(Rep v) { acos(v); } || requires(Rep v) { std::acos(v); }
[[nodiscard]] inline QuantityOf<MP_UNITS_IS_VALUE_WORKAROUND(isq::angular_measure)> auto acos( [[nodiscard]] inline QuantityOf<MP_UNITS_IS_VALUE_WORKAROUND(isq::angular_measure)> auto acos(const quantity<R, Rep>& q) noexcept
const quantity<R, Rep>& q) noexcept
{ {
using std::acos; using std::acos;
if constexpr (!treat_as_floating_point<Rep>) { if constexpr (!treat_as_floating_point<Rep>) {
@ -117,8 +115,7 @@ template<ReferenceOf<dimensionless> auto R, typename Rep>
template<ReferenceOf<dimensionless> auto R, typename Rep> template<ReferenceOf<dimensionless> auto R, typename Rep>
requires requires(Rep v) { atan(v); } || requires(Rep v) { std::atan(v); } requires requires(Rep v) { atan(v); } || requires(Rep v) { std::atan(v); }
[[nodiscard]] inline QuantityOf<MP_UNITS_IS_VALUE_WORKAROUND(isq::angular_measure)> auto atan( [[nodiscard]] inline QuantityOf<MP_UNITS_IS_VALUE_WORKAROUND(isq::angular_measure)> auto atan(const quantity<R, Rep>& q) noexcept
const quantity<R, Rep>& q) noexcept
{ {
using std::atan; using std::atan;
if constexpr (!treat_as_floating_point<Rep>) { if constexpr (!treat_as_floating_point<Rep>) {

10
test/runtime/CMakeLists.txt
View File

@ -37,11 +37,11 @@ if(${projectPrefix}BUILD_CXX_MODULES)
endif() endif()
target_link_libraries(unit_tests_runtime PRIVATE mp-units::mp-units Catch2::Catch2WithMain) target_link_libraries(unit_tests_runtime PRIVATE mp-units::mp-units Catch2::Catch2WithMain)
if(${projectPrefix}DEV_BUILD_LA) # if(${projectPrefix}DEV_BUILD_LA)
find_package(wg21_linear_algebra REQUIRED) # find_package(wg21_linear_algebra REQUIRED)
target_sources(unit_tests_runtime PRIVATE linear_algebra_test.cpp) # target_sources(unit_tests_runtime PRIVATE linear_algebra_test.cpp)
target_link_libraries(unit_tests_runtime PRIVATE wg21_linear_algebra::wg21_linear_algebra) # target_link_libraries(unit_tests_runtime PRIVATE wg21_linear_algebra::wg21_linear_algebra)
endif() # endif()
if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC") if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
target_compile_options( target_compile_options(

76
test/static/chrono_test.cpp
View File

@ -57,41 +57,43 @@ static_assert(!QuantityPoint<sys_seconds>);
// construction - same rep type // construction - same rep type
static_assert( static_assert(
std::constructible_from<quantity<isq::time[si::second], std::chrono::seconds::rep>, std::chrono::seconds>); std::constructible_from<quantity<(isq::time[si::second]), std::chrono::seconds::rep>, std::chrono::seconds>);
static_assert(std::convertible_to<std::chrono::seconds, quantity<isq::time[si::second], std::chrono::seconds::rep>>); static_assert(std::convertible_to<std::chrono::seconds, quantity<(isq::time[si::second]), std::chrono::seconds::rep>>);
static_assert(std::constructible_from<quantity<isq::time[si::hour], std::chrono::hours::rep>, std::chrono::hours>); static_assert(std::constructible_from<quantity<(isq::time[si::hour]), std::chrono::hours::rep>, std::chrono::hours>);
static_assert(std::convertible_to<std::chrono::hours, quantity<isq::time[si::hour], std::chrono::hours::rep>>); static_assert(std::convertible_to<std::chrono::hours, quantity<(isq::time[si::hour]), std::chrono::hours::rep>>);
static_assert(std::constructible_from<quantity<isq::time[si::second], std::chrono::hours::rep>, std::chrono::hours>); static_assert(std::constructible_from<quantity<(isq::time[si::second]), std::chrono::hours::rep>, std::chrono::hours>);
static_assert(std::convertible_to<std::chrono::hours, quantity<isq::time[si::second], std::chrono::hours::rep>>); static_assert(std::convertible_to<std::chrono::hours, quantity<(isq::time[si::second]), std::chrono::hours::rep>>);
static_assert(!std::constructible_from<quantity<isq::time[si::hour], std::chrono::seconds::rep>, std::chrono::seconds>);
static_assert(!std::convertible_to<std::chrono::seconds, quantity<isq::time[si::hour], std::chrono::seconds::rep>>);
static_assert( static_assert(
std::constructible_from<time_point<si::second, std::chrono::system_clock, sys_seconds::rep>, sys_seconds>); !std::constructible_from<quantity<(isq::time[si::hour]), std::chrono::seconds::rep>, std::chrono::seconds>);
static_assert(!std::convertible_to<std::chrono::seconds, quantity<(isq::time[si::hour]), std::chrono::seconds::rep>>);
static_assert( static_assert(
!std::constructible_from<time_point<si::second, std::chrono::steady_clock, sys_seconds::rep>, sys_seconds>); std::constructible_from<time_point<(si::second), std::chrono::system_clock, sys_seconds::rep>, sys_seconds>);
static_assert(std::convertible_to<sys_seconds, time_point<si::second, std::chrono::system_clock, sys_seconds::rep>>); static_assert(
static_assert(std::constructible_from<time_point<si::day, std::chrono::system_clock, sys_days::rep>, sys_days>); !std::constructible_from<time_point<(si::second), std::chrono::steady_clock, sys_seconds::rep>, sys_seconds>);
static_assert(!std::constructible_from<time_point<si::day, std::chrono::steady_clock, sys_days::rep>, sys_days>); static_assert(std::convertible_to<sys_seconds, time_point<(si::second), std::chrono::system_clock, sys_seconds::rep>>);
static_assert(std::convertible_to<sys_days, time_point<si::day, std::chrono::system_clock, sys_days::rep>>); static_assert(std::constructible_from<time_point<(si::day), std::chrono::system_clock, sys_days::rep>, sys_days>);
static_assert(std::constructible_from<time_point<si::second, std::chrono::system_clock, sys_days::rep>, sys_days>); static_assert(!std::constructible_from<time_point<(si::day), std::chrono::steady_clock, sys_days::rep>, sys_days>);
static_assert(!std::constructible_from<time_point<si::second, std::chrono::steady_clock, sys_days::rep>, sys_days>); static_assert(std::convertible_to<sys_days, time_point<(si::day), std::chrono::system_clock, sys_days::rep>>);
static_assert(std::convertible_to<sys_days, time_point<si::second, std::chrono::system_clock, sys_days::rep>>); static_assert(std::constructible_from<time_point<(si::second), std::chrono::system_clock, sys_days::rep>, sys_days>);
static_assert(!std::constructible_from<time_point<si::day, std::chrono::system_clock, sys_seconds::rep>, sys_seconds>); static_assert(!std::constructible_from<time_point<(si::second), std::chrono::steady_clock, sys_days::rep>, sys_days>);
static_assert(!std::convertible_to<sys_seconds, time_point<si::day, std::chrono::system_clock, sys_seconds::rep>>); static_assert(std::convertible_to<sys_days, time_point<(si::second), std::chrono::system_clock, sys_days::rep>>);
static_assert(
!std::constructible_from<time_point<(si::day), std::chrono::system_clock, sys_seconds::rep>, sys_seconds>);
static_assert(!std::convertible_to<sys_seconds, time_point<(si::day), std::chrono::system_clock, sys_seconds::rep>>);
// construction - different rep type (integral to a floating-point) // construction - different rep type (integral to a floating-point)
static_assert(std::constructible_from<quantity<isq::time[si::second]>, std::chrono::seconds>); static_assert(std::constructible_from<quantity<(isq::time[si::second])>, std::chrono::seconds>);
static_assert(std::convertible_to<std::chrono::seconds, quantity<isq::time[si::second]>>); static_assert(std::convertible_to<std::chrono::seconds, quantity<(isq::time[si::second])>>);
static_assert(std::constructible_from<quantity<isq::time[si::second]>, std::chrono::hours>); static_assert(std::constructible_from<quantity<(isq::time[si::second])>, std::chrono::hours>);
static_assert(std::convertible_to<std::chrono::hours, quantity<isq::time[si::second]>>); static_assert(std::convertible_to<std::chrono::hours, quantity<(isq::time[si::second])>>);
static_assert(std::constructible_from<quantity<isq::time[si::hour]>, std::chrono::seconds>); static_assert(std::constructible_from<quantity<(isq::time[si::hour])>, std::chrono::seconds>);
static_assert(std::convertible_to<std::chrono::seconds, quantity<isq::time[si::hour]>>); static_assert(std::convertible_to<std::chrono::seconds, quantity<(isq::time[si::hour])>>);
static_assert(std::constructible_from<time_point<si::second, std::chrono::system_clock>, sys_seconds>); static_assert(std::constructible_from<time_point<(si::second), std::chrono::system_clock>, sys_seconds>);
static_assert(std::convertible_to<sys_seconds, time_point<si::second, std::chrono::system_clock>>); static_assert(std::convertible_to<sys_seconds, time_point<(si::second), std::chrono::system_clock>>);
static_assert(std::constructible_from<time_point<si::second, std::chrono::system_clock>, sys_days>); static_assert(std::constructible_from<time_point<(si::second), std::chrono::system_clock>, sys_days>);
static_assert(std::convertible_to<sys_days, time_point<si::second, std::chrono::system_clock>>); static_assert(std::convertible_to<sys_days, time_point<(si::second), std::chrono::system_clock>>);
static_assert(std::constructible_from<time_point<si::day, std::chrono::system_clock>, sys_seconds>); static_assert(std::constructible_from<time_point<(si::day), std::chrono::system_clock>, sys_seconds>);
static_assert(std::convertible_to<sys_seconds, time_point<si::day, std::chrono::system_clock>>); static_assert(std::convertible_to<sys_seconds, time_point<(si::day), std::chrono::system_clock>>);
static_assert(quantity<si::second>{1s} == 1 * s); static_assert(quantity<si::second>{1s} == 1 * s);
static_assert(quantity<isq::time[si::second]>{1s} == 1 * s); static_assert(quantity<isq::time[si::second]>{1s} == 1 * s);
@ -107,13 +109,13 @@ static_assert(is_of_type<quantity_point{sys_days{sys_days::duration{1}}},
// conversion to chrono // conversion to chrono
static_assert( static_assert(
std::constructible_from<std::chrono::seconds, quantity<isq::time[si::second], std::chrono::seconds::rep>>); std::constructible_from<std::chrono::seconds, quantity<(isq::time[si::second]), std::chrono::seconds::rep>>);
static_assert(std::convertible_to<quantity<isq::time[si::second], std::chrono::seconds::rep>, std::chrono::seconds>); static_assert(std::convertible_to<quantity<(isq::time[si::second]), std::chrono::seconds::rep>, std::chrono::seconds>);
static_assert(std::constructible_from<std::chrono::hours, quantity<isq::time[si::hour], std::chrono::hours::rep>>); static_assert(std::constructible_from<std::chrono::hours, quantity<(isq::time[si::hour]), std::chrono::hours::rep>>);
static_assert(std::convertible_to<quantity<isq::time[si::hour], std::chrono::hours::rep>, std::chrono::hours>); static_assert(std::convertible_to<quantity<(isq::time[si::hour]), std::chrono::hours::rep>, std::chrono::hours>);
static_assert( static_assert(
std::constructible_from<sys_seconds, time_point<si::second, std::chrono::system_clock, sys_seconds::rep>>); std::constructible_from<sys_seconds, time_point<(si::second), std::chrono::system_clock, sys_seconds::rep>>);
static_assert(std::convertible_to<time_point<si::second, std::chrono::system_clock, sys_seconds::rep>, sys_seconds>); static_assert(std::convertible_to<time_point<(si::second), std::chrono::system_clock, sys_seconds::rep>, sys_seconds>);
// units mapping // units mapping
static_assert(quantity{1ns} == 1 * ns); static_assert(quantity{1ns} == 1 * ns);

242
test/static/concepts_test.cpp
View File

@ -83,7 +83,7 @@ inline constexpr auto speed = isq::length / isq::time;
static_assert(QuantitySpec<struct isq::length>); static_assert(QuantitySpec<struct isq::length>);
static_assert(QuantitySpec<struct isq::radius>); static_assert(QuantitySpec<struct isq::radius>);
static_assert(QuantitySpec<struct isq::speed>); static_assert(QuantitySpec<struct isq::speed>);
static_assert(QuantitySpec<decltype(kind_of<isq::length>)>); static_assert(QuantitySpec<decltype(kind_of<(isq::length)>)>);
static_assert(QuantitySpec<decltype(isq::length / isq::time)>); static_assert(QuantitySpec<decltype(isq::length / isq::time)>);
static_assert(QuantitySpec<decltype(pow<2>(isq::length))>); static_assert(QuantitySpec<decltype(pow<2>(isq::length))>);
static_assert(QuantitySpec<struct dimensionless>); static_assert(QuantitySpec<struct dimensionless>);
@ -95,7 +95,7 @@ static_assert(!QuantitySpec<int>);
static_assert(detail::NamedQuantitySpec<struct isq::length>); static_assert(detail::NamedQuantitySpec<struct isq::length>);
static_assert(detail::NamedQuantitySpec<struct isq::radius>); static_assert(detail::NamedQuantitySpec<struct isq::radius>);
static_assert(detail::NamedQuantitySpec<struct isq::speed>); static_assert(detail::NamedQuantitySpec<struct isq::speed>);
static_assert(!detail::NamedQuantitySpec<std::remove_const_t<decltype(kind_of<isq::length>)>>); static_assert(!detail::NamedQuantitySpec<std::remove_const_t<decltype(kind_of<(isq::length)>)>>);
static_assert(!detail::NamedQuantitySpec<decltype(isq::length / isq::time)>); static_assert(!detail::NamedQuantitySpec<decltype(isq::length / isq::time)>);
static_assert(!detail::NamedQuantitySpec<decltype(pow<2>(isq::length))>); static_assert(!detail::NamedQuantitySpec<decltype(pow<2>(isq::length))>);
static_assert(detail::NamedQuantitySpec<struct dimensionless>); static_assert(detail::NamedQuantitySpec<struct dimensionless>);
@ -106,7 +106,7 @@ static_assert(!detail::NamedQuantitySpec<int>);
// DerivedQuantitySpec // DerivedQuantitySpec
static_assert(!detail::DerivedQuantitySpec<struct isq::length>); static_assert(!detail::DerivedQuantitySpec<struct isq::length>);
static_assert(!detail::DerivedQuantitySpec<struct isq::radius>); static_assert(!detail::DerivedQuantitySpec<struct isq::radius>);
static_assert(!detail::DerivedQuantitySpec<decltype(kind_of<isq::length>)>); static_assert(!detail::DerivedQuantitySpec<decltype(kind_of<(isq::length)>)>);
static_assert(!detail::DerivedQuantitySpec<struct isq::speed>); static_assert(!detail::DerivedQuantitySpec<struct isq::speed>);
static_assert(detail::DerivedQuantitySpec<decltype(isq::length / isq::time)>); static_assert(detail::DerivedQuantitySpec<decltype(isq::length / isq::time)>);
static_assert(detail::DerivedQuantitySpec<decltype(pow<2>(isq::length))>); static_assert(detail::DerivedQuantitySpec<decltype(pow<2>(isq::length))>);
@ -118,7 +118,7 @@ static_assert(!detail::DerivedQuantitySpec<int>);
// QuantityKindSpec // QuantityKindSpec
static_assert(!detail::QuantityKindSpec<struct isq::length>); static_assert(!detail::QuantityKindSpec<struct isq::length>);
static_assert(!detail::QuantityKindSpec<struct isq::radius>); static_assert(!detail::QuantityKindSpec<struct isq::radius>);
static_assert(detail::QuantityKindSpec<std::remove_const_t<decltype(kind_of<isq::length>)>>); static_assert(detail::QuantityKindSpec<std::remove_const_t<decltype(kind_of<(isq::length)>)>>);
static_assert(!detail::QuantityKindSpec<struct isq::speed>); static_assert(!detail::QuantityKindSpec<struct isq::speed>);
static_assert(!detail::QuantityKindSpec<decltype(isq::length / isq::time)>); static_assert(!detail::QuantityKindSpec<decltype(isq::length / isq::time)>);
static_assert(!detail::QuantityKindSpec<decltype(pow<2>(isq::length))>); static_assert(!detail::QuantityKindSpec<decltype(pow<2>(isq::length))>);
@ -133,7 +133,7 @@ static_assert(!detail::QuantityKindSpec<int>);
// Unit // Unit
static_assert(Unit<struct si::metre>); static_assert(Unit<struct si::metre>);
static_assert(Unit<decltype(si::kilogram)>); static_assert(Unit<decltype(si::kilogram)>);
static_assert(Unit<decltype(si::kilo<si::gram>)>); static_assert(Unit<decltype(si::kilo<(si::gram)>)>);
static_assert(Unit<struct natural::electronvolt>); static_assert(Unit<struct natural::electronvolt>);
static_assert(Unit<decltype(si::metre / si::second)>); static_assert(Unit<decltype(si::metre / si::second)>);
static_assert(Unit<decltype(inverse(si::second))>); static_assert(Unit<decltype(inverse(si::second))>);
@ -144,11 +144,11 @@ static_assert(Unit<struct si::standard_gravity>);
static_assert(Unit<scaled_unit<mag<10>, struct si::second>>); static_assert(Unit<scaled_unit<mag<10>, struct si::second>>);
static_assert(Unit<derived_unit<struct si::metre, per<struct si::second>>>); static_assert(Unit<derived_unit<struct si::metre, per<struct si::second>>>);
static_assert(Unit<struct one>); static_assert(Unit<struct one>);
static_assert(!Unit<named_unit<"?", kind_of<isq::length>>>); static_assert(!Unit<named_unit<"?", kind_of<(isq::length)>>>);
static_assert(!Unit<named_unit<"?">>); static_assert(!Unit<named_unit<"?">>);
static_assert(!Unit<named_unit<"?", si::metre / si::second>>); static_assert(!Unit<named_unit<"?", si::metre / si::second>>);
static_assert(!Unit<named_unit<"?", si::metre, kind_of<isq::length>>>); static_assert(!Unit<named_unit<"?", (si::metre), kind_of<(isq::length)>>>);
static_assert(!Unit<prefixed_unit<"?", mag<10>, si::second>>); static_assert(!Unit<prefixed_unit<"?", mag<10>, (si::second)>>);
static_assert(!Unit<struct isq::dim_length>); static_assert(!Unit<struct isq::dim_length>);
static_assert(!Unit<int>); static_assert(!Unit<int>);
#if MP_UNITS_HOSTED #if MP_UNITS_HOSTED
@ -159,7 +159,7 @@ static_assert(!Unit<std::chrono::seconds>);
static_assert(PrefixableUnit<struct si::metre>); static_assert(PrefixableUnit<struct si::metre>);
static_assert(PrefixableUnit<struct natural::electronvolt>); static_assert(PrefixableUnit<struct natural::electronvolt>);
static_assert(!PrefixableUnit<decltype(si::kilogram)>); static_assert(!PrefixableUnit<decltype(si::kilogram)>);
static_assert(!PrefixableUnit<decltype(si::kilo<si::gram>)>); static_assert(!PrefixableUnit<decltype(si::kilo<(si::gram)>)>);
static_assert(!PrefixableUnit<decltype(si::metre / si::second)>); static_assert(!PrefixableUnit<decltype(si::metre / si::second)>);
static_assert(!PrefixableUnit<decltype(inverse(si::second))>); static_assert(!PrefixableUnit<decltype(inverse(si::second))>);
static_assert(!PrefixableUnit<decltype(mag<10> * si::second)>); static_assert(!PrefixableUnit<decltype(mag<10> * si::second)>);
@ -169,11 +169,11 @@ static_assert(PrefixableUnit<struct si::standard_gravity>);
static_assert(!PrefixableUnit<scaled_unit<mag<10>, struct si::second>>); static_assert(!PrefixableUnit<scaled_unit<mag<10>, struct si::second>>);
static_assert(!PrefixableUnit<derived_unit<struct si::metre, per<struct si::second>>>); static_assert(!PrefixableUnit<derived_unit<struct si::metre, per<struct si::second>>>);
static_assert(!PrefixableUnit<struct one>); static_assert(!PrefixableUnit<struct one>);
static_assert(!PrefixableUnit<named_unit<"?", kind_of<isq::length>>>); static_assert(!PrefixableUnit<named_unit<"?", kind_of<(isq::length)>>>);
static_assert(!PrefixableUnit<named_unit<"?">>); static_assert(!PrefixableUnit<named_unit<"?">>);
static_assert(!PrefixableUnit<named_unit<"?", si::metre / si::second>>); static_assert(!PrefixableUnit<named_unit<"?", si::metre / si::second>>);
static_assert(!PrefixableUnit<named_unit<"?", si::metre, kind_of<isq::length>>>); static_assert(!PrefixableUnit<named_unit<"?", (si::metre), kind_of<(isq::length)>>>);
static_assert(!PrefixableUnit<prefixed_unit<"?", mag<10>, si::second>>); static_assert(!PrefixableUnit<prefixed_unit<"?", mag<10>, (si::second)>>);
static_assert(!PrefixableUnit<struct isq::dim_length>); static_assert(!PrefixableUnit<struct isq::dim_length>);
static_assert(!PrefixableUnit<int>); static_assert(!PrefixableUnit<int>);
#if MP_UNITS_HOSTED #if MP_UNITS_HOSTED
@ -184,7 +184,7 @@ static_assert(!PrefixableUnit<std::chrono::seconds>);
static_assert(AssociatedUnit<struct si::metre>); static_assert(AssociatedUnit<struct si::metre>);
static_assert(!AssociatedUnit<struct natural::electronvolt>); static_assert(!AssociatedUnit<struct natural::electronvolt>);
static_assert(AssociatedUnit<decltype(si::kilogram)>); static_assert(AssociatedUnit<decltype(si::kilogram)>);
static_assert(AssociatedUnit<decltype(si::kilo<si::gram>)>); static_assert(AssociatedUnit<decltype(si::kilo<(si::gram)>)>);
static_assert(AssociatedUnit<decltype(si::metre / si::second)>); static_assert(AssociatedUnit<decltype(si::metre / si::second)>);
static_assert(AssociatedUnit<decltype(inverse(si::second))>); static_assert(AssociatedUnit<decltype(inverse(si::second))>);
static_assert(AssociatedUnit<decltype(mag<10> * si::second)>); static_assert(AssociatedUnit<decltype(mag<10> * si::second)>);
@ -194,11 +194,11 @@ static_assert(AssociatedUnit<struct si::standard_gravity>);
static_assert(AssociatedUnit<scaled_unit<mag<10>, struct si::second>>); static_assert(AssociatedUnit<scaled_unit<mag<10>, struct si::second>>);
static_assert(AssociatedUnit<derived_unit<struct si::metre, per<struct si::second>>>); static_assert(AssociatedUnit<derived_unit<struct si::metre, per<struct si::second>>>);
static_assert(AssociatedUnit<struct one>); static_assert(AssociatedUnit<struct one>);
static_assert(!AssociatedUnit<named_unit<"?", kind_of<isq::length>>>); static_assert(!AssociatedUnit<named_unit<"?", kind_of<(isq::length)>>>);
static_assert(!AssociatedUnit<named_unit<"?">>); static_assert(!AssociatedUnit<named_unit<"?">>);
static_assert(!AssociatedUnit<named_unit<"?", si::metre / si::second>>); static_assert(!AssociatedUnit<named_unit<"?", si::metre / si::second>>);
static_assert(!AssociatedUnit<named_unit<"?", si::metre, kind_of<isq::length>>>); static_assert(!AssociatedUnit<named_unit<"?", (si::metre), kind_of<(isq::length)>>>);
static_assert(!AssociatedUnit<prefixed_unit<"?", mag<10>, si::second>>); static_assert(!AssociatedUnit<prefixed_unit<"?", mag<10>, (si::second)>>);
static_assert(!AssociatedUnit<struct isq::dim_length>); static_assert(!AssociatedUnit<struct isq::dim_length>);
static_assert(!AssociatedUnit<int>); static_assert(!AssociatedUnit<int>);
#if MP_UNITS_HOSTED #if MP_UNITS_HOSTED
@ -206,19 +206,19 @@ static_assert(!AssociatedUnit<std::chrono::seconds>);
#endif #endif
// UnitOf // UnitOf
static_assert(UnitOf<struct si::metre, isq::length>); static_assert(UnitOf<struct si::metre, (isq::length)>);
static_assert(UnitOf<struct si::metre, isq::radius>); static_assert(UnitOf<struct si::metre, (isq::radius)>);
static_assert(UnitOf<decltype(si::kilogram), isq::mass>); static_assert(UnitOf<decltype(si::kilogram), (isq::mass)>);
static_assert(UnitOf<struct si::hertz, isq::frequency>); static_assert(UnitOf<struct si::hertz, (isq::frequency)>);
static_assert(UnitOf<struct si::hertz, inverse(isq::time)>); static_assert(UnitOf<struct si::hertz, inverse(isq::time)>);
static_assert(UnitOf<struct one, dimensionless>); static_assert(UnitOf<struct one, dimensionless>);
static_assert(UnitOf<struct percent, dimensionless>); static_assert(UnitOf<struct percent, dimensionless>);
static_assert(UnitOf<struct si::radian, isq::angular_measure>); static_assert(UnitOf<struct si::radian, (isq::angular_measure)>);
static_assert(UnitOf<struct one, isq::angular_measure>); static_assert(UnitOf<struct one, (isq::angular_measure)>);
static_assert(UnitOf<struct percent, isq::angular_measure>); static_assert(UnitOf<struct percent, (isq::angular_measure)>);
static_assert(!UnitOf<struct si::radian, dimensionless>); static_assert(!UnitOf<struct si::radian, dimensionless>);
static_assert(!UnitOf<struct si::metre, isq::time>); static_assert(!UnitOf<struct si::metre, (isq::time)>);
static_assert(!UnitOf<struct natural::electronvolt, isq::energy>); static_assert(!UnitOf<struct natural::electronvolt, (isq::energy)>);
// Reference // Reference
static_assert(Reference<struct si::metre>); static_assert(Reference<struct si::metre>);
@ -228,32 +228,32 @@ static_assert(Reference<decltype(isq::radius[si::metre])>);
static_assert(Reference<decltype(isq::radius[si::metre] / isq::time[si::second])>); static_assert(Reference<decltype(isq::radius[si::metre] / isq::time[si::second])>);
static_assert(!Reference<struct natural::electronvolt>); static_assert(!Reference<struct natural::electronvolt>);
static_assert(!Reference<struct isq::length>); static_assert(!Reference<struct isq::length>);
static_assert(!Reference<decltype(kind_of<isq::length>)>); static_assert(!Reference<decltype(kind_of<(isq::length)>)>);
static_assert(!Reference<struct isq::dim_length>); static_assert(!Reference<struct isq::dim_length>);
static_assert(!Reference<int>); static_assert(!Reference<int>);
// ReferenceOf // ReferenceOf
static_assert(ReferenceOf<struct si::metre, isq::length>); static_assert(ReferenceOf<struct si::metre, (isq::length)>);
static_assert(ReferenceOf<struct si::metre, isq::radius>); static_assert(ReferenceOf<struct si::metre, (isq::radius)>);
static_assert(!ReferenceOf<struct si::second, isq::length>); static_assert(!ReferenceOf<struct si::second, (isq::length)>);
static_assert(ReferenceOf<decltype(isq::length[si::metre]), isq::length>); static_assert(ReferenceOf<decltype(isq::length[si::metre]), (isq::length)>);
static_assert(!ReferenceOf<decltype(isq::length[si::metre]), isq::radius>); static_assert(!ReferenceOf<decltype(isq::length[si::metre]), (isq::radius)>);
static_assert(ReferenceOf<decltype(isq::radius[si::metre]), isq::length>); static_assert(ReferenceOf<decltype(isq::radius[si::metre]), (isq::length)>);
static_assert(ReferenceOf<decltype(isq::radius[si::metre]), isq::radius>); static_assert(ReferenceOf<decltype(isq::radius[si::metre]), (isq::radius)>);
static_assert(!ReferenceOf<struct si::second, isq::dim_length>); static_assert(!ReferenceOf<struct si::second, (isq::dim_length)>);
static_assert(ReferenceOf<struct one, dimensionless>); static_assert(ReferenceOf<struct one, dimensionless>);
static_assert(ReferenceOf<decltype(dimensionless[one]), dimensionless>); static_assert(ReferenceOf<decltype(dimensionless[one]), dimensionless>);
static_assert(ReferenceOf<decltype(isq::rotation[one]), isq::rotation>); static_assert(ReferenceOf<decltype(isq::rotation[one]), (isq::rotation)>);
static_assert(ReferenceOf<decltype(isq::rotation[one]), dimensionless>); static_assert(ReferenceOf<decltype(isq::rotation[one]), dimensionless>);
static_assert(ReferenceOf<struct si::radian, isq::angular_measure>); static_assert(ReferenceOf<struct si::radian, (isq::angular_measure)>);
static_assert(!ReferenceOf<struct si::radian, dimensionless>); static_assert(!ReferenceOf<struct si::radian, dimensionless>);
static_assert(ReferenceOf<decltype(isq::angular_measure[si::radian]), isq::angular_measure>); static_assert(ReferenceOf<decltype(isq::angular_measure[si::radian]), (isq::angular_measure)>);
static_assert(!ReferenceOf<decltype(isq::angular_measure[si::radian]), dimensionless>); static_assert(!ReferenceOf<decltype(isq::angular_measure[si::radian]), dimensionless>);
static_assert(ReferenceOf<struct one, isq::rotation>); static_assert(ReferenceOf<struct one, (isq::rotation)>);
static_assert(ReferenceOf<struct one, isq::angular_measure>); static_assert(ReferenceOf<struct one, (isq::angular_measure)>);
static_assert(!ReferenceOf<decltype(dimensionless[one]), isq::rotation>); static_assert(!ReferenceOf<decltype(dimensionless[one]), (isq::rotation)>);
static_assert(!ReferenceOf<decltype(dimensionless[one]), isq::angular_measure>); static_assert(!ReferenceOf<decltype(dimensionless[one]), (isq::angular_measure)>);
// Representation // Representation
static_assert(Representation<int>); static_assert(Representation<int>);
@ -278,57 +278,57 @@ static_assert(!RepresentationOf<std::string, quantity_character::scalar>);
#endif #endif
// Quantity // Quantity
static_assert(Quantity<quantity<si::metre>>); static_assert(Quantity<quantity<(si::metre)>>);
static_assert(Quantity<quantity<isq::length[si::metre]>>); static_assert(Quantity<quantity<(isq::length[si::metre])>>);
static_assert(Quantity<quantity<si::metre, int>>); static_assert(Quantity<quantity<(si::metre), int>>);
static_assert(Quantity<quantity<isq::length[si::metre], int>>); static_assert(Quantity<quantity<(isq::length[si::metre]), int>>);
#if MP_UNITS_HOSTED #if MP_UNITS_HOSTED
static_assert(!Quantity<std::chrono::seconds>); static_assert(!Quantity<std::chrono::seconds>);
#endif #endif
static_assert(!Quantity<quantity_point<si::metre, my_origin>>); static_assert(!Quantity<quantity_point<(si::metre), my_origin>>);
static_assert(!Quantity<decltype(isq::length[si::metre])>); static_assert(!Quantity<decltype(isq::length[si::metre])>);
// QuantityOf // QuantityOf
static_assert(QuantityOf<quantity<si::metre>, isq::length>); static_assert(QuantityOf<quantity<(si::metre)>, (isq::length)>);
static_assert(QuantityOf<quantity<si::metre>, isq::radius>); static_assert(QuantityOf<quantity<(si::metre)>, (isq::radius)>);
static_assert(!QuantityOf<quantity<si::second>, isq::length>); static_assert(!QuantityOf<quantity<(si::second)>, (isq::length)>);
static_assert(QuantityOf<quantity<isq::length[si::metre]>, isq::length>); static_assert(QuantityOf<quantity<(isq::length[si::metre])>, (isq::length)>);
static_assert(!QuantityOf<quantity<isq::length[si::metre]>, isq::radius>); static_assert(!QuantityOf<quantity<(isq::length[si::metre])>, (isq::radius)>);
static_assert(QuantityOf<quantity<isq::radius[si::metre]>, isq::length>); static_assert(QuantityOf<quantity<(isq::radius[si::metre])>, (isq::length)>);
static_assert(QuantityOf<quantity<isq::radius[si::metre]>, isq::radius>); static_assert(QuantityOf<quantity<(isq::radius[si::metre])>, (isq::radius)>);
static_assert(!QuantityOf<quantity<si::second>, isq::dim_length>); static_assert(!QuantityOf<quantity<(si::second)>, (isq::dim_length)>);
static_assert(QuantityOf<quantity<one>, dimensionless>); static_assert(QuantityOf<quantity<one>, dimensionless>);
static_assert(QuantityOf<quantity<dimensionless[one]>, dimensionless>); static_assert(QuantityOf<quantity<dimensionless[one]>, dimensionless>);
static_assert(QuantityOf<quantity<isq::rotation[one]>, isq::rotation>); static_assert(QuantityOf<quantity<(isq::rotation[one])>, (isq::rotation)>);
static_assert(QuantityOf<quantity<isq::rotation[one]>, dimensionless>); static_assert(QuantityOf<quantity<(isq::rotation[one])>, dimensionless>);
static_assert(QuantityOf<quantity<si::radian>, isq::angular_measure>); static_assert(QuantityOf<quantity<(si::radian)>, (isq::angular_measure)>);
static_assert(!QuantityOf<quantity<si::radian>, dimensionless>); static_assert(!QuantityOf<quantity<(si::radian)>, dimensionless>);
static_assert(QuantityOf<quantity<isq::angular_measure[si::radian]>, isq::angular_measure>); static_assert(QuantityOf<quantity<(isq::angular_measure[si::radian])>, (isq::angular_measure)>);
static_assert(!QuantityOf<quantity<isq::angular_measure[si::radian]>, dimensionless>); static_assert(!QuantityOf<quantity<(isq::angular_measure[si::radian])>, dimensionless>);
static_assert(QuantityOf<quantity<one>, isq::rotation>); static_assert(QuantityOf<quantity<one>, (isq::rotation)>);
static_assert(QuantityOf<quantity<one>, isq::angular_measure>); static_assert(QuantityOf<quantity<one>, (isq::angular_measure)>);
static_assert(!QuantityOf<quantity<dimensionless[one]>, isq::rotation>); static_assert(!QuantityOf<quantity<dimensionless[one]>, (isq::rotation)>);
static_assert(!QuantityOf<quantity<dimensionless[one]>, isq::angular_measure>); static_assert(!QuantityOf<quantity<dimensionless[one]>, (isq::angular_measure)>);
// QuantityLike // QuantityLike
#if MP_UNITS_HOSTED #if MP_UNITS_HOSTED
static_assert(QuantityLike<std::chrono::seconds>); static_assert(QuantityLike<std::chrono::seconds>);
static_assert(QuantityLike<std::chrono::hours>); static_assert(QuantityLike<std::chrono::hours>);
#endif #endif
static_assert(!QuantityLike<quantity<isq::time[si::second]>>); static_assert(!QuantityLike<quantity<(isq::time[si::second])>>);
static_assert(!QuantityLike<quantity_point<isq::length[si::metre], my_origin>>); static_assert(!QuantityLike<quantity_point<(isq::length[si::metre]), my_origin>>);
static_assert(!QuantityLike<int>); static_assert(!QuantityLike<int>);
// QuantityPoint // QuantityPoint
static_assert(QuantityPoint<quantity_point<si::metre, my_origin>>); static_assert(QuantityPoint<quantity_point<(si::metre), my_origin>>);
static_assert(QuantityPoint<quantity_point<si::metre, my_relative_origin>>); static_assert(QuantityPoint<quantity_point<(si::metre), my_relative_origin>>);
static_assert(QuantityPoint<quantity_point<isq::length[si::metre], my_origin>>); static_assert(QuantityPoint<quantity_point<(isq::length[si::metre]), my_origin>>);
static_assert(QuantityPoint<quantity_point<isq::length[si::metre], my_relative_origin, int>>); static_assert(QuantityPoint<quantity_point<(isq::length[si::metre]), my_relative_origin, int>>);
static_assert(QuantityPoint<quantity_point<isq::radius[si::metre], my_origin>>); static_assert(QuantityPoint<quantity_point<(isq::radius[si::metre]), my_origin>>);
static_assert(QuantityPoint<quantity_point<isq::radius[si::metre], my_relative_origin>>); static_assert(QuantityPoint<quantity_point<(isq::radius[si::metre]), my_relative_origin>>);
static_assert(!QuantityPoint<decltype(isq::length[si::metre])>); static_assert(!QuantityPoint<decltype(isq::length[si::metre])>);
static_assert(!QuantityPoint<absolute_point_origin<isq::length>>); static_assert(!QuantityPoint<absolute_point_origin<(isq::length)>>);
static_assert(!QuantityPoint<struct my_origin>); static_assert(!QuantityPoint<struct my_origin>);
static_assert(!QuantityPoint<struct my_relative_origin>); static_assert(!QuantityPoint<struct my_relative_origin>);
#if MP_UNITS_HOSTED #if MP_UNITS_HOSTED
@ -338,35 +338,35 @@ static_assert(!QuantityPoint<std::chrono::time_point<std::chrono::system_clock>>
static_assert(!QuantityPoint<int>); static_assert(!QuantityPoint<int>);
// QuantityPointOf // QuantityPointOf
static_assert(QuantityPointOf<quantity_point<si::metre, my_origin>, isq::length>); static_assert(QuantityPointOf<quantity_point<(si::metre), my_origin>, (isq::length)>);
static_assert(QuantityPointOf<quantity_point<si::metre, my_origin>, isq::radius>); static_assert(QuantityPointOf<quantity_point<(si::metre), my_origin>, (isq::radius)>);
static_assert(QuantityPointOf<quantity_point<isq::length[si::metre], my_origin>, isq::length>); static_assert(QuantityPointOf<quantity_point<(isq::length[si::metre]), my_origin>, (isq::length)>);
static_assert(!QuantityPointOf<quantity_point<isq::length[si::metre], my_origin>, isq::radius>); static_assert(!QuantityPointOf<quantity_point<(isq::length[si::metre]), my_origin>, (isq::radius)>);
static_assert(QuantityPointOf<quantity_point<isq::radius[si::metre], my_origin>, isq::length>); static_assert(QuantityPointOf<quantity_point<(isq::radius[si::metre]), my_origin>, (isq::length)>);
static_assert(QuantityPointOf<quantity_point<isq::radius[si::metre], my_origin>, isq::radius>); static_assert(QuantityPointOf<quantity_point<(isq::radius[si::metre]), my_origin>, (isq::radius)>);
static_assert(QuantityPointOf<quantity_point<isq::radius[si::metre], my_relative_origin>, isq::length>); static_assert(QuantityPointOf<quantity_point<(isq::radius[si::metre]), my_relative_origin>, (isq::length)>);
static_assert(QuantityPointOf<quantity_point<isq::radius[si::metre], my_relative_origin>, isq::radius>); static_assert(QuantityPointOf<quantity_point<(isq::radius[si::metre]), my_relative_origin>, (isq::radius)>);
static_assert(QuantityPointOf<quantity_point<si::metre, my_origin>, my_origin>); static_assert(QuantityPointOf<quantity_point<(si::metre), my_origin>, my_origin>);
static_assert(QuantityPointOf<quantity_point<si::metre, my_origin>, my_relative_origin>); static_assert(QuantityPointOf<quantity_point<(si::metre), my_origin>, my_relative_origin>);
static_assert(QuantityPointOf<quantity_point<si::metre, my_relative_origin>, my_relative_origin>); static_assert(QuantityPointOf<quantity_point<(si::metre), my_relative_origin>, my_relative_origin>);
static_assert(QuantityPointOf<quantity_point<si::metre, my_relative_origin>, my_origin>); static_assert(QuantityPointOf<quantity_point<(si::metre), my_relative_origin>, my_origin>);
static_assert(QuantityPointOf<quantity_point<isq::length[si::metre], my_origin>, my_origin>); static_assert(QuantityPointOf<quantity_point<(isq::length[si::metre]), my_origin>, my_origin>);
static_assert(QuantityPointOf<quantity_point<isq::length[si::metre], my_origin>, my_relative_origin>); static_assert(QuantityPointOf<quantity_point<(isq::length[si::metre]), my_origin>, my_relative_origin>);
static_assert(QuantityPointOf<quantity_point<isq::length[si::metre], my_relative_origin>, my_relative_origin>); static_assert(QuantityPointOf<quantity_point<(isq::length[si::metre]), my_relative_origin>, my_relative_origin>);
static_assert(QuantityPointOf<quantity_point<isq::length[si::metre], my_relative_origin>, my_origin>); static_assert(QuantityPointOf<quantity_point<(isq::length[si::metre]), my_relative_origin>, my_origin>);
static_assert(QuantityPointOf<quantity_point<isq::radius[si::metre], my_origin>, my_origin>); static_assert(QuantityPointOf<quantity_point<(isq::radius[si::metre]), my_origin>, my_origin>);
static_assert(QuantityPointOf<quantity_point<isq::radius[si::metre], my_origin>, my_relative_origin>); static_assert(QuantityPointOf<quantity_point<(isq::radius[si::metre]), my_origin>, my_relative_origin>);
static_assert(QuantityPointOf<quantity_point<isq::radius[si::metre], my_relative_origin>, my_relative_origin>); static_assert(QuantityPointOf<quantity_point<(isq::radius[si::metre]), my_relative_origin>, my_relative_origin>);
static_assert(QuantityPointOf<quantity_point<isq::radius[si::metre], my_relative_origin>, my_origin>); static_assert(QuantityPointOf<quantity_point<(isq::radius[si::metre]), my_relative_origin>, my_origin>);
// PointOrigin // PointOrigin
static_assert(PointOrigin<struct my_origin>); static_assert(PointOrigin<struct my_origin>);
static_assert(PointOrigin<struct my_relative_origin>); static_assert(PointOrigin<struct my_relative_origin>);
static_assert(!PointOrigin<absolute_point_origin<isq::length>>); static_assert(!PointOrigin<absolute_point_origin<(isq::length)>>);
static_assert(!PointOrigin<relative_point_origin<my_origin + 42 * si::metre>>); static_assert(!PointOrigin<relative_point_origin<my_origin + 42 * si::metre>>);
static_assert(!PointOrigin<quantity_point<si::metre, my_origin>>); static_assert(!PointOrigin<quantity_point<(si::metre), my_origin>>);
static_assert(!PointOrigin<quantity_point<isq::length[si::metre], my_origin>>); static_assert(!PointOrigin<quantity_point<(isq::length[si::metre]), my_origin>>);
static_assert(!PointOrigin<quantity_point<isq::radius[si::metre], my_origin>>); static_assert(!PointOrigin<quantity_point<(isq::radius[si::metre]), my_origin>>);
static_assert(!PointOrigin<decltype(isq::length[si::metre])>); static_assert(!PointOrigin<decltype(isq::length[si::metre])>);
#if MP_UNITS_HOSTED #if MP_UNITS_HOSTED
static_assert(!PointOrigin<std::chrono::seconds>); static_assert(!PointOrigin<std::chrono::seconds>);
@ -375,38 +375,38 @@ static_assert(!PointOrigin<std::chrono::time_point<std::chrono::system_clock>>);
static_assert(!PointOrigin<int>); static_assert(!PointOrigin<int>);
// PointOriginFor // PointOriginFor
static_assert(PointOriginFor<struct my_origin, isq::length>); static_assert(PointOriginFor<struct my_origin, (isq::length)>);
static_assert(PointOriginFor<struct my_origin, isq::radius>); static_assert(PointOriginFor<struct my_origin, (isq::radius)>);
static_assert(!PointOriginFor<struct my_origin, isq::time>); static_assert(!PointOriginFor<struct my_origin, (isq::time)>);
static_assert(PointOriginFor<struct my_relative_origin, isq::length>); static_assert(PointOriginFor<struct my_relative_origin, (isq::length)>);
static_assert(PointOriginFor<struct my_relative_origin, isq::radius>); static_assert(PointOriginFor<struct my_relative_origin, (isq::radius)>);
static_assert(!PointOriginFor<struct my_relative_origin, isq::time>); static_assert(!PointOriginFor<struct my_relative_origin, (isq::time)>);
static_assert(!PointOriginFor<quantity_point<si::metre, my_origin>, isq::length>); static_assert(!PointOriginFor<quantity_point<(si::metre), my_origin>, (isq::length)>);
static_assert(!PointOriginFor<quantity_point<si::metre, my_origin>, isq::radius>); static_assert(!PointOriginFor<quantity_point<(si::metre), my_origin>, (isq::radius)>);
static_assert(!PointOriginFor<quantity_point<si::metre, my_origin>, isq::time>); static_assert(!PointOriginFor<quantity_point<(si::metre), my_origin>, (isq::time)>);
static_assert(!PointOriginFor<quantity_point<isq::length[si::metre], my_origin>, isq::length>); static_assert(!PointOriginFor<quantity_point<(isq::length[si::metre]), my_origin>, (isq::length)>);
static_assert(!PointOriginFor<quantity_point<isq::length[si::metre], my_origin>, isq::radius>); static_assert(!PointOriginFor<quantity_point<(isq::length[si::metre]), my_origin>, (isq::radius)>);
static_assert(!PointOriginFor<quantity_point<isq::length[si::metre], my_origin>, isq::time>); static_assert(!PointOriginFor<quantity_point<(isq::length[si::metre]), my_origin>, (isq::time)>);
static_assert(!PointOriginFor<quantity_point<isq::radius[si::metre], my_origin>, isq::length>); static_assert(!PointOriginFor<quantity_point<(isq::radius[si::metre]), my_origin>, (isq::length)>);
static_assert(!PointOriginFor<quantity_point<isq::radius[si::metre], my_origin>, isq::radius>); static_assert(!PointOriginFor<quantity_point<(isq::radius[si::metre]), my_origin>, (isq::radius)>);
static_assert(!PointOriginFor<quantity_point<isq::radius[si::metre], my_origin>, isq::time>); static_assert(!PointOriginFor<quantity_point<(isq::radius[si::metre]), my_origin>, (isq::time)>);
static_assert(!PointOriginFor<quantity_point<isq::radius[si::metre], my_relative_origin>, isq::length>); static_assert(!PointOriginFor<quantity_point<(isq::radius[si::metre]), my_relative_origin>, (isq::length)>);
static_assert(!PointOriginFor<quantity_point<isq::radius[si::metre], my_relative_origin>, isq::radius>); static_assert(!PointOriginFor<quantity_point<(isq::radius[si::metre]), my_relative_origin>, (isq::radius)>);
static_assert(!PointOriginFor<quantity_point<isq::radius[si::metre], my_relative_origin>, isq::time>); static_assert(!PointOriginFor<quantity_point<(isq::radius[si::metre]), my_relative_origin>, (isq::time)>);
static_assert(!PointOriginFor<decltype(isq::length[si::metre]), isq::length>); static_assert(!PointOriginFor<decltype((isq::length[si::metre])), (isq::length)>);
#if MP_UNITS_HOSTED #if MP_UNITS_HOSTED
static_assert(!PointOriginFor<std::chrono::seconds, isq::length>); static_assert(!PointOriginFor<std::chrono::seconds, (isq::length)>);
static_assert(!PointOriginFor<std::chrono::time_point<std::chrono::system_clock>, isq::length>); static_assert(!PointOriginFor<std::chrono::time_point<std::chrono::system_clock>, (isq::length)>);
#endif #endif
static_assert(!PointOriginFor<int, isq::length>); static_assert(!PointOriginFor<int, (isq::length)>);
// QuantityPointLike // QuantityPointLike
#if MP_UNITS_HOSTED #if MP_UNITS_HOSTED
static_assert(QuantityPointLike<std::chrono::time_point<std::chrono::system_clock>>); static_assert(QuantityPointLike<std::chrono::time_point<std::chrono::system_clock>>);
static_assert(!QuantityPointLike<std::chrono::seconds>); static_assert(!QuantityPointLike<std::chrono::seconds>);
#endif #endif
static_assert(!QuantityPointLike<quantity<isq::time[si::second]>>); static_assert(!QuantityPointLike<quantity<(isq::time[si::second])>>);
static_assert(!QuantityPointLike<quantity_point<si::metre, my_origin>>); static_assert(!QuantityPointLike<quantity_point<(si::metre), my_origin>>);
static_assert(!QuantityPointLike<int>); static_assert(!QuantityPointLike<int>);
} // namespace } // namespace

67
test/static/custom_rep_test_min_impl.cpp
View File

@ -78,18 +78,18 @@ static_assert(Representation<min_impl<int>>);
static_assert(Representation<min_impl<double>>); static_assert(Representation<min_impl<double>>);
// construction from a value is not allowed // construction from a value is not allowed
static_assert(!std::constructible_from<quantity<si::metre, min_impl<int>>, min_impl<int>>); static_assert(!std::constructible_from<quantity<(si::metre), min_impl<int>>, min_impl<int>>);
static_assert(!std::convertible_to<min_impl<int>, quantity<si::metre, min_impl<int>>>); static_assert(!std::convertible_to<min_impl<int>, quantity<(si::metre), min_impl<int>>>);
static_assert(!std::constructible_from<quantity<si::metre, min_impl<double>>, min_impl<double>>); static_assert(!std::constructible_from<quantity<(si::metre), min_impl<double>>, min_impl<double>>);
static_assert(!std::convertible_to<min_impl<double>, quantity<si::metre, min_impl<double>>>); static_assert(!std::convertible_to<min_impl<double>, quantity<(si::metre), min_impl<double>>>);
// multiply syntax should work // multiply syntax should work
template<typename T, auto U> template<typename T, auto U>
concept creates_quantity = Unit<decltype(U)> && requires { T{} * U; }; concept creates_quantity = Unit<decltype(U)> && requires { T{} * U; };
static_assert(creates_quantity<min_impl<int>, si::metre>); static_assert(creates_quantity<min_impl<int>, (si::metre)>);
static_assert(creates_quantity<min_impl<double>, si::metre>); static_assert(creates_quantity<min_impl<double>, (si::metre)>);
// multiply syntax // multiply syntax
static_assert(creates_quantity<min_impl<int>, one>); static_assert(creates_quantity<min_impl<int>, one>);
@ -99,46 +99,47 @@ static_assert(creates_quantity<min_impl<double>, percent>);
// construction from a quantity // construction from a quantity
// min_impl<T> -> min_impl<T> // min_impl<T> -> min_impl<T>
static_assert(std::constructible_from<quantity<si::metre, min_impl<int>>, quantity<si::metre, min_impl<int>>>); static_assert(std::constructible_from<quantity<(si::metre), min_impl<int>>, quantity<(si::metre), min_impl<int>>>);
static_assert(std::convertible_to<quantity<si::metre, min_impl<int>>, quantity<si::metre, min_impl<int>>>); static_assert(std::convertible_to<quantity<(si::metre), min_impl<int>>, quantity<(si::metre), min_impl<int>>>);
static_assert(std::constructible_from<quantity<si::metre, min_impl<double>>, quantity<si::metre, min_impl<double>>>); static_assert(
static_assert(std::convertible_to<quantity<si::metre, min_impl<double>>, quantity<si::metre, min_impl<double>>>); std::constructible_from<quantity<(si::metre), min_impl<double>>, quantity<(si::metre), min_impl<double>>>);
static_assert(std::convertible_to<quantity<(si::metre), min_impl<double>>, quantity<(si::metre), min_impl<double>>>);
static_assert(std::constructible_from<quantity<si::metre, min_impl<double>>, quantity<si::metre, min_impl<int>>>); static_assert(std::constructible_from<quantity<(si::metre), min_impl<double>>, quantity<(si::metre), min_impl<int>>>);
static_assert(std::convertible_to<quantity<si::metre, min_impl<int>>, quantity<si::metre, min_impl<double>>>); static_assert(std::convertible_to<quantity<(si::metre), min_impl<int>>, quantity<(si::metre), min_impl<double>>>);
static_assert(!std::constructible_from<quantity<si::metre, min_impl<int>>, static_assert(!std::constructible_from<quantity<(si::metre), min_impl<int>>,
quantity<si::metre, min_impl<double>>>); // narrowing conversion quantity<(si::metre), min_impl<double>>>); // narrowing conversion
static_assert(!std::convertible_to<quantity<si::metre, min_impl<double>>, quantity<si::metre, min_impl<int>>>); static_assert(!std::convertible_to<quantity<(si::metre), min_impl<double>>, quantity<(si::metre), min_impl<int>>>);
// T -> min_impl<T> // T -> min_impl<T>
static_assert(std::constructible_from<quantity<si::metre, min_impl<int>>, quantity<si::metre, int>>); static_assert(std::constructible_from<quantity<(si::metre), min_impl<int>>, quantity<(si::metre), int>>);
static_assert(std::convertible_to<quantity<si::metre, int>, quantity<si::metre, min_impl<int>>>); static_assert(std::convertible_to<quantity<(si::metre), int>, quantity<(si::metre), min_impl<int>>>);
static_assert(std::constructible_from<quantity<si::metre, min_impl<double>>, quantity<si::metre, double>>); static_assert(std::constructible_from<quantity<(si::metre), min_impl<double>>, quantity<(si::metre), double>>);
static_assert(std::convertible_to<quantity<si::metre, double>, quantity<si::metre, min_impl<double>>>); static_assert(std::convertible_to<quantity<(si::metre), double>, quantity<(si::metre), min_impl<double>>>);
static_assert(std::constructible_from<quantity<si::metre, min_impl<double>>, quantity<si::metre, int>>); static_assert(std::constructible_from<quantity<(si::metre), min_impl<double>>, quantity<(si::metre), int>>);
static_assert(std::convertible_to<quantity<si::metre, int>, quantity<si::metre, min_impl<double>>>); static_assert(std::convertible_to<quantity<(si::metre), int>, quantity<(si::metre), min_impl<double>>>);
static_assert( static_assert(!std::constructible_from<quantity<(si::metre), min_impl<int>>,
!std::constructible_from<quantity<si::metre, min_impl<int>>, quantity<si::metre, double>>); // narrowing conversion quantity<(si::metre), double>>); // narrowing conversion
static_assert(!std::convertible_to<quantity<si::metre, double>, quantity<si::metre, min_impl<int>>>); static_assert(!std::convertible_to<quantity<(si::metre), double>, quantity<(si::metre), min_impl<int>>>);
// min_impl<T> -> T // min_impl<T> -> T
static_assert(std::constructible_from<quantity<si::metre, int>, quantity<si::metre, min_impl<int>>>); static_assert(std::constructible_from<quantity<(si::metre), int>, quantity<(si::metre), min_impl<int>>>);
static_assert(std::convertible_to<quantity<si::metre, min_impl<int>>, quantity<si::metre, int>>); static_assert(std::convertible_to<quantity<(si::metre), min_impl<int>>, quantity<(si::metre), int>>);
static_assert(std::constructible_from<quantity<si::metre, double>, quantity<si::metre, min_impl<double>>>); static_assert(std::constructible_from<quantity<(si::metre), double>, quantity<(si::metre), min_impl<double>>>);
static_assert(std::convertible_to<quantity<si::metre, min_impl<double>>, quantity<si::metre, double>>); static_assert(std::convertible_to<quantity<(si::metre), min_impl<double>>, quantity<(si::metre), double>>);
static_assert(std::constructible_from<quantity<si::metre, double>, quantity<si::metre, min_impl<int>>>); static_assert(std::constructible_from<quantity<(si::metre), double>, quantity<(si::metre), min_impl<int>>>);
static_assert(std::convertible_to<quantity<si::metre, min_impl<int>>, quantity<si::metre, double>>); static_assert(std::convertible_to<quantity<(si::metre), min_impl<int>>, quantity<(si::metre), double>>);
static_assert( static_assert(!std::constructible_from<quantity<(si::metre), int>,
!std::constructible_from<quantity<si::metre, int>, quantity<si::metre, min_impl<double>>>); // narrowing conversion quantity<(si::metre), min_impl<double>>>); // narrowing conversion
static_assert(!std::convertible_to<quantity<si::metre, min_impl<double>>, quantity<si::metre, int>>); static_assert(!std::convertible_to<quantity<(si::metre), min_impl<double>>, quantity<(si::metre), int>>);
// arithmetic operators // arithmetic operators

2
test/static/dimension_test.cpp
View File

@ -33,7 +33,7 @@ namespace {
using namespace mp_units; using namespace mp_units;
using dimension_one_ = struct dimension_one; using dimension_one_ = struct mp_units::dimension_one;
// clang-format off // clang-format off
inline constexpr struct length_ final : base_dimension<"L"> {} length; inline constexpr struct length_ final : base_dimension<"L"> {} length;

787
test/static/quantity_point_test.cpp
View File

File diff suppressed because it is too large Load Diff

4
test/static/quantity_spec_test.cpp
View File

@ -33,8 +33,8 @@ namespace {
using namespace mp_units; using namespace mp_units;
using dimensionless_ = struct dimensionless; using dimensionless_ = struct mp_units::dimensionless;
using dim_one_ = struct dimension_one; using dim_one_ = struct mp_units::dimension_one;
// clang-format off // clang-format off
inline constexpr struct dim_length_ final : base_dimension<"L"> {} dim_length; inline constexpr struct dim_length_ final : base_dimension<"L"> {} dim_length;

204
test/static/quantity_test.cpp
View File

@ -84,14 +84,14 @@ static_assert(std::is_nothrow_destructible_v<quantity<isq::length[m]>>);
static_assert(std::is_trivially_copyable_v<quantity<isq::length[m]>>); static_assert(std::is_trivially_copyable_v<quantity<isq::length[m]>>);
static_assert(std::is_standard_layout_v<quantity<isq::length[m]>>); static_assert(std::is_standard_layout_v<quantity<isq::length[m]>>);
static_assert(std::default_initializable<quantity<isq::length[m]>>); static_assert(std::default_initializable<quantity<(isq::length[m])>>);
static_assert(std::move_constructible<quantity<isq::length[m]>>); static_assert(std::move_constructible<quantity<(isq::length[m])>>);
static_assert(std::copy_constructible<quantity<isq::length[m]>>); static_assert(std::copy_constructible<quantity<(isq::length[m])>>);
static_assert(std::equality_comparable<quantity<isq::length[m]>>); static_assert(std::equality_comparable<quantity<(isq::length[m])>>);
static_assert(std::totally_ordered<quantity<isq::length[m]>>); static_assert(std::totally_ordered<quantity<(isq::length[m])>>);
static_assert(std::regular<quantity<isq::length[m]>>); static_assert(std::regular<quantity<(isq::length[m])>>);
static_assert(std::three_way_comparable<quantity<isq::length[m]>>); static_assert(std::three_way_comparable<quantity<(isq::length[m])>>);
////////////////// //////////////////
@ -112,8 +112,8 @@ static_assert(quantity<isq::length[m]>::unit == si::metre);
// member types // member types
///////////////// /////////////////
static_assert(is_same_v<quantity<isq::length[m]>::rep, double>); static_assert(is_same_v<quantity<(isq::length[m])>::rep, double>);
static_assert(is_same_v<quantity<isq::length[m], int>::rep, int>); static_assert(is_same_v<quantity<(isq::length[m]), int>::rep, int>);
[[maybe_unused]] volatile std::int16_t vint = 123; [[maybe_unused]] volatile std::int16_t vint = 123;
static_assert(is_same_v<decltype(quantity(vint * m))::rep, std::int16_t>); static_assert(is_same_v<decltype(quantity(vint * m))::rep, std::int16_t>);
@ -139,11 +139,11 @@ static_assert(quantity<isq::length[m], double>::max().numerical_value_in(m) == s
///////////////////////////////////////////////// /////////////////////////////////////////////////
// construction from a value is private // construction from a value is private
static_assert(!std::constructible_from<quantity<isq::length[m]>, double>); static_assert(!std::constructible_from<quantity<(isq::length[m])>, double>);
static_assert(!std::convertible_to<double, quantity<isq::length[m]>>); static_assert(!std::convertible_to<double, quantity<(isq::length[m])>>);
static_assert(!std::constructible_from<quantity<isq::length[m], int>, int>); static_assert(!std::constructible_from<quantity<(isq::length[m]), int>, int>);
static_assert(!std::convertible_to<int, quantity<isq::length[m], int>>); static_assert(!std::convertible_to<int, quantity<(isq::length[m]), int>>);
static_assert(std::constructible_from<quantity<one>, double>); static_assert(std::constructible_from<quantity<one>, double>);
static_assert(std::convertible_to<double, quantity<one>>); static_assert(std::convertible_to<double, quantity<one>>);
@ -163,45 +163,46 @@ static_assert(std::convertible_to<int, quantity<dimensionless[one]>>);
/////////////////////////////////////// ///////////////////////////////////////
// conversion only between convertible quantities // conversion only between convertible quantities
static_assert(std::constructible_from<quantity<isq::length[m]>, quantity<isq::length[m]>>); static_assert(std::constructible_from<quantity<(isq::length[m])>, quantity<(isq::length[m])>>);
static_assert(std::convertible_to<quantity<isq::length[m]>, quantity<isq::length[m]>>); static_assert(std::convertible_to<quantity<(isq::length[m])>, quantity<(isq::length[m])>>);
static_assert(std::constructible_from<quantity<isq::length[m]>, quantity<isq::distance[m]>>); static_assert(std::constructible_from<quantity<(isq::length[m])>, quantity<(isq::distance[m])>>);
static_assert(std::convertible_to<quantity<isq::distance[m]>, quantity<isq::length[m]>>); static_assert(std::convertible_to<quantity<(isq::distance[m])>, quantity<(isq::length[m])>>);
static_assert(std::constructible_from<quantity<isq::length[m]>, quantity<isq::length[km]>>); static_assert(std::constructible_from<quantity<(isq::length[m])>, quantity<(isq::length[km])>>);
static_assert(std::convertible_to<quantity<isq::length[km]>, quantity<isq::length[m]>>); static_assert(std::convertible_to<quantity<(isq::length[km])>, quantity<(isq::length[m])>>);
// conversion between different quantities not allowed // conversion between different quantities not allowed
static_assert(!std::constructible_from<quantity<isq::length[m]>, quantity<isq::time[s]>>); static_assert(!std::constructible_from<quantity<(isq::length[m])>, quantity<(isq::time[s])>>);
static_assert(!std::convertible_to<quantity<isq::time[s]>, quantity<isq::length[m]>>); static_assert(!std::convertible_to<quantity<(isq::time[s])>, quantity<(isq::length[m])>>);
static_assert(!std::constructible_from<quantity<isq::length[m]>, quantity<isq::speed[m / s]>>); static_assert(!std::constructible_from<quantity<(isq::length[m])>, quantity<(isq::speed[m / s])>>);
static_assert(!std::convertible_to<quantity<isq::speed[m / s]>, quantity<isq::length[m]>>); static_assert(!std::convertible_to<quantity<(isq::speed[m / s])>, quantity<(isq::length[m])>>);
// implicit conversion from another quantity only if non-truncating // implicit conversion from another quantity only if non-truncating
static_assert(std::constructible_from<quantity<isq::length[m]>, quantity<isq::length[m], int>>); // int -> double OK
static_assert(std::convertible_to<quantity<isq::length[m], int>, quantity<isq::length[m]>>); // int -> double OK
static_assert(!std::constructible_from<quantity<isq::length[m], int>,
quantity<isq::length[m]>>); // truncating double -> int not allowed
static_assert(!std::convertible_to<quantity<isq::length[m]>,
quantity<isq::length[m], int>>); // truncating double -> int not allowed
static_assert(std::constructible_from<quantity<isq::length[m], int>,
quantity<isq::length[km], int>>); // kilometre<int> -> metre<int> OK
static_assert(std::convertible_to<quantity<isq::length[km], int>,
quantity<isq::length[m], int>>); // kilometre<int> -> metre<int> OK
static_assert(!std::constructible_from<quantity<isq::length[km], int>,
quantity<isq::length[m], int>>); // truncating metre<int> ->
// kilometre<int> not allowed
static_assert( static_assert(
!std::convertible_to<quantity<isq::length[m], int>, std::constructible_from<quantity<(isq::length[m])>, quantity<(isq::length[m]), int>>); // int -> double OK
quantity<isq::length[km], int>>); // truncating metre<int> -> kilometre<int> not allowed static_assert(std::convertible_to<quantity<(isq::length[m]), int>, quantity<(isq::length[m])>>); // int -> double OK
static_assert(!std::constructible_from<quantity<(isq::length[m]), int>,
quantity<(isq::length[m])>>); // truncating double -> int not allowed
static_assert(!std::convertible_to<quantity<(isq::length[m])>,
quantity<(isq::length[m]), int>>); // truncating double -> int not allowed
static_assert(std::constructible_from<quantity<(isq::length[m]), int>,
quantity<(isq::length[km]), int>>); // kilometre<int> -> metre<int> OK
static_assert(std::convertible_to<quantity<(isq::length[km]), int>,
quantity<(isq::length[m]), int>>); // kilometre<int> -> metre<int> OK
static_assert(!std::constructible_from<quantity<(isq::length[km]), int>,
quantity<(isq::length[m]), int>>); // truncating metre<int> ->
// kilometre<int> not allowed
static_assert(
!std::convertible_to<quantity<(isq::length[m]), int>,
quantity<(isq::length[km]), int>>); // truncating metre<int> -> kilometre<int> not allowed
// converting to double always OK // converting to double always OK
static_assert(std::constructible_from<quantity<isq::length[m]>, quantity<isq::length[km], int>>); static_assert(std::constructible_from<quantity<(isq::length[m])>, quantity<(isq::length[km]), int>>);
static_assert(std::convertible_to<quantity<isq::length[km], int>, quantity<isq::length[m]>>); static_assert(std::convertible_to<quantity<(isq::length[km]), int>, quantity<(isq::length[m])>>);
static_assert(std::constructible_from<quantity<isq::length[km]>, quantity<isq::length[m], int>>); static_assert(std::constructible_from<quantity<(isq::length[km])>, quantity<(isq::length[m]), int>>);
static_assert(std::convertible_to<quantity<isq::length[m], int>, quantity<isq::length[km]>>); static_assert(std::convertible_to<quantity<(isq::length[m]), int>, quantity<(isq::length[km])>>);
/////////////////////// ///////////////////////
// obtaining a number // obtaining a number
@ -219,16 +220,16 @@ static_assert(quantity<isq::length[km]>(1500 * m).numerical_value_in(km) == 1.5)
static_assert(!std::convertible_to<quantity<one>, double>); static_assert(!std::convertible_to<quantity<one>, double>);
static_assert(std::constructible_from<double, quantity<one>>); static_assert(std::constructible_from<double, quantity<one>>);
static_assert(!std::convertible_to<quantity<isq::angular_measure[one]>, double>); static_assert(!std::convertible_to<quantity<(isq::angular_measure[one])>, double>);
static_assert(std::constructible_from<double, quantity<isq::angular_measure[one]>>); static_assert(std::constructible_from<double, quantity<(isq::angular_measure[one])>>);
static_assert(!std::convertible_to<quantity<one>, int>); static_assert(!std::convertible_to<quantity<one>, int>);
static_assert(std::constructible_from<int, quantity<one>>); static_assert(std::constructible_from<int, quantity<one>>);
static_assert(!std::convertible_to<quantity<isq::angular_measure[one]>, int>); static_assert(!std::convertible_to<quantity<(isq::angular_measure[one])>, int>);
static_assert(std::constructible_from<int, quantity<isq::angular_measure[one]>>); static_assert(std::constructible_from<int, quantity<(isq::angular_measure[one])>>);
static_assert(!std::convertible_to<quantity<one, int>, double>); static_assert(!std::convertible_to<quantity<one, int>, double>);
static_assert(std::constructible_from<double, quantity<one, int>>); static_assert(std::constructible_from<double, quantity<one, int>>);
static_assert(!std::convertible_to<quantity<isq::angular_measure[one], int>, double>); static_assert(!std::convertible_to<quantity<(isq::angular_measure[one]), int>, double>);
static_assert(std::constructible_from<double, quantity<isq::angular_measure[one], int>>); static_assert(std::constructible_from<double, quantity<(isq::angular_measure[one]), int>>);
/////////////////////////////////// ///////////////////////////////////
@ -318,9 +319,9 @@ struct derived_quantity : quantity<Q::reference, Rep> {
R::operator=(t); R::operator=(t);
return *this; return *this;
} }
constexpr derived_quantity& operator=(R&& t) constexpr derived_quantity& operator=(R&& other)
{ {
R::operator=(std::move(t)); R::operator=(std::move(other));
return *this; return *this;
} }
// NOLINTBEGIN(google-explicit-constructor, hicpp-explicit-conversions) // NOLINTBEGIN(google-explicit-constructor, hicpp-explicit-conversions)
@ -331,9 +332,9 @@ struct derived_quantity : quantity<Q::reference, Rep> {
// NOLINTEND(google-explicit-constructor, hicpp-explicit-conversions) // NOLINTEND(google-explicit-constructor, hicpp-explicit-conversions)
}; };
static_assert(Quantity<derived_quantity<double, quantity<isq::length[m]>, "NTTP type description">>); static_assert(Quantity<derived_quantity<double, quantity<(isq::length[m])>, "NTTP type description">>);
constexpr QuantityOf<isq::length> auto get_length_derived_quantity() noexcept constexpr QuantityOf<(isq::length)> auto get_length_derived_quantity() noexcept
{ {
derived_quantity<double, quantity<isq::length[m]>, "NTTP type description"> dist{}; derived_quantity<double, quantity<isq::length[m]>, "NTTP type description"> dist{};
dist += 1 * m; dist += 1 * m;
@ -362,7 +363,8 @@ static_assert(quantity{123}.quantity_spec == kind_of<dimensionless>);
#if MP_UNITS_HOSTED #if MP_UNITS_HOSTED
using namespace std::chrono_literals; using namespace std::chrono_literals;
static_assert(std::is_same_v<decltype(quantity{123s})::rep, std::chrono::seconds::rep>); static_assert(std::is_same_v<decltype(quantity{123s})::rep, std::chrono::seconds::rep>);
static_assert(std::is_same_v<decltype(quantity{123.s})::rep, long double>); // return type for "s" is not specified. is double for msvc
// static_assert(std::is_same_v<decltype(quantity{123.s})::rep, long double>);
static_assert(quantity{24h}.unit == si::hour); static_assert(quantity{24h}.unit == si::hour);
static_assert(quantity{24h}.quantity_spec == kind_of<isq::time>); static_assert(quantity{24h}.quantity_spec == kind_of<isq::time>);
#endif #endif
@ -461,10 +463,10 @@ static_assert((std::uint8_t{255}* m %= 257 * m).numerical_value_in(m) != [] {
#if !(defined MP_UNITS_COMP_CLANG && MP_UNITS_COMP_CLANG < 18 && defined MP_UNITS_MODULES) #if !(defined MP_UNITS_COMP_CLANG && MP_UNITS_COMP_CLANG < 18 && defined MP_UNITS_MODULES)
// next two lines trigger conversions warnings // next two lines trigger conversions warnings
// (warning disabled in CMake for this file) // (warning disabled in CMake for this file)
static_assert((22 * m *= 33.33).numerical_value_in(m) == 733); static_assert(((22 * m) *= 33.33).numerical_value_in(m) == 733);
static_assert((22 * m /= 3.33).numerical_value_in(m) == 6); static_assert(((22 * m) /= 3.33).numerical_value_in(m) == 6);
static_assert((22 * m *= 33.33 * one).numerical_value_in(m) == 733); static_assert(((22 * m) *= 33.33 * one).numerical_value_in(m) == 733);
static_assert((22 * m /= 3.33 * one).numerical_value_in(m) == 6); static_assert(((22 * m) /= 3.33 * one).numerical_value_in(m) == 6);
#endif #endif
template<template<auto, typename> typename Q> template<template<auto, typename> typename Q>
@ -850,27 +852,30 @@ static_assert(2 * one / (1 * m) == 2 / (1 * m));
// equality operators // equality operators
/////////////////////// ///////////////////////
static_assert(std::equality_comparable_with<quantity<si::metre>, quantity<si::metre>>); static_assert(std::equality_comparable_with<quantity<(si::metre)>, quantity<(si::metre)>>);
static_assert(std::equality_comparable_with<quantity<si::metre>, quantity<si::metre, int>>); static_assert(std::equality_comparable_with<quantity<(si::metre)>, quantity<(si::metre), int>>);
static_assert(std::equality_comparable_with<quantity<si::metre>, quantity<si::kilo<si::metre>, int>>); static_assert(std::equality_comparable_with<quantity<(si::metre)>, quantity<si::kilo<(si::metre)>, int>>);
static_assert(std::equality_comparable_with<quantity<si::metre, int>, quantity<si::kilo<si::metre>, int>>); static_assert(std::equality_comparable_with<quantity<(si::metre), int>, quantity<si::kilo<(si::metre)>, int>>);
static_assert(std::equality_comparable_with<quantity<isq::length[si::metre]>, quantity<si::metre>>); static_assert(std::equality_comparable_with<quantity<(isq::length[(si::metre)])>, quantity<(si::metre)>>);
static_assert(std::equality_comparable_with<quantity<isq::length[si::metre]>, quantity<si::metre, int>>); static_assert(std::equality_comparable_with<quantity<(isq::length[(si::metre)])>, quantity<(si::metre), int>>);
static_assert(std::equality_comparable_with<quantity<isq::length[si::metre]>, quantity<si::kilo<si::metre>, int>>);
static_assert(std::equality_comparable_with<quantity<isq::width[si::metre]>, quantity<si::metre>>);
static_assert(std::equality_comparable_with<quantity<isq::width[si::metre]>, quantity<si::metre, int>>);
static_assert(std::equality_comparable_with<quantity<isq::width[si::metre]>, quantity<si::kilo<si::metre>, int>>);
static_assert(std::equality_comparable_with<quantity<isq::width[si::metre]>, quantity<isq::height[si::metre]>>);
static_assert(std::equality_comparable_with<quantity<isq::width[si::metre]>, quantity<isq::height[si::metre], int>>);
static_assert( static_assert(
std::equality_comparable_with<quantity<isq::width[si::metre]>, quantity<isq::height[si::kilo<si::metre>], int>>); std::equality_comparable_with<quantity<(isq::length[(si::metre)])>, quantity<si::kilo<(si::metre)>, int>>);
static_assert(std::equality_comparable_with<quantity<(isq::width[(si::metre)])>, quantity<(si::metre)>>);
static_assert(std::equality_comparable_with<quantity<(isq::width[(si::metre)])>, quantity<(si::metre), int>>);
static_assert(
std::equality_comparable_with<quantity<(isq::width[(si::metre)])>, quantity<(si::kilo<(si::metre)>), int>>);
static_assert(std::equality_comparable_with<quantity<(isq::width[(si::metre)])>, quantity<(isq::height[(si::metre)])>>);
static_assert(
std::equality_comparable_with<quantity<(isq::width[(si::metre)])>, quantity<(isq::height[(si::metre)]), int>>);
static_assert(std::equality_comparable_with<quantity<(isq::width[(si::metre)])>,
quantity<(isq::height[(si::kilo<(si::metre)>)]), int>>);
template<auto M> template<auto M>
concept no_crossdimensional_equality = requires { concept no_crossdimensional_equality = requires {
requires !requires { 1 * s == 1 * M; }; requires !requires { 1 * s == 1 * M; };
requires !requires { 1 * s != 1 * M; }; requires !requires { 1 * s != 1 * M; };
}; };
static_assert(no_crossdimensional_equality<si::metre>); static_assert(no_crossdimensional_equality<(si::metre)>);
// same type // same type
static_assert(123 * m == 123 * m); static_assert(123 * m == 123 * m);
@ -923,7 +928,7 @@ concept no_crossdimensional_ordering = requires {
requires !requires { 1 * s <= 1 * M; }; requires !requires { 1 * s <= 1 * M; };
requires !requires { 1 * s >= 1 * M; }; requires !requires { 1 * s >= 1 * M; };
}; };
static_assert(no_crossdimensional_ordering<si::metre>); static_assert(no_crossdimensional_ordering<(si::metre)>);
// same type // same type
static_assert(123 * m < 321 * m); static_assert(123 * m < 321 * m);
@ -1037,34 +1042,35 @@ static_assert(is_of_type<quantity_cast<isq::distance>(lvalue_q), quantity<isq::d
} // namespace lvalue_tests } // namespace lvalue_tests
// QuantityOf // QuantityOf
static_assert(QuantityOf<quantity<isq::length[m]>, isq::length>); static_assert(QuantityOf<quantity<(isq::length[m])>, (isq::length)>);
static_assert(QuantityOf<quantity<isq::width[m]>, isq::length>); static_assert(QuantityOf<quantity<(isq::width[m])>, (isq::length)>);
static_assert(QuantityOf<quantity<isq::position_vector[m], int>, isq::length>); static_assert(QuantityOf<quantity<(isq::position_vector[m]), int>, (isq::length)>);
static_assert(!QuantityOf<quantity<isq::length[m]>, isq::width>); static_assert(!QuantityOf<quantity<(isq::length[m])>, (isq::width)>);
static_assert(QuantityOf<quantity<m>, isq::width>); static_assert(QuantityOf<quantity<m>, (isq::width)>);
static_assert(QuantityOf<quantity<m>, isq::position_vector>); static_assert(QuantityOf<quantity<m>, (isq::position_vector)>);
static_assert(QuantityOf<quantity<kind_of<isq::length>[m]>, isq::width>); static_assert(QuantityOf<quantity<kind_of<(isq::length)>[m]>, (isq::width)>);
static_assert(QuantityOf<quantity<kind_of<isq::length>[m]>, isq::position_vector>); static_assert(QuantityOf<quantity<kind_of<(isq::length)>[m]>, (isq::position_vector)>);
static_assert(!QuantityOf<quantity<isq::width[m]>, isq::altitude>); static_assert(!QuantityOf<quantity<(isq::width[m])>, isq::altitude>);
static_assert(QuantityOf<quantity<isq::speed[m / s]>, isq::speed>); static_assert(QuantityOf<quantity<(isq::speed[m / s])>, (isq::speed)>);
static_assert(QuantityOf<quantity<isq::speed[m / s]>, isq::length / isq::time>); static_assert(QuantityOf<quantity<(isq::speed[m / s])>, (isq::length) / (isq::time)>);
static_assert(QuantityOf<quantity<m / s>, isq::length / isq::time>); static_assert(QuantityOf<quantity<m / s>, isq::length / isq::time>);
static_assert(QuantityOf<quantity<kind_of<isq::speed>[m / s]>, isq::length / isq::time>); static_assert(QuantityOf<quantity<kind_of<(isq::speed)>[m / s]>, (isq::length) / (isq::time)>);
static_assert(!QuantityOf<quantity<isq::speed[m / s]>, isq::distance / isq::duration>); static_assert(!QuantityOf<quantity<(isq::speed[m / s])>, (isq::distance) / (isq::duration)>);
static_assert(!QuantityOf<quantity<isq::speed[m / s]>, isq::width / isq::duration>); static_assert(!QuantityOf<quantity<(isq::speed[m / s])>, (isq::width) / (isq::duration)>);
static_assert(QuantityOf<quantity<m / s>, isq::width / isq::duration>); static_assert(QuantityOf<quantity<m / s>, isq::width / isq::duration>);
static_assert(QuantityOf<quantity<kind_of<isq::speed>[m / s]>, isq::width / isq::duration>); static_assert(QuantityOf<quantity<kind_of<(isq::speed)>[m / s]>, (isq::width) / (isq::duration)>);
static_assert(!QuantityOf<quantity<isq::speed[m / s]>, isq::position_vector / isq::duration>); static_assert(!QuantityOf<quantity<(isq::speed[m / s])>, (isq::position_vector) / (isq::duration)>);
static_assert(QuantityOf<quantity<m / s>, isq::position_vector / isq::duration>); static_assert(QuantityOf<quantity<m / s>, isq::position_vector / isq::duration>);
static_assert(QuantityOf<quantity<kind_of<isq::speed>[m / s]>, isq::position_vector / isq::duration>); static_assert(QuantityOf<quantity<kind_of<(isq::speed)>[m / s]>, isq::position_vector / isq::duration>);
static_assert(QuantityOf<quantity<isq::velocity[m / s], int>, isq::position_vector / isq::duration>); static_assert(QuantityOf<quantity<(isq::velocity)[m / s], int>, isq::position_vector / isq::duration>);
static_assert(QuantityOf<decltype(10 * m), isq::height>); // kind of static_assert(QuantityOf<decltype(10 * m), (isq::height)>); // kind of
static_assert(QuantityOf<decltype(10 * kind_of<isq::length>[m]), isq::height>); // kind of static_assert(QuantityOf<decltype(10 * kind_of<(isq::length)>[m]), (isq::height)>); // kind of
static_assert(!QuantityOf<decltype(10 * isq::length[m]), isq::height>); // different kinds static_assert(!QuantityOf<decltype(10 * (isq::length[m])), (isq::height)>); // different kinds
static_assert(!QuantityOf<decltype(10 * isq::width[m]), isq::height>); // different kinds static_assert(!QuantityOf<decltype(10 * (isq::width[m])), (isq::height)>); // different kinds
static_assert(QuantityOf<decltype(10 * isq::speed[m / s]), isq::speed>); static_assert(QuantityOf<decltype(10 * (isq::speed[m / s])), (isq::speed)>);
static_assert(QuantityOf<decltype(20 * isq::length[m] / (2 * isq::time[s])), isq::speed>); // derived unnamed quantity static_assert(
QuantityOf<decltype(20 * (isq::length[m]) / (2 * isq::time[s])), (isq::speed)>); // derived unnamed quantity
} // namespace } // namespace

6
test/static/reference_test.cpp
View File

@ -34,8 +34,8 @@ namespace {
using namespace mp_units; using namespace mp_units;
using dimensionless_ = struct dimensionless; using dimensionless_ = struct mp_units::dimensionless;
using one_ = struct one; using one_ = struct mp_units::one;
// base dimensions // base dimensions
// clang-format off // clang-format off
@ -238,7 +238,7 @@ template<auto dim, auto unit>
concept invalid_nu_unit = !requires { dim[unit]; }; concept invalid_nu_unit = !requires { dim[unit]; };
static_assert(invalid_nu_unit<time, nu::second>); static_assert(invalid_nu_unit<time, nu::second>);
static_assert(invalid_nu_unit<nu::time, second>); static_assert(invalid_nu_unit<(nu::time), second>);
static_assert(invalid_nu_unit<length / time, nu::second / nu::second>); static_assert(invalid_nu_unit<length / time, nu::second / nu::second>);
static_assert(invalid_nu_unit<speed, nu::second / nu::second>); static_assert(invalid_nu_unit<speed, nu::second / nu::second>);
static_assert(invalid_nu_unit<speed, nu::second / second>); static_assert(invalid_nu_unit<speed, nu::second / second>);

2
test/static/si_test.cpp
View File

@ -65,7 +65,7 @@ concept can_not_be_prefixed = Unit<decltype(V1)> && !requires { typename prefix<
static_assert(can_not_be_prefixed<si::milli_, si::kilogram>); static_assert(can_not_be_prefixed<si::milli_, si::kilogram>);
static_assert(can_not_be_prefixed<si::milli_, si::hectare>); static_assert(can_not_be_prefixed<si::milli_, si::hectare>);
static_assert(can_not_be_prefixed<si::milli_, si::kilo<si::metre>>); static_assert(can_not_be_prefixed<si::milli_, (si::kilo<(si::metre)>)>);
static_assert(can_not_be_prefixed<si::milli_, si::metre / si::second>); static_assert(can_not_be_prefixed<si::milli_, si::metre / si::second>);
static_assert(can_not_be_prefixed<si::milli_, mag_ratio<1, 60> * si::degree>); static_assert(can_not_be_prefixed<si::milli_, mag_ratio<1, 60> * si::degree>);

4
test/static/unit_test.cpp
View File

@ -35,8 +35,8 @@ namespace {
using namespace mp_units; using namespace mp_units;
using namespace mp_units::detail; using namespace mp_units::detail;
using one_ = struct one; using one_ = struct mp_units::one;
using percent_ = struct percent; using percent_ = struct mp_units::percent;
// base dimensions // base dimensions
// clang-format off // clang-format off