forked from mpusz/mp-units
style: clang-format applied to the remaining files
This commit is contained in:
Mateusz Pusz
@@ -67,19 +67,22 @@ static_assert(!Speed<si::time<si::second>>);
|
||||
static_assert(Acceleration<si::acceleration<si::metre_per_second_sq>>);
|
||||
static_assert(!Acceleration<si::time<si::second>>);
|
||||
#if UNITS_DOWNCAST_MODE == 0
|
||||
static_assert(Acceleration<quantity<unknown_dimension<exponent<si::dim_length, 1>, exponent<si::dim_time, -2>>, unknown_coherent_unit>>);
|
||||
static_assert(Acceleration<quantity<unknown_dimension<exponent<si::dim_length, 1>, exponent<si::dim_time, -2>>,
|
||||
unknown_coherent_unit>>);
|
||||
#endif
|
||||
|
||||
static_assert(Force<si::force<si::newton>>);
|
||||
static_assert(!Force<si::time<si::second>>);
|
||||
#if UNITS_DOWNCAST_MODE == 0
|
||||
// static_assert(Force<quantity<unknown_dimension<exponent<si::dim_length, 1>, exponent<si::dim_time, -2>, exponent<si::dim_mass, 1>>, unknown_coherent_unit>>);
|
||||
// static_assert(Force<quantity<unknown_dimension<exponent<si::dim_length, 1>, exponent<si::dim_time, -2>,
|
||||
// exponent<si::dim_mass, 1>>, unknown_coherent_unit>>);
|
||||
#endif
|
||||
|
||||
static_assert(Energy<si::energy<si::joule>>);
|
||||
static_assert(!Energy<si::time<si::second>>);
|
||||
#if UNITS_DOWNCAST_MODE == 0
|
||||
// static_assert(Energy<quantity<unknown_dimension<exponent<si::dim_mass, 1>, exponent<si::dim_length, 2>, exponent<si::dim_time, -3>>, unknown_coherent_unit>>);
|
||||
// static_assert(Energy<quantity<unknown_dimension<exponent<si::dim_mass, 1>, exponent<si::dim_length, 2>,
|
||||
// exponent<si::dim_time, -3>>, unknown_coherent_unit>>);
|
||||
#endif
|
||||
|
||||
static_assert(Power<si::power<si::watt>>);
|
||||
@@ -168,4 +171,4 @@ static_assert(!Permeability<si::time<si::second>>);
|
||||
static_assert(MolarEnergy<si::molar_energy<si::joule_per_mole>>);
|
||||
static_assert(!MolarEnergy<si::time<si::second>>);
|
||||
|
||||
}
|
||||
} // namespace
|
||||
|
||||
@@ -50,4 +50,4 @@ static_assert(basic_fixed_string('d') + txt2 == basic_fixed_string("dabc"));
|
||||
static_assert(txt2 + basic_fixed_string("def") == basic_fixed_string("abcdef"));
|
||||
static_assert(basic_fixed_string("def") + txt2 == basic_fixed_string("defabc"));
|
||||
|
||||
}
|
||||
} // namespace
|
||||
|
||||
@@ -100,6 +100,7 @@ static_assert(1_q_ft_pdl_per_s * 10_q_s == 10_q_ft_pdl);
|
||||
static_assert(10_q_ft_pdl / 1_q_ft_pdl_per_s == 10_q_s);
|
||||
|
||||
static_assert(detail::unit_text<dim_power, foot_poundal_per_second>() == basic_symbol_text("ft ⋅ pdl/s", "ft pdl/s"));
|
||||
static_assert(detail::unit_text<dim_power, foot_pound_force_per_second>() == basic_symbol_text("ft ⋅ lbf/s", "ft lbf/s"));
|
||||
static_assert(detail::unit_text<dim_power, foot_pound_force_per_second>() ==
|
||||
basic_symbol_text("ft ⋅ lbf/s", "ft lbf/s"));
|
||||
|
||||
}
|
||||
} // namespace
|
||||
|
||||
@@ -114,7 +114,7 @@ concept invalid_types =
|
||||
requires {
|
||||
requires !requires { typename quantity_kind<Width, second, int>; }; // unit of a different dimension
|
||||
requires !requires { typename quantity_kind<Width, metre, length<metre>>; }; // quantity used as Rep
|
||||
requires !requires { // quantity point used as Rep
|
||||
requires !requires { // quantity point used as Rep
|
||||
typename quantity_kind<Width, metre, quantity_point<dynamic_origin<dim_length>, metre>>;
|
||||
};
|
||||
requires !requires { typename quantity_kind<Width, metre, width<metre>>; }; // quantity kind used as Rep
|
||||
|
||||
@@ -20,7 +20,6 @@
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
// SOFTWARE.
|
||||
|
||||
#include <units/quantity_point.h>
|
||||
#include "test_tools.h"
|
||||
#include <units/bits/common_type.h>
|
||||
#include <units/bits/external/type_traits.h>
|
||||
@@ -29,6 +28,7 @@
|
||||
#include <units/isq/si/speed.h>
|
||||
#include <units/isq/si/uscs/length.h>
|
||||
#include <units/isq/si/volume.h>
|
||||
#include <units/quantity_point.h>
|
||||
#include <limits>
|
||||
#include <type_traits>
|
||||
#include <utility>
|
||||
@@ -46,20 +46,22 @@ struct sea_level_origin : point_origin<dim_length> {};
|
||||
// class invariants
|
||||
|
||||
template<typename DimLength>
|
||||
concept invalid_types = requires
|
||||
{
|
||||
// unit of a different dimension:
|
||||
requires !requires { typename quantity_point<dynamic_origin<DimLength>, second, int>; };
|
||||
// quantity used as Rep:
|
||||
requires !requires { typename quantity_point<dynamic_origin<DimLength>, metre, quantity<DimLength, metre, int>>; };
|
||||
// quantity point used as Rep:
|
||||
requires !requires { typename quantity_point<dynamic_origin<DimLength>, metre,
|
||||
quantity_point<dynamic_origin<DimLength>, metre, int>>; };
|
||||
// reordered arguments:
|
||||
requires !requires { typename quantity_point<metre, dynamic_origin<DimLength>, double>; };
|
||||
// dimension used as origin:
|
||||
requires !requires { typename quantity_point<DimLength, second, int>; };
|
||||
};
|
||||
concept invalid_types =
|
||||
requires {
|
||||
// unit of a different dimension:
|
||||
requires !requires { typename quantity_point<dynamic_origin<DimLength>, second, int>; };
|
||||
// quantity used as Rep:
|
||||
requires !requires { typename quantity_point<dynamic_origin<DimLength>, metre, quantity<DimLength, metre, int>>; };
|
||||
// quantity point used as Rep:
|
||||
requires !requires {
|
||||
typename quantity_point<dynamic_origin<DimLength>, metre,
|
||||
quantity_point<dynamic_origin<DimLength>, metre, int>>;
|
||||
};
|
||||
// reordered arguments:
|
||||
requires !requires { typename quantity_point<metre, dynamic_origin<DimLength>, double>; };
|
||||
// dimension used as origin:
|
||||
requires !requires { typename quantity_point<DimLength, second, int>; };
|
||||
};
|
||||
|
||||
static_assert(invalid_types<dim_length>);
|
||||
|
||||
@@ -71,7 +73,8 @@ static_assert(is_same_v<quantity_point<dynamic_origin<dim_length>, metre, int>::
|
||||
static_assert(is_same_v<quantity_point<dynamic_origin<dim_length>, kilometre, int>::unit, kilometre>);
|
||||
static_assert(is_same_v<quantity_point<dynamic_origin<dim_length>, metre, int>::dimension, dim_length>);
|
||||
static_assert(is_same_v<quantity_point<dynamic_origin<dim_length>, metre, int>::origin, dynamic_origin<dim_length>>);
|
||||
static_assert(is_same_v<quantity_point<dynamic_origin<dim_length>, metre, int>::quantity_type, quantity<dim_length, metre, int>>);
|
||||
static_assert(
|
||||
is_same_v<quantity_point<dynamic_origin<dim_length>, metre, int>::quantity_type, quantity<dim_length, metre, int>>);
|
||||
|
||||
// constructors
|
||||
|
||||
@@ -80,10 +83,14 @@ static_assert(!std::is_convertible_v<int, quantity_point<dynamic_origin<dim_one>
|
||||
|
||||
static_assert(quantity_point(42s).relative() == 42 * s);
|
||||
static_assert(quantity_point(sys_seconds{42s}).relative() == 42 * s);
|
||||
static_assert(!std::is_convertible_v<std::chrono::seconds, quantity_point<dynamic_origin<dim_time>, second, std::chrono::seconds::rep>>);
|
||||
static_assert(!std::is_convertible_v<std::chrono::seconds, quantity_point<clock_origin<std::chrono::system_clock>, second, std::chrono::seconds::rep>>);
|
||||
static_assert(!std::is_convertible_v<std::chrono::seconds,
|
||||
quantity_point<dynamic_origin<dim_time>, second, std::chrono::seconds::rep>>);
|
||||
static_assert(
|
||||
!std::is_convertible_v<std::chrono::seconds,
|
||||
quantity_point<clock_origin<std::chrono::system_clock>, second, std::chrono::seconds::rep>>);
|
||||
static_assert(!std::is_convertible_v<sys_seconds, quantity_point<dynamic_origin<dim_time>, second, sys_seconds::rep>>);
|
||||
static_assert(!std::is_convertible_v<sys_seconds, quantity_point<clock_origin<std::chrono::system_clock>, second, sys_seconds::rep>>);
|
||||
static_assert(!std::is_convertible_v<
|
||||
sys_seconds, quantity_point<clock_origin<std::chrono::system_clock>, second, sys_seconds::rep>>);
|
||||
|
||||
static_assert(quantity_point<dynamic_origin<dim_length>, metre, int>().relative() == 0_q_m);
|
||||
constexpr quantity_point<dynamic_origin<dim_length>, metre, int> km{1000_q_m};
|
||||
@@ -91,21 +98,25 @@ static_assert(km.relative() == 1000_q_m);
|
||||
static_assert(quantity_point<dynamic_origin<dim_length>, metre, int>(km).relative() == km.relative());
|
||||
|
||||
static_assert(quantity_point<dynamic_origin<dim_length>, metre, int>(1_q_m).relative() == 1_q_m);
|
||||
static_assert(!std::is_constructible_v<quantity_point<dynamic_origin<dim_length>, metre, int>, double>); // truncating conversion
|
||||
static_assert(
|
||||
!std::is_constructible_v<quantity_point<dynamic_origin<dim_length>, metre, int>, double>); // truncating conversion
|
||||
static_assert(quantity_point<dynamic_origin<dim_length>, metre, double>(1.0_q_m).relative() == 1.0_q_m);
|
||||
static_assert(quantity_point<dynamic_origin<dim_length>, metre, double>(1_q_m).relative() == 1_q_m);
|
||||
static_assert(quantity_point<dynamic_origin<dim_length>, metre, long double>(3.14_q_m).relative() == 3.14_q_m);
|
||||
|
||||
static_assert(quantity_point<dynamic_origin<dim_length>, metre, int>(km).relative() == 1000_q_m);
|
||||
static_assert(!std::is_constructible_v<quantity_point<dynamic_origin<dim_length>, metre, int>,
|
||||
quantity_point<dynamic_origin<dim_length>, metre, double>>); // truncating conversion
|
||||
static_assert(quantity_point<dynamic_origin<dim_length>, metre, double>(quantity_point(1000.0_q_m)).relative() == 1000.0_q_m);
|
||||
static_assert(
|
||||
!std::is_constructible_v<quantity_point<dynamic_origin<dim_length>, metre, int>,
|
||||
quantity_point<dynamic_origin<dim_length>, metre, double>>); // truncating conversion
|
||||
static_assert(quantity_point<dynamic_origin<dim_length>, metre, double>(quantity_point(1000.0_q_m)).relative() ==
|
||||
1000.0_q_m);
|
||||
static_assert(quantity_point<dynamic_origin<dim_length>, metre, double>(km).relative() == 1000.0_q_m);
|
||||
static_assert(quantity_point<dynamic_origin<dim_length>, metre, int>(quantity_point(1_q_km)).relative() == 1000_q_m);
|
||||
static_assert(!std::is_constructible_v<quantity_point<dynamic_origin<dim_length>, metre, int>,
|
||||
quantity_point<dynamic_origin<dim_time>, second, int>>); // different dimensions
|
||||
static_assert(!std::is_constructible_v<quantity_point<dynamic_origin<dim_length>, kilometre, int>,
|
||||
quantity_point<dynamic_origin<dim_length>, metre, int>>); // truncating conversion
|
||||
static_assert(
|
||||
!std::is_constructible_v<quantity_point<dynamic_origin<dim_length>, kilometre, int>,
|
||||
quantity_point<dynamic_origin<dim_length>, metre, int>>); // truncating conversion
|
||||
|
||||
static_assert(!std::is_constructible_v<quantity_point<sea_level_origin, kilometre, int>,
|
||||
quantity_point<dynamic_origin<dim_length>, metre, int>>,
|
||||
@@ -115,12 +126,18 @@ static_assert(!std::is_constructible_v<quantity_point<dynamic_origin<dim_time>,
|
||||
|
||||
// assignment operator
|
||||
|
||||
static_assert([]() { quantity_point<dynamic_origin<dim_length>, metre, int> l1(1_q_m), l2{}; return l2 = l1; }().relative() == 1_q_m);
|
||||
static_assert(([]() {
|
||||
quantity_point<dynamic_origin<dim_length>, metre, int> l1(1_q_m), l2{};
|
||||
return l2 = l1;
|
||||
}())
|
||||
.relative() == 1_q_m);
|
||||
|
||||
// static member functions
|
||||
|
||||
static_assert(quantity_point<dynamic_origin<dim_length>, metre, int>::min().relative().number() == std::numeric_limits<int>::lowest());
|
||||
static_assert(quantity_point<dynamic_origin<dim_length>, metre, int>::max().relative().number() == std::numeric_limits<int>::max());
|
||||
static_assert(quantity_point<dynamic_origin<dim_length>, metre, int>::min().relative().number() ==
|
||||
std::numeric_limits<int>::lowest());
|
||||
static_assert(quantity_point<dynamic_origin<dim_length>, metre, int>::max().relative().number() ==
|
||||
std::numeric_limits<int>::max());
|
||||
static_assert(quantity_point<dynamic_origin<dim_length>, metre, double>::min().relative().number() ==
|
||||
std::numeric_limits<double>::lowest());
|
||||
static_assert(quantity_point<dynamic_origin<dim_length>, metre, double>::max().relative().number() ==
|
||||
@@ -131,19 +148,23 @@ static_assert(quantity_point<dynamic_origin<dim_length>, metre, double>::max().r
|
||||
static_assert([](auto v) {
|
||||
auto vv = v++;
|
||||
return std::pair(v, vv);
|
||||
}(km) == std::pair(quantity_point<dynamic_origin<dim_length>, metre, int>(1001_q_m), quantity_point<dynamic_origin<dim_length>, metre, int>(1000_q_m)));
|
||||
}(km) == std::pair(quantity_point<dynamic_origin<dim_length>, metre, int>(1001_q_m),
|
||||
quantity_point<dynamic_origin<dim_length>, metre, int>(1000_q_m)));
|
||||
static_assert([](auto v) {
|
||||
auto vv = ++v;
|
||||
return std::pair(v, vv);
|
||||
}(km) == std::pair(quantity_point<dynamic_origin<dim_length>, metre, int>(1001_q_m), quantity_point<dynamic_origin<dim_length>, metre, int>(1001_q_m)));
|
||||
}(km) == std::pair(quantity_point<dynamic_origin<dim_length>, metre, int>(1001_q_m),
|
||||
quantity_point<dynamic_origin<dim_length>, metre, int>(1001_q_m)));
|
||||
static_assert([](auto v) {
|
||||
auto vv = v--;
|
||||
return std::pair(v, vv);
|
||||
}(km) == std::pair(quantity_point<dynamic_origin<dim_length>, metre, int>(999_q_m), quantity_point<dynamic_origin<dim_length>, metre, int>(1000_q_m)));
|
||||
}(km) == std::pair(quantity_point<dynamic_origin<dim_length>, metre, int>(999_q_m),
|
||||
quantity_point<dynamic_origin<dim_length>, metre, int>(1000_q_m)));
|
||||
static_assert([](auto v) {
|
||||
auto vv = --v;
|
||||
return std::pair(v, vv);
|
||||
}(km) == std::pair(quantity_point<dynamic_origin<dim_length>, metre, int>(999_q_m), quantity_point<dynamic_origin<dim_length>, metre, int>(999_q_m)));
|
||||
}(km) == std::pair(quantity_point<dynamic_origin<dim_length>, metre, int>(999_q_m),
|
||||
quantity_point<dynamic_origin<dim_length>, metre, int>(999_q_m)));
|
||||
|
||||
// compound assignment
|
||||
|
||||
@@ -153,23 +174,23 @@ static_assert((quantity_point(2_q_m) -= 1_q_m).relative().number() == 1);
|
||||
// non-member arithmetic operators
|
||||
|
||||
static_assert(compare<decltype(quantity_point<dynamic_origin<dim_length>, metre, int>() + length<metre, double>()),
|
||||
quantity_point<dynamic_origin<dim_length>, metre, double>>);
|
||||
quantity_point<dynamic_origin<dim_length>, metre, double>>);
|
||||
static_assert(compare<decltype(length<metre, int>() + quantity_point<dynamic_origin<dim_length>, metre, double>()),
|
||||
quantity_point<dynamic_origin<dim_length>, metre, double>>);
|
||||
quantity_point<dynamic_origin<dim_length>, metre, double>>);
|
||||
static_assert(compare<decltype(quantity_point<dynamic_origin<dim_length>, kilometre, int>() + length<metre, double>()),
|
||||
quantity_point<dynamic_origin<dim_length>, metre, double>>);
|
||||
quantity_point<dynamic_origin<dim_length>, metre, double>>);
|
||||
static_assert(compare<decltype(length<kilometre, int>() + quantity_point<dynamic_origin<dim_length>, metre, double>()),
|
||||
quantity_point<dynamic_origin<dim_length>, metre, double>>);
|
||||
quantity_point<dynamic_origin<dim_length>, metre, double>>);
|
||||
static_assert(compare<decltype(quantity_point<dynamic_origin<dim_length>, metre, double>() - length<metre, int>()),
|
||||
quantity_point<dynamic_origin<dim_length>, metre, double>>);
|
||||
quantity_point<dynamic_origin<dim_length>, metre, double>>);
|
||||
static_assert(compare<decltype(quantity_point<dynamic_origin<dim_length>, kilometre, double>() - length<metre, int>()),
|
||||
quantity_point<dynamic_origin<dim_length>, metre, double>>);
|
||||
static_assert(
|
||||
compare<decltype(quantity_point<dynamic_origin<dim_length>, metre, double>() - quantity_point<dynamic_origin<dim_length>, metre, int>()),
|
||||
length<metre, double>>);
|
||||
static_assert(
|
||||
compare<decltype(quantity_point<dynamic_origin<dim_length>, kilometre, double>() - quantity_point<dynamic_origin<dim_length>, metre, int>()),
|
||||
length<metre, double>>);
|
||||
quantity_point<dynamic_origin<dim_length>, metre, double>>);
|
||||
static_assert(compare<decltype(quantity_point<dynamic_origin<dim_length>, metre, double>() -
|
||||
quantity_point<dynamic_origin<dim_length>, metre, int>()),
|
||||
length<metre, double>>);
|
||||
static_assert(compare<decltype(quantity_point<dynamic_origin<dim_length>, kilometre, double>() -
|
||||
quantity_point<dynamic_origin<dim_length>, metre, int>()),
|
||||
length<metre, double>>);
|
||||
|
||||
static_assert((1_q_m + km).relative().number() == 1001);
|
||||
static_assert((quantity_point(1_q_m) + 1_q_km).relative().number() == 1001);
|
||||
@@ -177,10 +198,9 @@ static_assert((km - 1_q_m).relative().number() == 999);
|
||||
static_assert((quantity_point(1_q_km) - quantity_point(1_q_m)).number() == 999);
|
||||
|
||||
template<typename Int>
|
||||
concept invalid_subtraction = requires(quantity_point<dynamic_origin<dim_length>, metre, Int> lhs,
|
||||
quantity_point<sea_level_origin, metre, Int> rhs) {
|
||||
requires !requires { rhs - lhs; };
|
||||
};
|
||||
concept invalid_subtraction =
|
||||
requires(quantity_point<dynamic_origin<dim_length>, metre, Int> lhs,
|
||||
quantity_point<sea_level_origin, metre, Int> rhs) { requires !requires { rhs - lhs; }; };
|
||||
static_assert(invalid_subtraction<int>);
|
||||
|
||||
// comparators
|
||||
@@ -217,9 +237,9 @@ static_assert(quantity_point(1000_q_m) <= quantity_point(1_q_km));
|
||||
template<typename Int>
|
||||
concept invalid_comparisons = requires(quantity_point<dynamic_origin<dim_length>, metre, Int> lhs,
|
||||
quantity_point<sea_level_origin, metre, Int> rhs) {
|
||||
requires !requires { lhs == rhs; };
|
||||
requires !requires { lhs < rhs; };
|
||||
};
|
||||
requires !requires { lhs == rhs; };
|
||||
requires !requires { lhs < rhs; };
|
||||
};
|
||||
static_assert(invalid_comparisons<int>);
|
||||
|
||||
// alias units
|
||||
@@ -256,25 +276,35 @@ static_assert(std::equality_comparable_with<decltype(quantity_point(1_q_m)), dec
|
||||
|
||||
// quantity_cast
|
||||
|
||||
static_assert(quantity_point_cast<quantity_point<dynamic_origin<dim_length>, metre, int>>(quantity_point(2_q_km)).relative().number() ==
|
||||
2000);
|
||||
static_assert(
|
||||
quantity_point_cast<quantity_point<dynamic_origin<dim_length>, kilometre, int>>(quantity_point(2000_q_m)).relative().number() == 2);
|
||||
static_assert(quantity_point_cast<quantity_point<dynamic_origin<dim_length>, metre, int>>(quantity_point(1.23_q_m)).relative().number() ==
|
||||
1);
|
||||
static_assert(quantity_point_cast<quantity_point<dynamic_origin<dim_length>, metre, int>>(quantity_point(2_q_km))
|
||||
.relative()
|
||||
.number() == 2000);
|
||||
static_assert(quantity_point_cast<quantity_point<dynamic_origin<dim_length>, kilometre, int>>(quantity_point(2000_q_m))
|
||||
.relative()
|
||||
.number() == 2);
|
||||
static_assert(quantity_point_cast<quantity_point<dynamic_origin<dim_length>, metre, int>>(quantity_point(1.23_q_m))
|
||||
.relative()
|
||||
.number() == 1);
|
||||
static_assert(quantity_point_cast<length<metre, int>>(quantity_point(2_q_km)).relative().number() == 2000);
|
||||
static_assert(quantity_point_cast<length<kilometre, int>>(quantity_point(2000_q_m)).relative().number() == 2);
|
||||
static_assert(quantity_point_cast<length<metre, int>>(quantity_point(1.23_q_m)).relative().number() == 1);
|
||||
static_assert(quantity_point_cast<metre>(quantity_point(2_q_km)).relative().number() == 2000);
|
||||
static_assert(quantity_point_cast<kilometre>(quantity_point(2000_q_m)).relative().number() == 2);
|
||||
static_assert(quantity_point_cast<int>(quantity_point(1.23_q_m)).relative().number() == 1);
|
||||
static_assert(quantity_point_cast<dim_speed, kilometre_per_hour>(quantity_point(2000.0_q_m / 3600.0_q_s)).relative().number() == 2);
|
||||
static_assert(
|
||||
quantity_point_cast<dim_speed, kilometre_per_hour>(quantity_point(2000.0_q_m / 3600.0_q_s)).relative().number() == 2);
|
||||
|
||||
template<typename Int>
|
||||
concept invalid_cast = requires(Int i) {
|
||||
requires !requires { quantity_point_cast<quantity_point<dynamic_origin<dim_time>, second, Int>>(quantity_point(i * m)); };
|
||||
requires !requires { quantity_point_cast<quantity_point<dynamic_origin<dim_length>, metre, Int>>(quantity_point<sea_level_origin, metre, Int>(i * m)); };
|
||||
};
|
||||
concept invalid_cast =
|
||||
requires(Int i) {
|
||||
requires !requires {
|
||||
quantity_point_cast<quantity_point<dynamic_origin<dim_time>, second, Int>>(quantity_point(i * m));
|
||||
};
|
||||
requires !requires {
|
||||
quantity_point_cast<quantity_point<dynamic_origin<dim_length>, metre, Int>>(
|
||||
quantity_point<sea_level_origin, metre, Int>(i * m));
|
||||
};
|
||||
};
|
||||
static_assert(invalid_cast<int>);
|
||||
|
||||
// time
|
||||
@@ -282,10 +312,7 @@ static_assert(invalid_cast<int>);
|
||||
static_assert(quantity_point{1_q_h} == quantity_point{3600_q_s});
|
||||
|
||||
template<typename Metre>
|
||||
concept no_crossdimensional_equality = !requires
|
||||
{
|
||||
quantity_point(1_q_s) == quantity_point(length<Metre, int>(1));
|
||||
};
|
||||
concept no_crossdimensional_equality = !requires { quantity_point(1_q_s) == quantity_point(length<Metre, int>(1)); };
|
||||
|
||||
static_assert(no_crossdimensional_equality<metre>);
|
||||
|
||||
@@ -297,10 +324,7 @@ static_assert(quantity_point(1_q_km) + 1_q_m == quantity_point(1001_q_m));
|
||||
static_assert(1_q_km + quantity_point(1_q_m) == quantity_point(1001_q_m));
|
||||
|
||||
template<class T>
|
||||
concept dimensional_analysis = requires(T t)
|
||||
{
|
||||
pow<2>(t);
|
||||
};
|
||||
concept dimensional_analysis = requires(T t) { pow<2>(t); };
|
||||
|
||||
static_assert(!dimensional_analysis<quantity_point<dynamic_origin<dim_length>, metre, int>>);
|
||||
|
||||
|
||||
@@ -58,11 +58,11 @@ static_assert(sizeof(length<metre, short>) == sizeof(short));
|
||||
#if UNITS_COMP_GCC != 10 || UNITS_COMP_GCC_MINOR > 2
|
||||
template<template<typename, typename, typename> typename Q>
|
||||
concept invalid_types = requires {
|
||||
requires !requires { typename Q<dim_length, second, int>; }; // unit of a different dimension
|
||||
requires !requires { typename Q<dim_length, metre, length<metre>>; }; // quantity used as Rep
|
||||
requires !requires { typename Q<metre, dim_length, double>; }; // reordered arguments
|
||||
requires !requires { typename Q<metre, double, dim_length>; }; // reordered arguments
|
||||
};
|
||||
requires !requires { typename Q<dim_length, second, int>; }; // unit of a different dimension
|
||||
requires !requires { typename Q<dim_length, metre, length<metre>>; }; // quantity used as Rep
|
||||
requires !requires { typename Q<metre, dim_length, double>; }; // reordered arguments
|
||||
requires !requires { typename Q<metre, double, dim_length>; }; // reordered arguments
|
||||
};
|
||||
static_assert(invalid_types<quantity>);
|
||||
#endif
|
||||
|
||||
@@ -128,7 +128,8 @@ static_assert(!std::convertible_to<double, length<metre>>);
|
||||
static_assert(std::constructible_from<length<metre>, float>);
|
||||
static_assert(!std::convertible_to<float, length<metre>>);
|
||||
|
||||
static_assert(std::constructible_from<length<metre, float>, double>); // truncating implicit conversions double -> float allowed
|
||||
static_assert(
|
||||
std::constructible_from<length<metre, float>, double>); // truncating implicit conversions double -> float allowed
|
||||
static_assert(!std::convertible_to<double, length<metre, float>>);
|
||||
|
||||
static_assert(std::constructible_from<length<metre>, int>);
|
||||
@@ -137,7 +138,8 @@ static_assert(!std::convertible_to<int, length<metre>>);
|
||||
static_assert(std::constructible_from<length<metre>, short>);
|
||||
static_assert(!std::convertible_to<short, length<metre>>);
|
||||
|
||||
static_assert(std::constructible_from<length<metre, short>, int>); // truncating implicit conversions int -> short allowed
|
||||
static_assert(
|
||||
std::constructible_from<length<metre, short>, int>); // truncating implicit conversions int -> short allowed
|
||||
static_assert(!std::convertible_to<int, length<metre, short>>);
|
||||
|
||||
// exception, implicit construction from a value allowed for a dimensionless quantity
|
||||
@@ -166,7 +168,8 @@ static_assert(!std::convertible_to<double, dimensionless<percent>>);
|
||||
static_assert(std::constructible_from<dimensionless<percent>, float>);
|
||||
static_assert(!std::convertible_to<float, dimensionless<percent>>);
|
||||
|
||||
static_assert(std::constructible_from<dimensionless<percent, float>, double>); // truncating implicit conversions double -> float allowed
|
||||
static_assert(std::constructible_from<dimensionless<percent, float>,
|
||||
double>); // truncating implicit conversions double -> float allowed
|
||||
static_assert(!std::convertible_to<double, dimensionless<percent, float>>);
|
||||
|
||||
static_assert(std::constructible_from<dimensionless<percent>, int>);
|
||||
@@ -175,7 +178,8 @@ static_assert(!std::convertible_to<int, dimensionless<percent>>);
|
||||
static_assert(std::constructible_from<dimensionless<percent>, short>);
|
||||
static_assert(!std::convertible_to<short, dimensionless<percent>>);
|
||||
|
||||
static_assert(std::constructible_from<dimensionless<percent, short>, int>); // truncating implicit conversions int -> short allowed
|
||||
static_assert(
|
||||
std::constructible_from<dimensionless<percent, short>, int>); // truncating implicit conversions int -> short allowed
|
||||
static_assert(!std::convertible_to<int, dimensionless<percent, short>>);
|
||||
|
||||
// floating-point to integral truncating conversion not allowed
|
||||
@@ -185,7 +189,7 @@ static_assert(!std::convertible_to<double, length<metre, int>>);
|
||||
static_assert(!std::constructible_from<dimensionless<one, int>, double>);
|
||||
static_assert(!std::convertible_to<double, dimensionless<one, int>>);
|
||||
|
||||
static_assert(length<metre, int>().number() == 0); // value initialization
|
||||
static_assert(length<metre, int>().number() == 0); // value initialization
|
||||
static_assert(length<metre, int>(1).number() == 1);
|
||||
static_assert(length<metre, double>(1.0).number() == 1.0);
|
||||
static_assert(length<metre, double>(1).number() == 1.0);
|
||||
@@ -212,16 +216,18 @@ static_assert(!std::convertible_to<speed<metre_per_second>, length<metre>>);
|
||||
|
||||
// implicit conversion from another quantity only if non-truncating
|
||||
static_assert(std::constructible_from<length<metre>, length<metre, int>>); // int -> double OK
|
||||
static_assert(std::convertible_to<length<metre, int>, length<metre>>); // int -> double OK
|
||||
static_assert(std::convertible_to<length<metre, int>, length<metre>>); // int -> double OK
|
||||
|
||||
static_assert(!std::constructible_from<length<metre, int>, length<metre>>); // truncating double -> int not allowed
|
||||
static_assert(!std::convertible_to<length<metre>, length<metre, int>>); // truncating double -> int not allowed
|
||||
static_assert(!std::convertible_to<length<metre>, length<metre, int>>); // truncating double -> int not allowed
|
||||
|
||||
static_assert(std::constructible_from<length<metre, int>, length<kilometre, int>>); // kilometre<int> -> metre<int> OK
|
||||
static_assert(std::convertible_to<length<kilometre, int>, length<metre, int>>); // kilometre<int> -> metre<int> OK
|
||||
static_assert(std::convertible_to<length<kilometre, int>, length<metre, int>>); // kilometre<int> -> metre<int> OK
|
||||
|
||||
static_assert(!std::constructible_from<length<kilometre, int>, length<metre, int>>); // truncating metre<int> -> kilometre<int> not allowed
|
||||
static_assert(!std::convertible_to<length<metre, int>, length<kilometre, int>>); // truncating metre<int> -> kilometre<int> not allowed
|
||||
static_assert(!std::constructible_from<length<kilometre, int>,
|
||||
length<metre, int>>); // truncating metre<int> -> kilometre<int> not allowed
|
||||
static_assert(!std::convertible_to<length<metre, int>,
|
||||
length<kilometre, int>>); // truncating metre<int> -> kilometre<int> not allowed
|
||||
|
||||
// converting to double always OK
|
||||
static_assert(std::constructible_from<length<metre>, length<kilometre, int>>);
|
||||
@@ -249,13 +255,21 @@ struct derived_quantity : quantity<typename Q::dimension, typename Q::unit, Rep>
|
||||
constexpr explicit(!std::is_trivial_v<Rep>) derived_quantity(const R& t) : R(t) {}
|
||||
constexpr explicit(!std::is_trivial_v<Rep>) derived_quantity(R&& t) : R(std::move(t)) {}
|
||||
|
||||
constexpr derived_quantity& operator=(const R& t) { R::operator=(t); return *this; }
|
||||
constexpr derived_quantity& operator=(R&& t) { R::operator=(std::move(t)); return *this; }
|
||||
constexpr derived_quantity& operator=(const R& t)
|
||||
{
|
||||
R::operator=(t);
|
||||
return *this;
|
||||
}
|
||||
constexpr derived_quantity& operator=(R&& t)
|
||||
{
|
||||
R::operator=(std::move(t));
|
||||
return *this;
|
||||
}
|
||||
|
||||
constexpr operator R&() & noexcept { return *this; }
|
||||
constexpr operator const R&() const & noexcept { return *this; }
|
||||
constexpr operator const R&() const& noexcept { return *this; }
|
||||
constexpr operator R&&() && noexcept { return *this; }
|
||||
constexpr operator const R&&() const && noexcept { return *this; }
|
||||
constexpr operator const R&&() const&& noexcept { return *this; }
|
||||
};
|
||||
|
||||
static_assert(detail::is_quantity<derived_quantity<double, si::length<metre>, "NTTP type description">>);
|
||||
@@ -290,8 +304,16 @@ static_assert(is_same_v<decltype(quantity{1.23}), dimensionless<one, double>>);
|
||||
// assignment operator
|
||||
////////////////////////
|
||||
|
||||
static_assert([]() { length<metre, int> l1(1), l2(2); return l2 = l1; }().number() == 1);
|
||||
static_assert([]() { length<metre, int> l1(1), l2(2); return l2 = std::move(l1); }().number() == 1);
|
||||
static_assert([]() {
|
||||
length<metre, int> l1(1), l2(2);
|
||||
return l2 = l1;
|
||||
}()
|
||||
.number() == 1);
|
||||
static_assert([]() {
|
||||
length<metre, int> l1(1), l2(2);
|
||||
return l2 = std::move(l1);
|
||||
}()
|
||||
.number() == 1);
|
||||
|
||||
|
||||
////////////////////
|
||||
@@ -303,10 +325,22 @@ static_assert((-123_q_m).number() == -123);
|
||||
static_assert((+(-123_q_m)).number() == -123);
|
||||
static_assert((-(-123_q_m)).number() == 123);
|
||||
|
||||
static_assert([](auto v) { auto vv = v++; return std::pair(v, vv); }(123_q_m) == std::pair(124_q_m, 123_q_m));
|
||||
static_assert([](auto v) { auto vv = ++v; return std::pair(v, vv); }(123_q_m) == std::pair(124_q_m, 124_q_m));
|
||||
static_assert([](auto v) { auto vv = v--; return std::pair(v, vv); }(123_q_m) == std::pair(122_q_m, 123_q_m));
|
||||
static_assert([](auto v) { auto vv = --v; return std::pair(v, vv); }(123_q_m) == std::pair(122_q_m, 122_q_m));
|
||||
static_assert([](auto v) {
|
||||
auto vv = v++;
|
||||
return std::pair(v, vv);
|
||||
}(123_q_m) == std::pair(124_q_m, 123_q_m));
|
||||
static_assert([](auto v) {
|
||||
auto vv = ++v;
|
||||
return std::pair(v, vv);
|
||||
}(123_q_m) == std::pair(124_q_m, 124_q_m));
|
||||
static_assert([](auto v) {
|
||||
auto vv = v--;
|
||||
return std::pair(v, vv);
|
||||
}(123_q_m) == std::pair(122_q_m, 123_q_m));
|
||||
static_assert([](auto v) {
|
||||
auto vv = --v;
|
||||
return std::pair(v, vv);
|
||||
}(123_q_m) == std::pair(122_q_m, 122_q_m));
|
||||
|
||||
static_assert(is_same_v<decltype((+(short{0} * m)).number()), int&&>);
|
||||
|
||||
@@ -337,15 +371,32 @@ static_assert((2.5_q_m *= quantity(3)).number() == 7.5);
|
||||
static_assert((7.5_q_m /= quantity(3)).number() == 2.5);
|
||||
static_assert((3500_q_m %= 1_q_km).number() == 500);
|
||||
|
||||
static_assert((std::uint8_t(255) * m %= 256).number() == [] { std::uint8_t ui(255); return ui %= 256; }());
|
||||
static_assert((std::uint8_t(255) * m %= quantity(256)).number() == [] { std::uint8_t ui(255); return ui %= 256; }());
|
||||
// static_assert((std::uint8_t(255) * m %= 256 * m).number() != [] { std::uint8_t ui(255); return ui %= 256; }()); // UB
|
||||
static_assert((std::uint8_t(255) * m %= 257).number() == [] { std::uint8_t ui(255); return ui %= 257; }());
|
||||
static_assert((std::uint8_t(255) * m %= quantity(257)).number() == [] { std::uint8_t ui(255); return ui %= 257; }());
|
||||
static_assert((std::uint8_t(255) * m %= 256).number() == [] {
|
||||
std::uint8_t ui(255);
|
||||
return ui %= 256;
|
||||
}());
|
||||
static_assert((std::uint8_t(255) * m %= quantity(256)).number() == [] {
|
||||
std::uint8_t ui(255);
|
||||
return ui %= 256;
|
||||
}());
|
||||
// static_assert((std::uint8_t(255) * m %= 256 * m).number() != [] { std::uint8_t ui(255); return ui %= 256; }()); //
|
||||
// UB
|
||||
static_assert((std::uint8_t(255) * m %= 257).number() == [] {
|
||||
std::uint8_t ui(255);
|
||||
return ui %= 257;
|
||||
}());
|
||||
static_assert((std::uint8_t(255) * m %= quantity(257)).number() == [] {
|
||||
std::uint8_t ui(255);
|
||||
return ui %= 257;
|
||||
}());
|
||||
// TODO: Fix
|
||||
static_assert((std::uint8_t(255) * m %= 257 * m).number() != [] { std::uint8_t ui(255); return ui %= 257; }());
|
||||
static_assert((std::uint8_t(255) * m %= 257 * m).number() != [] {
|
||||
std::uint8_t ui(255);
|
||||
return ui %= 257;
|
||||
}());
|
||||
|
||||
#ifndef UNITS_COMP_MSVC // TODO ICE (https://developercommunity2.visualstudio.com/t/ICE-on-a-constexpr-operator-in-mp-unit/1302907)
|
||||
#ifndef UNITS_COMP_MSVC // TODO ICE
|
||||
// (https://developercommunity2.visualstudio.com/t/ICE-on-a-constexpr-operator-in-mp-unit/1302907)
|
||||
// next two lines trigger conversions warnings
|
||||
// (warning disabled in CMake for this file)
|
||||
static_assert((22_q_m *= 33.33).number() == 733);
|
||||
@@ -355,43 +406,44 @@ static_assert((22_q_m /= quantity(3.33)).number() == 6);
|
||||
#endif
|
||||
|
||||
template<typename Metre, typename Kilometre>
|
||||
concept invalid_compound_assignments = requires() {
|
||||
// truncating not allowed
|
||||
requires !requires(length<Metre, int> l) { l += 2.5_q_m; };
|
||||
requires !requires(length<Metre, int> l) { l -= 2.5_q_m; };
|
||||
requires !requires(length<Kilometre, int> l) { l += length<Metre, int>(2); };
|
||||
requires !requires(length<Kilometre, int> l) { l -= length<Metre, int>(2); };
|
||||
requires !requires(length<Kilometre, int> l) { l %= length<Metre, int>(2); };
|
||||
requires !requires(length<Kilometre, int> l) { l %= dimensionless<percent, int>(2); };
|
||||
requires !requires(length<Kilometre, int> l) { l %= dimensionless<percent, double>(2); };
|
||||
concept invalid_compound_assignments =
|
||||
requires() {
|
||||
// truncating not allowed
|
||||
requires !requires(length<Metre, int> l) { l += 2.5_q_m; };
|
||||
requires !requires(length<Metre, int> l) { l -= 2.5_q_m; };
|
||||
requires !requires(length<Kilometre, int> l) { l += length<Metre, int>(2); };
|
||||
requires !requires(length<Kilometre, int> l) { l -= length<Metre, int>(2); };
|
||||
requires !requires(length<Kilometre, int> l) { l %= length<Metre, int>(2); };
|
||||
requires !requires(length<Kilometre, int> l) { l %= dimensionless<percent, int>(2); };
|
||||
requires !requires(length<Kilometre, int> l) { l %= dimensionless<percent, double>(2); };
|
||||
|
||||
// TODO: accept non-truncating argument
|
||||
requires !requires(length<Kilometre, int> l) { l *= 1 * (km / m); };
|
||||
requires !requires(length<Kilometre, int> l) { l /= 1 * (km / m); };
|
||||
requires !requires(length<Kilometre, int> l) { l %= 1 * (km / m); };
|
||||
// TODO: accept non-truncating argument
|
||||
requires !requires(length<Kilometre, int> l) { l *= 1 * (km / m); };
|
||||
requires !requires(length<Kilometre, int> l) { l /= 1 * (km / m); };
|
||||
requires !requires(length<Kilometre, int> l) { l %= 1 * (km / m); };
|
||||
|
||||
// only quantities can be added or subtracted
|
||||
requires !requires(length<Metre, int> l) { l += 2; };
|
||||
requires !requires(length<Metre, int> l) { l -= 2; };
|
||||
// only quantities can be added or subtracted
|
||||
requires !requires(length<Metre, int> l) { l += 2; };
|
||||
requires !requires(length<Metre, int> l) { l -= 2; };
|
||||
|
||||
// compound multiply/divide by another quantity not allowed
|
||||
requires !requires(length<Metre, int> l) { l *= 2_q_m; };
|
||||
requires !requires(length<Metre, int> l) { l /= 2_q_m; };
|
||||
// compound multiply/divide by another quantity not allowed
|
||||
requires !requires(length<Metre, int> l) { l *= 2_q_m; };
|
||||
requires !requires(length<Metre, int> l) { l /= 2_q_m; };
|
||||
|
||||
// modulo operations on a floating point representation not allowed
|
||||
requires !requires(length<Metre, double> l) { l %= 2.; };
|
||||
requires !requires(length<Metre, double> l) { l %= 2; };
|
||||
requires !requires(length<Metre, double> l) { l %= 2._q_m; };
|
||||
requires !requires(length<Metre, double> l) { l %= 2_q_m; };
|
||||
requires !requires(length<Metre, int> l) { l %= 2._q_m; };
|
||||
// modulo operations on a floating point representation not allowed
|
||||
requires !requires(length<Metre, double> l) { l %= 2.; };
|
||||
requires !requires(length<Metre, double> l) { l %= 2; };
|
||||
requires !requires(length<Metre, double> l) { l %= 2._q_m; };
|
||||
requires !requires(length<Metre, double> l) { l %= 2_q_m; };
|
||||
requires !requires(length<Metre, int> l) { l %= 2._q_m; };
|
||||
|
||||
// no unit constants
|
||||
requires !requires(length<Metre, int> l) { l += m; };
|
||||
requires !requires(length<Metre, int> l) { l -= m; };
|
||||
requires !requires(length<Metre, int> l) { l *= m; };
|
||||
requires !requires(length<Metre, int> l) { l /= m; };
|
||||
requires !requires(length<Metre, int> l) { l %= m; };
|
||||
};
|
||||
// no unit constants
|
||||
requires !requires(length<Metre, int> l) { l += m; };
|
||||
requires !requires(length<Metre, int> l) { l -= m; };
|
||||
requires !requires(length<Metre, int> l) { l *= m; };
|
||||
requires !requires(length<Metre, int> l) { l /= m; };
|
||||
requires !requires(length<Metre, int> l) { l %= m; };
|
||||
};
|
||||
static_assert(invalid_compound_assignments<metre, kilometre>);
|
||||
|
||||
|
||||
@@ -401,26 +453,26 @@ static_assert(invalid_compound_assignments<metre, kilometre>);
|
||||
|
||||
template<typename Metre>
|
||||
concept invalid_binary_operations = requires {
|
||||
// no crossdimensional addition and subtraction
|
||||
requires !requires { 1_q_s + length<Metre, int>(1); };
|
||||
requires !requires { 1_q_s - length<Metre, int>(1); };
|
||||
// no crossdimensional addition and subtraction
|
||||
requires !requires { 1_q_s + length<Metre, int>(1); };
|
||||
requires !requires { 1_q_s - length<Metre, int>(1); };
|
||||
|
||||
// no floating-point modulo
|
||||
requires !requires(length<Metre, double> a) { a % 2_q_m; };
|
||||
requires !requires(length<Metre, double> a) { 2_q_m % a; };
|
||||
requires !requires(length<Metre, double> a) { a % 2; };
|
||||
requires !requires(length<Metre, double> a, length<Metre, double> b) { a % b; };
|
||||
requires !requires(length<Metre, double> a, length<Metre, int> b) { a % b; };
|
||||
requires !requires(length<Metre, double> a, length<Metre, int> b) { b % a; };
|
||||
// no floating-point modulo
|
||||
requires !requires(length<Metre, double> a) { a % 2_q_m; };
|
||||
requires !requires(length<Metre, double> a) { 2_q_m % a; };
|
||||
requires !requires(length<Metre, double> a) { a % 2; };
|
||||
requires !requires(length<Metre, double> a, length<Metre, double> b) { a % b; };
|
||||
requires !requires(length<Metre, double> a, length<Metre, int> b) { a % b; };
|
||||
requires !requires(length<Metre, double> a, length<Metre, int> b) { b % a; };
|
||||
|
||||
// unit constants
|
||||
requires !requires { length<Metre, int>(1) + m; };
|
||||
requires !requires { length<Metre, int>(1) - m; };
|
||||
requires !requires { length<Metre, int>(1) % m; };
|
||||
requires !requires { m + length<Metre, int>(1); };
|
||||
requires !requires { m - length<Metre, int>(1); };
|
||||
requires !requires { m % length<Metre, int>(1); };
|
||||
};
|
||||
// unit constants
|
||||
requires !requires { length<Metre, int>(1) + m; };
|
||||
requires !requires { length<Metre, int>(1) - m; };
|
||||
requires !requires { length<Metre, int>(1) % m; };
|
||||
requires !requires { m + length<Metre, int>(1); };
|
||||
requires !requires { m - length<Metre, int>(1); };
|
||||
requires !requires { m % length<Metre, int>(1); };
|
||||
};
|
||||
static_assert(invalid_binary_operations<metre>);
|
||||
|
||||
// same representation type
|
||||
@@ -443,7 +495,8 @@ static_assert(compare<decltype(1_q_m * 1_q_m), area<square_metre, std::int64_t>>
|
||||
static_assert(compare<decltype(1_q_m / 1_q_m), dimensionless<one, std::int64_t>>);
|
||||
static_assert(compare<decltype(1 / 1_q_s), frequency<hertz, std::int64_t>>);
|
||||
static_assert(compare<decltype(quantity{1} / 1_q_s), frequency<hertz, std::int64_t>>);
|
||||
static_assert(compare<decltype(dimensionless<percent, std::int64_t>(1) / 1_q_s), frequency<scaled_unit<ratio(1, 100), hertz>, std::int64_t>>);
|
||||
static_assert(compare<decltype(dimensionless<percent, std::int64_t>(1) / 1_q_s),
|
||||
frequency<scaled_unit<ratio(1, 100), hertz>, std::int64_t>>);
|
||||
|
||||
static_assert(is_same_v<decltype((std::uint8_t(0) * m + std::uint8_t(0) * m).number()), int&&>);
|
||||
static_assert(is_same_v<decltype((std::uint8_t(0) * m - std::uint8_t(0) * m).number()), int&&>);
|
||||
@@ -456,9 +509,13 @@ static_assert(is_same_v<decltype(((std::uint8_t(0) * m) % (std::uint8_t(0) * m))
|
||||
// different representation types
|
||||
static_assert(is_same_v<decltype(1_q_m + 1._q_m), length<metre, long double>>);
|
||||
static_assert(is_same_v<decltype(1_q_m - 1._q_m), length<metre, long double>>);
|
||||
static_assert(is_same_v<decltype(1_q_m * 1.L), length<metre, long double>>); // TODO should we address fundamental types implicit truncating conversions with concepts?
|
||||
static_assert(
|
||||
is_same_v<decltype(1_q_m * 1.L), length<metre, long double>>); // TODO should we address fundamental types implicit
|
||||
// truncating conversions with concepts?
|
||||
static_assert(is_same_v<decltype(1 * 1._q_m), length<metre, long double>>);
|
||||
static_assert(is_same_v<decltype(1_q_m * quantity{1.L}), length<metre, long double>>); // TODO should we address fundamental types implicit truncating conversions with concepts?
|
||||
static_assert(is_same_v<decltype(1_q_m * quantity{1.L}),
|
||||
length<metre, long double>>); // TODO should we address fundamental types implicit truncating
|
||||
// conversions with concepts?
|
||||
static_assert(is_same_v<decltype(quantity{1} * 1._q_m), length<metre, long double>>);
|
||||
static_assert(is_same_v<decltype(1_q_m / 1.L), length<metre, long double>>);
|
||||
static_assert(is_same_v<decltype(1_q_m / quantity{1.L}), length<metre, long double>>);
|
||||
@@ -469,7 +526,8 @@ static_assert(compare<decltype(1_q_m / dimensionless<percent, long double>(1)),
|
||||
static_assert(compare<decltype(1_q_m / 1._q_m), dimensionless<one, long double>>);
|
||||
static_assert(compare<decltype(1 / 1._q_s), frequency<hertz, long double>>);
|
||||
static_assert(compare<decltype(quantity{1} / 1._q_s), frequency<hertz, long double>>);
|
||||
static_assert(compare<decltype(dimensionless<percent, std::int64_t>(1) / 1._q_s), frequency<scaled_unit<ratio(1, 100), hertz>, long double>>);
|
||||
static_assert(compare<decltype(dimensionless<percent, std::int64_t>(1) / 1._q_s),
|
||||
frequency<scaled_unit<ratio(1, 100), hertz>, long double>>);
|
||||
static_assert(compare<decltype(1_q_m % short(1)), length<metre, std::int64_t>>);
|
||||
static_assert(compare<decltype(1_q_m % quantity{short(1)}), length<metre, std::int64_t>>);
|
||||
static_assert(compare<decltype(1_q_m % dimensionless<percent, short>(1)), length<metre, std::int64_t>>);
|
||||
@@ -490,7 +548,8 @@ static_assert(compare<decltype(1._q_m * 1_q_m), area<square_metre, long double>>
|
||||
static_assert(compare<decltype(1._q_m / 1_q_m), dimensionless<one, long double>>);
|
||||
static_assert(compare<decltype(1.L / 1_q_s), frequency<hertz, long double>>);
|
||||
static_assert(compare<decltype(quantity{1.L} / 1_q_s), frequency<hertz, long double>>);
|
||||
static_assert(compare<decltype(dimensionless<percent, long double>(1) / 1_q_s), frequency<scaled_unit<ratio(1, 100), hertz>, long double>>);
|
||||
static_assert(compare<decltype(dimensionless<percent, long double>(1) / 1_q_s),
|
||||
frequency<scaled_unit<ratio(1, 100), hertz>, long double>>);
|
||||
|
||||
// different units
|
||||
static_assert(is_same_v<decltype(1_q_m + 1_q_km), length<metre, std::int64_t>>);
|
||||
@@ -519,15 +578,21 @@ static_assert(is_same_v<decltype(1_q_km % 1_q_m), length<kilometre, std::int64_t
|
||||
// different dimensions
|
||||
static_assert(compare<decltype(1_q_m_per_s * 1_q_s), length<metre, std::int64_t>>);
|
||||
static_assert(compare<decltype(1_q_m_per_s * 1_q_h), length<scaled_unit<ratio(36, 1, 2), metre>, std::int64_t>>);
|
||||
static_assert(compare<decltype(1_q_m * 1_q_min), quantity<unknown_dimension<exponent<dim_length, 1>, exponent<dim_time, 1>>, scaled_unit<ratio(60), unknown_coherent_unit>, std::int64_t>>);
|
||||
static_assert(
|
||||
compare<decltype(1_q_m * 1_q_min), quantity<unknown_dimension<exponent<dim_length, 1>, exponent<dim_time, 1>>,
|
||||
scaled_unit<ratio(60), unknown_coherent_unit>, std::int64_t>>);
|
||||
static_assert(compare<decltype(1_q_s * 1_q_Hz), dimensionless<one, std::int64_t>>);
|
||||
static_assert(compare<decltype(1 / 1_q_min), frequency<scaled_unit<ratio(1, 60), hertz>, std::int64_t>>);
|
||||
static_assert(compare<decltype(1 / 1_q_Hz), isq::si::time<second, std::int64_t>>);
|
||||
static_assert(compare<decltype(1 / 1_q_km), quantity<unknown_dimension<exponent<dim_length, -1>>, scaled_unit<ratio(1, 1, -3), unknown_coherent_unit>, std::int64_t>>);
|
||||
static_assert(
|
||||
compare<decltype(1 / 1_q_km), quantity<unknown_dimension<exponent<dim_length, -1>>,
|
||||
scaled_unit<ratio(1, 1, -3), unknown_coherent_unit>, std::int64_t>>);
|
||||
static_assert(compare<decltype(1_q_km / 1_q_m), dimensionless<scaled_unit<ratio(1000), one>, std::int64_t>>);
|
||||
static_assert(compare<decltype(1_q_m / 1_q_s), speed<metre_per_second, std::int64_t>>);
|
||||
static_assert(compare<decltype(1_q_m / 1_q_min), speed<scaled_unit<ratio(1, 60), metre_per_second>, std::int64_t>>);
|
||||
static_assert(compare<decltype(1_q_min / 1_q_m), quantity<unknown_dimension<exponent<dim_length, -1>, exponent<dim_time, 1>>, scaled_unit<ratio(60), unknown_coherent_unit>, std::int64_t>>);
|
||||
static_assert(
|
||||
compare<decltype(1_q_min / 1_q_m), quantity<unknown_dimension<exponent<dim_length, -1>, exponent<dim_time, 1>>,
|
||||
scaled_unit<ratio(60), unknown_coherent_unit>, std::int64_t>>);
|
||||
|
||||
static_assert((1_q_m + 1_q_m).number() == 2);
|
||||
static_assert((1_q_m + 1_q_km).number() == 1001);
|
||||
@@ -652,9 +717,9 @@ static_assert(quantity{2} / (1 * m) == 2 / 1_q_m);
|
||||
|
||||
template<typename Metre>
|
||||
concept no_crossdimensional_equality = requires {
|
||||
requires !requires { 1_q_s == length<Metre, int>(1); };
|
||||
requires !requires { 1_q_s != length<Metre, int>(1); };
|
||||
};
|
||||
requires !requires { 1_q_s == length<Metre, int>(1); };
|
||||
requires !requires { 1_q_s != length<Metre, int>(1); };
|
||||
};
|
||||
static_assert(no_crossdimensional_equality<metre>);
|
||||
|
||||
// same type
|
||||
@@ -688,11 +753,11 @@ static_assert(123 != quantity{321});
|
||||
|
||||
template<typename Metre>
|
||||
concept no_crossdimensional_ordering = requires {
|
||||
requires !requires { 1_q_s < length<Metre, int>(1); };
|
||||
requires !requires { 1_q_s > length<Metre, int>(1); };
|
||||
requires !requires { 1_q_s <= length<Metre, int>(1); };
|
||||
requires !requires { 1_q_s >= length<Metre, int>(1); };
|
||||
};
|
||||
requires !requires { 1_q_s < length<Metre, int>(1); };
|
||||
requires !requires { 1_q_s > length<Metre, int>(1); };
|
||||
requires !requires { 1_q_s <= length<Metre, int>(1); };
|
||||
requires !requires { 1_q_s >= length<Metre, int>(1); };
|
||||
};
|
||||
static_assert(no_crossdimensional_ordering<metre>);
|
||||
|
||||
// same type
|
||||
@@ -764,9 +829,9 @@ static_assert(!std::equality_comparable_with<dimensionless<one, int>, double>);
|
||||
|
||||
template<typename Int>
|
||||
concept invalid_dimensionless_operations = requires {
|
||||
requires !requires(dimensionless<percent, Int> d) { 1 + d; };
|
||||
requires !requires(dimensionless<percent, Int> d) { d + 1; };
|
||||
};
|
||||
requires !requires(dimensionless<percent, Int> d) { 1 + d; };
|
||||
requires !requires(dimensionless<percent, Int> d) { d + 1; };
|
||||
};
|
||||
static_assert(invalid_dimensionless_operations<int>);
|
||||
|
||||
static_assert(compare<decltype(10_q_km / 5_q_km), quantity<dim_one, one, std::int64_t>>);
|
||||
@@ -815,7 +880,9 @@ static_assert(!is_same_v<decltype(quantity_cast<litre>(2_q_dm3)), volume<cubic_d
|
||||
|
||||
#if UNITS_DOWNCAST_MODE == 0
|
||||
|
||||
static_assert(is_same_v<decltype(10_q_m / 5_q_s), quantity<unknown_dimension<units::exponent<dim_length, 1>, units::exponent<dim_time, -1>>, scaled_unit<ratio(1), unknown_coherent_unit>, std::int64_t>>);
|
||||
static_assert(is_same_v<decltype(10_q_m / 5_q_s),
|
||||
quantity<unknown_dimension<units::exponent<dim_length, 1>, units::exponent<dim_time, -1>>,
|
||||
scaled_unit<ratio(1), unknown_coherent_unit>, std::int64_t>>);
|
||||
static_assert(is_same_v<decltype(1_q_mm + 1_q_km), length<scaled_unit<ratio(1, 1, -3), metre>, std::int64_t>>);
|
||||
|
||||
#else
|
||||
@@ -846,6 +913,7 @@ static_assert(same(quotient_remainder_theorem(3'000 * m, 400), 3'000 * m));
|
||||
static_assert(same(quotient_remainder_theorem(3'000 * m, quantity(400)), 3'000 * m));
|
||||
static_assert(same(quotient_remainder_theorem(3 * km, quantity(400)), 3 * km));
|
||||
static_assert(same(quotient_remainder_theorem(3 * km, quantity(2)), 3 * km));
|
||||
static_assert(same(quotient_remainder_theorem(3 * km, dimensionless<scaled_unit<ratio(1, 1000), one>, int>(400)), 3 * km));
|
||||
static_assert(same(quotient_remainder_theorem(3 * km, dimensionless<scaled_unit<ratio(1, 1000), one>, int>(400)),
|
||||
3 * km));
|
||||
|
||||
} // namespace
|
||||
|
||||
@@ -45,7 +45,7 @@ static_assert(-ratio(3, 8) == ratio(-3, 8));
|
||||
|
||||
// ratio addition
|
||||
static_assert(ratio(1, 2) + ratio(1, 3) == ratio(5, 6));
|
||||
static_assert(ratio(1, 3, 2) + ratio(11, 6) == ratio(211, 6)); // 100/3 + 11/6
|
||||
static_assert(ratio(1, 3, 2) + ratio(11, 6) == ratio(211, 6)); // 100/3 + 11/6
|
||||
|
||||
// multiply with exponents
|
||||
static_assert(ratio(1, 8, 2) * ratio(2, 1, 4) == ratio(1, 4, 6));
|
||||
|
||||
@@ -36,24 +36,24 @@ static_assert(2 * m == 2_q_m);
|
||||
static_assert(2 * s == 2_q_s);
|
||||
template<auto& s>
|
||||
concept invalid_operations = requires {
|
||||
requires !requires { 2 / s; };
|
||||
requires !requires { s / 2; };
|
||||
requires !requires { s * 2; };
|
||||
requires !requires { s + 2; };
|
||||
requires !requires { 2 + s; };
|
||||
requires !requires { s + s; };
|
||||
requires !requires { s - 2; };
|
||||
requires !requires { 2 - s; };
|
||||
requires !requires { s - s; };
|
||||
requires !requires { s + 1_q_s; };
|
||||
requires !requires { s - 1_q_s; };
|
||||
requires !requires { s * 1_q_s; };
|
||||
requires !requires { s / 1_q_s; };
|
||||
requires !requires { 1_q_s + s; };
|
||||
requires !requires { 1_q_s - s; };
|
||||
requires !requires { 1_q_s * s; };
|
||||
requires !requires { 1_q_s / s; };
|
||||
};
|
||||
requires !requires { 2 / s; };
|
||||
requires !requires { s / 2; };
|
||||
requires !requires { s * 2; };
|
||||
requires !requires { s + 2; };
|
||||
requires !requires { 2 + s; };
|
||||
requires !requires { s + s; };
|
||||
requires !requires { s - 2; };
|
||||
requires !requires { 2 - s; };
|
||||
requires !requires { s - s; };
|
||||
requires !requires { s + 1_q_s; };
|
||||
requires !requires { s - 1_q_s; };
|
||||
requires !requires { s * 1_q_s; };
|
||||
requires !requires { s / 1_q_s; };
|
||||
requires !requires { 1_q_s + s; };
|
||||
requires !requires { 1_q_s - s; };
|
||||
requires !requires { 1_q_s * s; };
|
||||
requires !requires { 1_q_s / s; };
|
||||
};
|
||||
static_assert(invalid_operations<s>);
|
||||
|
||||
static_assert(2_q_m / (1 * s) == 2_q_m_per_s);
|
||||
@@ -77,7 +77,8 @@ static_assert(1. / 4 * m2 == 1._q_m2 / 4);
|
||||
|
||||
UNITS_DIAGNOSTIC_PUSH
|
||||
UNITS_DIAGNOSTIC_IGNORE_SHADOW
|
||||
constexpr bool test_hiding() {
|
||||
constexpr bool test_hiding()
|
||||
{
|
||||
Speed auto v0 = 10 * (m / s);
|
||||
signed s = 2; // hides ^
|
||||
Length auto v = 20 * m / s;
|
||||
|
||||
@@ -21,16 +21,16 @@
|
||||
// SOFTWARE.
|
||||
|
||||
#include <units/isq/si/acceleration.h>
|
||||
#include <units/isq/si/area.h> // IWYU pragma: keep
|
||||
#include <units/isq/si/area.h> // IWYU pragma: keep
|
||||
#include <units/isq/si/cgs/cgs.h>
|
||||
#include <units/isq/si/energy.h>
|
||||
#include <units/isq/si/force.h>
|
||||
#include <units/isq/si/length.h> // IWYU pragma: keep
|
||||
#include <units/isq/si/length.h> // IWYU pragma: keep
|
||||
#include <units/isq/si/mass.h>
|
||||
#include <units/isq/si/power.h>
|
||||
#include <units/isq/si/pressure.h>
|
||||
#include <units/isq/si/speed.h>
|
||||
#include <units/isq/si/time.h> // IWYU pragma: keep
|
||||
#include <units/isq/si/time.h> // IWYU pragma: keep
|
||||
|
||||
namespace {
|
||||
|
||||
@@ -40,8 +40,10 @@ static_assert(units::detail::quantity_ratio<si::length<si::metre>> == units::rat
|
||||
static_assert(units::detail::quantity_ratio<si::cgs::length<si::cgs::centimetre>> == units::ratio(1, 100));
|
||||
static_assert(units::detail::quantity_ratio<si::speed<si::metre_per_second>> == units::ratio(1));
|
||||
static_assert(units::detail::quantity_ratio<si::cgs::speed<si::cgs::centimetre_per_second>> == units::ratio(1, 100));
|
||||
static_assert(units::detail::quantity_ratio<si::force<si::newton>> == units::ratio(1000)); // defined in terms of kilogram that are 1000 * gram
|
||||
static_assert(units::detail::quantity_ratio<si::cgs::force<si::cgs::dyne>> == units::ratio(1, 100)); // defined in terms of gram so only centimetre ratio counts here
|
||||
static_assert(units::detail::quantity_ratio<si::force<si::newton>> ==
|
||||
units::ratio(1000)); // defined in terms of kilogram that are 1000 * gram
|
||||
static_assert(units::detail::quantity_ratio<si::cgs::force<si::cgs::dyne>> ==
|
||||
units::ratio(1, 100)); // defined in terms of gram so only centimetre ratio counts here
|
||||
|
||||
static_assert(si::cgs::length<si::cgs::centimetre>(100) == si::length<si::metre>(1));
|
||||
static_assert(si::cgs::mass<si::cgs::gram>(1'000) == si::mass<si::kilogram>(1));
|
||||
@@ -68,7 +70,7 @@ static_assert(si::cgs::energy<si::cgs::erg>(10'000'000) == 1_q_J);
|
||||
static_assert(si::cgs::power<si::cgs::erg_per_second>(10'000'000) == 1_q_W);
|
||||
static_assert(si::cgs::pressure<si::cgs::barye>(10) == 1_q_Pa);
|
||||
|
||||
}
|
||||
} // namespace si_test
|
||||
|
||||
namespace cgs_test {
|
||||
|
||||
@@ -84,7 +86,7 @@ static_assert(10'000'000_q_erg == si::energy<si::joule>(1));
|
||||
static_assert(10'000'000_q_erg_per_s == si::power<si::watt>(1));
|
||||
static_assert(10_q_Ba == si::pressure<si::pascal>(1));
|
||||
|
||||
}
|
||||
} // namespace cgs_test
|
||||
|
||||
namespace both_test {
|
||||
|
||||
@@ -101,7 +103,7 @@ static_assert(10'000'000_q_erg == 1_q_J);
|
||||
static_assert(10'000'000_q_erg_per_s == 1_q_W);
|
||||
static_assert(10_q_Ba == quantity_cast<double>(1_q_Pa));
|
||||
|
||||
}
|
||||
} // namespace both_test
|
||||
|
||||
namespace cgs_test {
|
||||
|
||||
@@ -125,24 +127,29 @@ static_assert(quantity_cast<si::cgs::length<si::cgs::centimetre>>(si::length<si:
|
||||
|
||||
// multiplication
|
||||
|
||||
// static_assert(200_q_cm * si::length<si::metre>(2) == si::area<si::square_metre>(4)); // TODO Add support for comparing of an unknown_dimension
|
||||
// static_assert(200_q_cm * si::length<si::metre>(2) == si::area<si::square_metre>(4)); // TODO Add support for
|
||||
// comparing of an unknown_dimension
|
||||
|
||||
static_assert(quantity_cast<si::dim_length>(200._q_cm) * si::length<si::metre>(2) == si::area<si::square_metre>(4));
|
||||
static_assert(200._q_cm * quantity_cast<si::cgs::dim_length>(si::length<si::metre>(2)) == 40'000_q_cm2);
|
||||
|
||||
// TODO Add support for quantity_cast on an unknown_dimension?
|
||||
// static_assert(quantity_cast<si::area<si::square_metre>>(200_q_cm * si::length<si::metre>(2)) == si::area<si::square_metre>(4));
|
||||
// static_assert(quantity_cast<si::dim_area>(200_q_cm * si::length<si::metre>(2)) == si::area<si::square_metre>(4));
|
||||
// static_assert(quantity_cast<si::cgs::area<si::cgs::square_centimeters>>(200_q_cm * si::length<si::metre>(2)) == 40'000_q_cm2);
|
||||
// static_assert(quantity_cast<si::cgs::dim_area>(200_q_cm * si::length<si::metre>(2)) == 40'000_q_cm2);
|
||||
// static_assert(quantity_cast<si::area<si::square_metre>>(200_q_cm * si::length<si::metre>(2)) ==
|
||||
// si::area<si::square_metre>(4)); static_assert(quantity_cast<si::dim_area>(200_q_cm * si::length<si::metre>(2)) ==
|
||||
// si::area<si::square_metre>(4)); static_assert(quantity_cast<si::cgs::area<si::cgs::square_centimeters>>(200_q_cm *
|
||||
// si::length<si::metre>(2)) == 40'000_q_cm2); static_assert(quantity_cast<si::cgs::dim_area>(200_q_cm *
|
||||
// si::length<si::metre>(2)) == 40'000_q_cm2);
|
||||
|
||||
// division
|
||||
|
||||
// static_assert(si::area<si::square_metre>(4) / 200_q_cm == si::length<si::metre>(2)); // TODO Add support for comparing of an unknown_dimension
|
||||
// static_assert(si::area<si::square_metre>(4) / 200_q_cm == si::length<si::metre>(2)); // TODO Add support for
|
||||
// comparing of an unknown_dimension
|
||||
|
||||
static_assert(si::area<si::square_metre>(4) / quantity_cast<si::length<si::metre>>(200_q_cm) == si::length<si::metre>(2));
|
||||
static_assert(quantity_cast<si::cgs::area<si::cgs::square_centimetre>>(si::area<si::square_metre>(4)) / 200._q_cm == 200_q_cm);
|
||||
static_assert(si::area<si::square_metre>(4) / quantity_cast<si::length<si::metre>>(200_q_cm) ==
|
||||
si::length<si::metre>(2));
|
||||
static_assert(quantity_cast<si::cgs::area<si::cgs::square_centimetre>>(si::area<si::square_metre>(4)) / 200._q_cm ==
|
||||
200_q_cm);
|
||||
|
||||
}
|
||||
} // namespace cgs_test
|
||||
|
||||
}
|
||||
} // namespace
|
||||
|
||||
@@ -41,7 +41,8 @@ static_assert(si::fps::mass<si::fps::pound>(1) == si::mass<si::kilogram>(0.45359
|
||||
static_assert(si::fps::time<si::fps::second>(1) == si::time<si::second>(1));
|
||||
static_assert(si::fps::speed<si::fps::foot_per_second>(1) == si::speed<si::metre_per_second>(0.3048));
|
||||
static_assert(si::fps::area<si::fps::square_foot>(1) == si::area<si::square_metre>(0.09290304));
|
||||
static_assert(si::fps::acceleration<si::fps::foot_per_second_sq>(1) == si::acceleration<si::metre_per_second_sq>(0.3048));
|
||||
static_assert(si::fps::acceleration<si::fps::foot_per_second_sq>(1) ==
|
||||
si::acceleration<si::metre_per_second_sq>(0.3048));
|
||||
static_assert(si::fps::force<si::fps::poundal>(1) > si::force<si::newton>(0.138254) &&
|
||||
si::fps::force<si::fps::poundal>(1) < si::force<si::newton>(0.138256));
|
||||
static_assert(si::fps::energy<si::fps::foot_poundal>(1) > si::energy<si::joule>(0.042140110093804) &&
|
||||
@@ -61,15 +62,14 @@ static_assert(si::fps::time<si::fps::second>(1) == 1_q_s);
|
||||
static_assert(si::fps::speed<si::fps::foot_per_second>(1) == 0.3048_q_m_per_s);
|
||||
static_assert(si::fps::area<si::fps::square_foot>(1) == 0.09290304_q_m2);
|
||||
static_assert(si::fps::acceleration<si::fps::foot_per_second_sq>(1) == 0.3048_q_m_per_s2);
|
||||
static_assert(si::fps::force<si::fps::poundal>(1) > 0.138254_q_N &&
|
||||
si::fps::force<si::fps::poundal>(1) < 0.138256_q_N);
|
||||
static_assert(si::fps::force<si::fps::poundal>(1) > 0.138254_q_N && si::fps::force<si::fps::poundal>(1) < 0.138256_q_N);
|
||||
static_assert(si::fps::energy<si::fps::foot_poundal>(1) > 0.042140110093804_q_J &&
|
||||
si::fps::energy<si::fps::foot_poundal>(1) < 0.042140110093806_q_J);
|
||||
static_assert(si::fps::power<si::fps::foot_poundal_per_second>(1) > 0.042140110093804_q_W &&
|
||||
si::fps::power<si::fps::foot_poundal_per_second>(1) < 0.042140110093806_q_W);
|
||||
static_assert(si::fps::pressure<si::fps::poundal_per_foot_sq>(1) > 1.4881639435_q_Pa &&
|
||||
si::fps::pressure<si::fps::poundal_per_foot_sq>(1) < 1.4881639437_q_Pa);
|
||||
}
|
||||
static_assert(si::fps::pressure<si::fps::poundal_per_foot_sq>(1) > 1.4881639435_q_Pa &&
|
||||
si::fps::pressure<si::fps::poundal_per_foot_sq>(1) < 1.4881639437_q_Pa);
|
||||
} // namespace si_literals
|
||||
|
||||
namespace fps_literals {
|
||||
|
||||
@@ -82,15 +82,14 @@ static_assert(1_q_s == si::time<si::second>(1));
|
||||
static_assert(1_q_ft_per_s == si::speed<si::metre_per_second>(0.3048));
|
||||
static_assert(1_q_ft2 == si::area<si::square_metre>(0.09290304));
|
||||
static_assert(1_q_ft_per_s2 == si::acceleration<si::metre_per_second_sq>(0.3048));
|
||||
static_assert(1_q_pdl > si::force<si::newton>(0.138254) &&
|
||||
1_q_pdl < si::force<si::newton>(0.138256));
|
||||
static_assert(1_q_pdl > si::force<si::newton>(0.138254) && 1_q_pdl < si::force<si::newton>(0.138256));
|
||||
static_assert(1_q_ft_pdl > si::energy<si::joule>(0.042140110093804) &&
|
||||
1_q_ft_pdl < si::energy<si::joule>(0.042140110093806));
|
||||
static_assert(1_q_ft_pdl_per_s > si::power<si::watt>(0.042140110093804) &&
|
||||
1_q_ft_pdl_per_s < si::power<si::watt>(0.042140110093806));
|
||||
static_assert(1_q_pdl_per_ft2> si::pressure<si::pascal>(1.4881639435) &&
|
||||
static_assert(1_q_pdl_per_ft2 > si::pressure<si::pascal>(1.4881639435) &&
|
||||
1_q_pdl_per_ft2 < si::pressure<si::pascal>(1.4881639437));
|
||||
}
|
||||
} // namespace fps_literals
|
||||
|
||||
namespace fps_plus_si_literals {
|
||||
|
||||
@@ -102,20 +101,16 @@ using namespace units::isq::si::fps::references;
|
||||
// static_assert(1'000_q_g == 1_q_kg); // ambiguous
|
||||
static_assert(1 * ft == 0.3048_q_m);
|
||||
static_assert(1_q_lb == 0.45359237_q_kg);
|
||||
static_assert(1_q_s == 1_q_s);
|
||||
static_assert(1_q_s == 1_q_s);
|
||||
static_assert(1_q_ft_per_s == 0.3048_q_m_per_s);
|
||||
static_assert(1_q_ft2 == 0.09290304_q_m2);
|
||||
static_assert(1_q_ft_per_s2 == 0.3048_q_m_per_s2);
|
||||
static_assert(1_q_pdl > 0.138254_q_N &&
|
||||
1_q_pdl < 0.138256_q_N);
|
||||
static_assert(1_q_ft_pdl > 0.042140110093804_q_J &&
|
||||
1_q_ft_pdl < 0.042140110093806_q_J);
|
||||
static_assert(1_q_ft_pdl_per_s > 0.042140110093804_q_W &&
|
||||
1_q_ft_pdl_per_s < 0.042140110093806_q_W);
|
||||
static_assert(1_q_pdl_per_ft2> 1.4881639435_q_Pa &&
|
||||
1_q_pdl_per_ft2 <1.4881639437_q_Pa);
|
||||
static_assert(1_q_pdl > 0.138254_q_N && 1_q_pdl < 0.138256_q_N);
|
||||
static_assert(1_q_ft_pdl > 0.042140110093804_q_J && 1_q_ft_pdl < 0.042140110093806_q_J);
|
||||
static_assert(1_q_ft_pdl_per_s > 0.042140110093804_q_W && 1_q_ft_pdl_per_s < 0.042140110093806_q_W);
|
||||
static_assert(1_q_pdl_per_ft2 > 1.4881639435_q_Pa && 1_q_pdl_per_ft2 < 1.4881639437_q_Pa);
|
||||
|
||||
}
|
||||
} // namespace fps_plus_si_literals
|
||||
|
||||
namespace fps_test {
|
||||
|
||||
@@ -126,34 +121,49 @@ using namespace units::isq::si::fps::references;
|
||||
|
||||
static_assert(si::length<si::metre>(1) + 1 * ft == si::length<si::metre>(1.3048));
|
||||
static_assert(1 * ft + si::length<si::metre>(1) == si::length<si::metre>(1.3048));
|
||||
static_assert(quantity_cast<si::length<si::metre>>(1. * ft / 0.3048) + si::length<si::metre>(1) == si::length<si::metre>(2)); // 1 m in ft + 1 m
|
||||
static_assert(si::length<si::metre>(1) + quantity_cast<si::length<si::metre>>(1. * ft / 0.3048) == si::length<si::metre>(2)); // 1 m + 1 m in ft
|
||||
static_assert(1 * ft + quantity_cast<si::fps::length<si::fps::foot>>(si::length<si::metre>(0.3048)) == 2 * ft); // 1 ft + 1 ft in m
|
||||
static_assert(quantity_cast<si::fps::length<si::fps::foot>>(si::length<si::metre>(0.3048)) + 1 * ft == 2 * ft); // 1 ft in m + 1 ft
|
||||
static_assert(quantity_cast<si::length<si::metre>>(1. * ft / 0.3048) + si::length<si::metre>(1) ==
|
||||
si::length<si::metre>(2)); // 1 m in ft + 1 m
|
||||
static_assert(si::length<si::metre>(1) + quantity_cast<si::length<si::metre>>(1. * ft / 0.3048) ==
|
||||
si::length<si::metre>(2)); // 1 m + 1 m in ft
|
||||
static_assert(1 * ft + quantity_cast<si::fps::length<si::fps::foot>>(si::length<si::metre>(0.3048)) ==
|
||||
2 * ft); // 1 ft + 1 ft in m
|
||||
static_assert(quantity_cast<si::fps::length<si::fps::foot>>(si::length<si::metre>(0.3048)) + 1 * ft ==
|
||||
2 * ft); // 1 ft in m + 1 ft
|
||||
|
||||
// substraction
|
||||
|
||||
static_assert(1 * ft - si::length<si::metre>(1) == -si::length<si::metre>(0.6952));
|
||||
static_assert(si::length<si::metre>(1) - 1 * ft == si::length<si::metre>(0.6952));
|
||||
static_assert(quantity_cast<si::length<si::metre>>(6. * ft) - si::length<si::metre>(1) > si::length<si::metre>(0.8287) &&
|
||||
quantity_cast<si::length<si::metre>>(6. * ft) - si::length<si::metre>(1) < si::length<si::metre>(0.8289)); // 6 ft in m - 1 m = ... m
|
||||
static_assert(si::length<si::metre>(5) - quantity_cast<si::length<si::metre>>(6 * ft) == si::length<si::metre>(3.1712)); // 5 m - 6 ft in m = ...
|
||||
static_assert(6. * ft - quantity_cast<si::fps::length<si::fps::foot>>(si::length<si::metre>(0.3048)) == 5. * ft); // 6 ft - 1 ft in m = 5 ft
|
||||
static_assert(quantity_cast<si::fps::length<si::fps::foot>>(si::length<si::metre>(1.8288)) - 1. * ft == 5. * ft); // 6 ft in m - 1 ft = 5 ft
|
||||
static_assert(quantity_cast<si::length<si::metre>>(6. * ft) - si::length<si::metre>(1) >
|
||||
si::length<si::metre>(0.8287) &&
|
||||
quantity_cast<si::length<si::metre>>(6. * ft) - si::length<si::metre>(1) <
|
||||
si::length<si::metre>(0.8289)); // 6 ft in m - 1 m = ... m
|
||||
static_assert(si::length<si::metre>(5) - quantity_cast<si::length<si::metre>>(6 * ft) ==
|
||||
si::length<si::metre>(3.1712)); // 5 m - 6 ft in m = ...
|
||||
static_assert(6. * ft - quantity_cast<si::fps::length<si::fps::foot>>(si::length<si::metre>(0.3048)) ==
|
||||
5. * ft); // 6 ft - 1 ft in m = 5 ft
|
||||
static_assert(quantity_cast<si::fps::length<si::fps::foot>>(si::length<si::metre>(1.8288)) - 1. * ft ==
|
||||
5. * ft); // 6 ft in m - 1 ft = 5 ft
|
||||
|
||||
// multiplication
|
||||
|
||||
// static_assert(2 * ft * si::length<si::metre>(2) == si::area<si::square_metre>(1.2192)); // TODO Add support for comparing of an unknown_dimension
|
||||
static_assert(quantity_cast<si::length<si::metre>>(2. * ft) * si::length<si::metre>(2) == si::area<si::square_metre>(1.2192));
|
||||
static_assert(quantity_cast<si::length<si::metre>>(2. * ft) * si::length<si::metre>(0.6096) == si::area<si::square_metre>(0.371612160)); // 2 ft * 2 ft == 4 sq ft
|
||||
// static_assert(2 * ft * si::length<si::metre>(2) == si::area<si::square_metre>(1.2192)); // TODO Add support for
|
||||
// comparing of an unknown_dimension
|
||||
static_assert(quantity_cast<si::length<si::metre>>(2. * ft) * si::length<si::metre>(2) ==
|
||||
si::area<si::square_metre>(1.2192));
|
||||
static_assert(quantity_cast<si::length<si::metre>>(2. * ft) * si::length<si::metre>(0.6096) ==
|
||||
si::area<si::square_metre>(0.371612160)); // 2 ft * 2 ft == 4 sq ft
|
||||
static_assert(2. * ft * quantity_cast<si::fps::length<si::fps::foot>>(si::length<si::metre>(0.6096)) == 4._q_ft2);
|
||||
|
||||
// division
|
||||
|
||||
// static_assert(si::area<si::square_metre>(4) / 200_q_cm == si::length<si::metre>(2)); // TODO Add support for comparing of an unknown_dimension
|
||||
static_assert(si::area<si::square_metre>(1.48644864) / quantity_cast<si::length<si::metre>>(4 * ft) == si::length<si::metre>(1.2192)); // 16 ft2 / 4 ft = 4 ft
|
||||
static_assert(quantity_cast<si::fps::area<si::fps::square_foot>>(si::area<si::square_metre>(1.48644864)) / (4. * ft) == 4. * ft); // 16 ft2 / 4 ft = 4 ft
|
||||
// static_assert(si::area<si::square_metre>(4) / 200_q_cm == si::length<si::metre>(2)); // TODO Add support for
|
||||
// comparing of an unknown_dimension
|
||||
static_assert(si::area<si::square_metre>(1.48644864) / quantity_cast<si::length<si::metre>>(4 * ft) ==
|
||||
si::length<si::metre>(1.2192)); // 16 ft2 / 4 ft = 4 ft
|
||||
static_assert(quantity_cast<si::fps::area<si::fps::square_foot>>(si::area<si::square_metre>(1.48644864)) / (4. * ft) ==
|
||||
4. * ft); // 16 ft2 / 4 ft = 4 ft
|
||||
|
||||
}
|
||||
} // namespace fps_test
|
||||
|
||||
}
|
||||
} // namespace
|
||||
|
||||
@@ -23,9 +23,9 @@
|
||||
#include <units/isq/si/area.h>
|
||||
#include <units/isq/si/hep/area.h>
|
||||
#include <units/isq/si/hep/energy.h>
|
||||
#include <units/isq/si/length.h>
|
||||
#include <units/isq/si/hep/mass.h>
|
||||
#include <units/isq/si/hep/momentum.h>
|
||||
#include <units/isq/si/length.h>
|
||||
|
||||
namespace {
|
||||
|
||||
@@ -45,7 +45,8 @@ static_assert(si::momentum<si::hep::eV_per_c>(1'000'000) == si::hep::momentum<si
|
||||
|
||||
// area
|
||||
static_assert(si::area<si::hep::barn>(1e28) == si::area<si::square_metre>(1));
|
||||
//static_assert(si::area<si::hep::barn>(1) == si::area<si::square_metre>(1e-28)); // numeric rounding issues on some platforms
|
||||
// static_assert(si::area<si::hep::barn>(1) == si::area<si::square_metre>(1e-28)); // numeric rounding issues on some
|
||||
// platforms
|
||||
|
||||
|
||||
namespace hep_literal_test {
|
||||
@@ -62,9 +63,10 @@ static_assert(si::hep::momentum<si::hep::eV_per_c>(1'000) == 1_q_keV_per_c);
|
||||
static_assert(si::hep::momentum<si::hep::eV_per_c>(1'000'000) == 1_q_MeV_per_c);
|
||||
|
||||
// static_assert(si::area<si::square_metre, long double>(1e-28L) == 1_q_b); // numeric rounding issues on some platforms
|
||||
//static_assert(si::hep::area<si::square_yoctometre, long double>(1e-4L) == 1_q_b); // numeric rounding issues on some platforms
|
||||
// static_assert(si::hep::area<si::square_yoctometre, long double>(1e-4L) == 1_q_b); // numeric rounding issues on some
|
||||
// platforms
|
||||
static_assert(si::area<si::square_metre>(1e-43) == 1_q_fb);
|
||||
|
||||
}
|
||||
} // namespace hep_literal_test
|
||||
|
||||
}
|
||||
} // namespace
|
||||
|
||||
@@ -334,16 +334,18 @@ static_assert(1_q_J_per_K * 1_q_K == 1_q_s * 1_q_N * 1_q_m_per_s);
|
||||
static_assert(1_q_J_per_mol_K == 1_q_J_per_K / 1_q_mol);
|
||||
|
||||
static_assert(detail::unit_text<dim_heat_capacity, joule_per_kelvin>() == "J/K");
|
||||
static_assert(detail::unit_text<dim_specific_heat_capacity, joule_per_kilogram_kelvin>() == basic_symbol_text("J ⋅ K⁻¹ ⋅ kg⁻¹", "J K^-1 kg^-1"));
|
||||
static_assert(detail::unit_text<dim_specific_heat_capacity, joule_per_kilogram_kelvin>() ==
|
||||
basic_symbol_text("J ⋅ K⁻¹ ⋅ kg⁻¹", "J K^-1 kg^-1"));
|
||||
|
||||
// thermal conductivity
|
||||
|
||||
static_assert(20_q_W_per_m_K * 10_q_m * 300_q_K == 60'000_q_W);
|
||||
static_assert(detail::unit_text<dim_thermal_conductivity, watt_per_metre_kelvin>() == basic_symbol_text("W ⋅ m⁻¹ ⋅ K⁻¹", "W m^-1 K^-1"));
|
||||
static_assert(detail::unit_text<dim_thermal_conductivity, watt_per_metre_kelvin>() ==
|
||||
basic_symbol_text("W ⋅ m⁻¹ ⋅ K⁻¹", "W m^-1 K^-1"));
|
||||
|
||||
// electric field strength
|
||||
|
||||
static_assert(100_q_N/20_q_C == 5_q_V_per_m);
|
||||
static_assert(100_q_N / 20_q_C == 5_q_V_per_m);
|
||||
static_assert(1_q_C * 10_q_V_per_m * 3_q_m == 30_q_J);
|
||||
|
||||
static_assert(detail::unit_text<dim_electric_field_strength, volt_per_metre>() == "V/m");
|
||||
@@ -358,12 +360,13 @@ static_assert(1_q_C_per_m2 == 1_q_C_per_m3 * 1_q_m);
|
||||
static_assert(1_q_V_per_m * 10_q_C_per_m3 * 1_q_m3 == 10_q_N);
|
||||
|
||||
static_assert(detail::unit_text<dim_charge_density, coulomb_per_metre_cub>() == basic_symbol_text("C/m³", "C/m^3"));
|
||||
static_assert(detail::unit_text<dim_surface_charge_density, coulomb_per_metre_sq>() == basic_symbol_text("C/m²", "C/m^2"));
|
||||
static_assert(detail::unit_text<dim_surface_charge_density, coulomb_per_metre_sq>() ==
|
||||
basic_symbol_text("C/m²", "C/m^2"));
|
||||
|
||||
// permittivity
|
||||
|
||||
static_assert(1_q_F_per_m == 1_q_F / 1_q_m);
|
||||
static_assert(1/(1_q_F_per_m) * 1_q_C * 1_q_C / 1_q_m2 == 1_q_N);
|
||||
static_assert(1 / (1_q_F_per_m) * 1_q_C * 1_q_C / 1_q_m2 == 1_q_N);
|
||||
static_assert(1_q_C_per_m3 / 1_q_F_per_m * 1_q_m == 1_q_V_per_m);
|
||||
|
||||
static_assert(detail::unit_text<dim_permittivity, farad_per_metre>() == "F/m");
|
||||
|
||||
@@ -92,4 +92,4 @@ static_assert(sym6 + basic_fixed_string("f") == basic_symbol_text("bcf", "def"))
|
||||
static_assert("a" + sym6 == basic_symbol_text("abc", "ade"));
|
||||
static_assert(sym6 + "f" == basic_symbol_text("bcf", "def"));
|
||||
|
||||
}
|
||||
} // namespace
|
||||
|
||||
@@ -50,8 +50,10 @@ static_assert(is_same_v<type_list_join<type_list<>, type_list<>, type_list<>>, t
|
||||
static_assert(is_same_v<type_list_join<type_list<int>, type_list<>, type_list<>>, type_list<int>>);
|
||||
static_assert(is_same_v<type_list_join<type_list<>, type_list<int>, type_list<>>, type_list<int>>);
|
||||
static_assert(is_same_v<type_list_join<type_list<>, type_list<>, type_list<int>>, type_list<int>>);
|
||||
static_assert(is_same_v<type_list_join<type_list<int>, type_list<float>, type_list<bool>>, type_list<int, float, bool>>);
|
||||
static_assert(is_same_v<type_list_join<type_list<int, short>, type_list<float, double>, type_list<bool>>, type_list<int, short, float, double, bool>>);
|
||||
static_assert(
|
||||
is_same_v<type_list_join<type_list<int>, type_list<float>, type_list<bool>>, type_list<int, float, bool>>);
|
||||
static_assert(is_same_v<type_list_join<type_list<int, short>, type_list<float, double>, type_list<bool>>,
|
||||
type_list<int, short, float, double, bool>>);
|
||||
|
||||
// type_list_split
|
||||
|
||||
@@ -87,10 +89,9 @@ static_assert(is_same_v<type_list_split_half<type_list<int, long>>::second_list,
|
||||
static_assert(is_same_v<type_list_split_half<type_list<int, long, double>>::first_list, type_list<int, long>>);
|
||||
static_assert(is_same_v<type_list_split_half<type_list<int, long, double>>::second_list, type_list<double>>);
|
||||
|
||||
static_assert(is_same_v<type_list_split_half<type_list<int, long, double, float>>::first_list, type_list<int, long>>);
|
||||
static_assert(
|
||||
is_same_v<type_list_split_half<type_list<int, long, double, float>>::first_list, type_list<int, long>>);
|
||||
static_assert(
|
||||
is_same_v<type_list_split_half<type_list<int, long, double, float>>::second_list, type_list<double, float>>);
|
||||
is_same_v<type_list_split_half<type_list<int, long, double, float>>::second_list, type_list<double, float>>);
|
||||
|
||||
// type_list_merge_sorted
|
||||
struct u0 : named_unit<u0, "u0", no_prefix> {};
|
||||
@@ -98,10 +99,12 @@ struct d0 : base_dimension<"d0", u0> {};
|
||||
struct u1 : named_unit<u1, "u1", no_prefix> {};
|
||||
struct d1 : base_dimension<"d1", u1> {};
|
||||
|
||||
static_assert(is_same_v<type_list_merge_sorted<type_list<units::exponent<d0, 1>>, type_list<units::exponent<d1, 1>>, exponent_less>,
|
||||
type_list<units::exponent<d0, 1>, units::exponent<d1, 1>>>);
|
||||
static_assert(is_same_v<type_list_merge_sorted<type_list<units::exponent<d1, 1>>, type_list<units::exponent<d0, 1>>, exponent_less>,
|
||||
type_list<units::exponent<d0, 1>, units::exponent<d1, 1>>>);
|
||||
static_assert(
|
||||
is_same_v<type_list_merge_sorted<type_list<units::exponent<d0, 1>>, type_list<units::exponent<d1, 1>>, exponent_less>,
|
||||
type_list<units::exponent<d0, 1>, units::exponent<d1, 1>>>);
|
||||
static_assert(
|
||||
is_same_v<type_list_merge_sorted<type_list<units::exponent<d1, 1>>, type_list<units::exponent<d0, 1>>, exponent_less>,
|
||||
type_list<units::exponent<d0, 1>, units::exponent<d1, 1>>>);
|
||||
|
||||
// type_list_sort
|
||||
|
||||
@@ -109,9 +112,9 @@ template<TypeList List>
|
||||
using exp_sort = type_list_sort<List, exponent_less>;
|
||||
|
||||
static_assert(is_same_v<exp_sort<exponent_list<units::exponent<d0, 1>>>, exponent_list<units::exponent<d0, 1>>>);
|
||||
static_assert(
|
||||
is_same_v<exp_sort<exponent_list<units::exponent<d0, 1>, units::exponent<d1, -1>>>, exponent_list<units::exponent<d0, 1>, units::exponent<d1, -1>>>);
|
||||
static_assert(
|
||||
is_same_v<exp_sort<exponent_list<units::exponent<d1, 1>, units::exponent<d0, -1>>>, exponent_list<units::exponent<d0, -1>, units::exponent<d1, 1>>>);
|
||||
static_assert(is_same_v<exp_sort<exponent_list<units::exponent<d0, 1>, units::exponent<d1, -1>>>,
|
||||
exponent_list<units::exponent<d0, 1>, units::exponent<d1, -1>>>);
|
||||
static_assert(is_same_v<exp_sort<exponent_list<units::exponent<d1, 1>, units::exponent<d0, -1>>>,
|
||||
exponent_list<units::exponent<d0, -1>, units::exponent<d1, 1>>>);
|
||||
|
||||
} // namespace
|
||||
|
||||
@@ -47,11 +47,14 @@ struct dim_time : base_dimension<"time", second> {};
|
||||
struct kelvin : named_unit<kelvin, "K", no_prefix> {};
|
||||
|
||||
#if !UNITS_COMP_MSVC
|
||||
static_assert([]<Prefix P>(P) { return !requires { typename prefixed_unit<struct kilokelvin, P, kelvin>; }; }(si::kilo{})); // no prefix allowed
|
||||
static_assert([]<Prefix P>(P) {
|
||||
return !requires { typename prefixed_unit<struct kilokelvin, P, kelvin>; };
|
||||
}(si::kilo{})); // no prefix allowed
|
||||
#endif
|
||||
|
||||
struct metre_per_second : unit<metre_per_second> {};
|
||||
struct dim_speed : derived_dimension<dim_speed, metre_per_second, units::exponent<dim_length, 1>, units::exponent<dim_time, -1>> {};
|
||||
struct dim_speed :
|
||||
derived_dimension<dim_speed, metre_per_second, units::exponent<dim_length, 1>, units::exponent<dim_time, -1>> {};
|
||||
struct kilometre_per_hour : derived_unit<kilometre_per_hour, dim_speed, kilometre, hour> {};
|
||||
|
||||
static_assert(equivalent<metre::named_unit, metre>);
|
||||
@@ -63,7 +66,9 @@ static_assert(compare<downcast<scaled_unit<yard::ratio * ratio(1, 3), metre>>, f
|
||||
static_assert(compare<downcast<scaled_unit<kilometre::ratio / hour::ratio, metre_per_second>>, kilometre_per_hour>);
|
||||
|
||||
#if !UNITS_COMP_MSVC
|
||||
static_assert([]<ratio R>() { return !requires { typename scaled_unit<R, metre>; }; }.template operator()<ratio(-1, 1)>()); // negative unit ratio
|
||||
static_assert([]<ratio R>() {
|
||||
return !requires { typename scaled_unit<R, metre>; };
|
||||
}.template operator()<ratio(-1, 1)>()); // negative unit ratio
|
||||
#endif
|
||||
|
||||
static_assert(centimetre::symbol == "cm");
|
||||
|
||||
Reference in New Issue
Block a user