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

perf: std::is_same_v replaced with units::is_same_v

Browse Source
This commit is contained in:
Mateusz Pusz
2020-12-28 18:42:03 +01:00
parent 32391866be
commit 3d081d37e6
6 changed files with 65 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
test/metabench/make_dimension/dimension_concepts_all.h
View File

@ -157,7 +157,7 @@ namespace units {
template<Exponent E1, Exponent... ERest>
struct dim_consolidate<dimension<E1, ERest...>> {
using rest = dim_consolidate_t<dimension<ERest...>>;
using type = conditional<std::is_same_v<rest, dimension<>>, dimension<E1>, type_list_push_front<rest, E1>>;
using type = conditional<is_same_v<rest, dimension<>>, dimension<E1>, type_list_push_front<rest, E1>>;
};
template<const base_dimension& D, std::intmax_t Num1, std::intmax_t Den1, std::intmax_t Num2, std::intmax_t Den2, Exponent... ERest>

2
test/metabench/make_dimension/dimension_concepts_iface.h
View File

@ -157,7 +157,7 @@ namespace units {
template<typename E1, typename... ERest>
struct dim_consolidate<dimension<E1, ERest...>> {
using rest = dim_consolidate_t<dimension<ERest...>>;
using type = conditional<std::is_same_v<rest, dimension<>>, dimension<E1>, type_list_push_front<rest, E1>>;
using type = conditional<is_same_v<rest, dimension<>>, dimension<E1>, type_list_push_front<rest, E1>>;
};
template<const base_dimension& D, std::intmax_t Num1, std::intmax_t Den1, std::intmax_t Num2, std::intmax_t Den2, typename... ERest>

2
test/metabench/make_dimension/dimension_no_concepts.h
View File

@ -128,7 +128,7 @@ namespace units {
template<typename E1, typename... ERest>
struct dim_consolidate<dimension<E1, ERest...>> {
using rest = dim_consolidate_t<dimension<ERest...>>;
using type = conditional<std::is_same_v<rest, dimension<>>, dimension<E1>, type_list_push_front<rest, E1>>;
using type = conditional<is_same_v<rest, dimension<>>, dimension<E1>, type_list_push_front<rest, E1>>;
};
template<const base_dimension& D, std::intmax_t Num1, std::intmax_t Den1, std::intmax_t Num2, std::intmax_t Den2, typename... ERest>

4
test/unit_test/static/chrono_test.cpp
View File

@ -43,8 +43,8 @@ static_assert(!std::constructible_from<si::time<si::hour, std::chrono::seconds::
static_assert(!std::convertible_to<std::chrono::seconds, si::time<si::hour, std::chrono::seconds::rep>>);
// CTAD
static_assert(std::is_same_v<decltype(quantity{1s}), si::time<si::second, std::chrono::seconds::rep>>);
static_assert(std::is_same_v<decltype(quantity{1h}), si::time<si::hour, std::chrono::hours::rep>>);
static_assert(is_same_v<decltype(quantity{1s}), si::time<si::second, std::chrono::seconds::rep>>);
static_assert(is_same_v<decltype(quantity{1h}), si::time<si::hour, std::chrono::hours::rep>>);
// operators
static_assert(quantity{1s} + 1_q_s == 2_q_s);

110
test/unit_test/static/quantity_test.cpp
View File

@ -231,12 +231,12 @@ static_assert(length<kilometre>(1500_q_m).count() == 1.5);
// CTAD
/////////
static_assert(std::is_same_v<decltype(quantity{length<metre, int>(123)}), length<metre, int>>);
static_assert(std::is_same_v<decltype(quantity{speed<metre_per_second>(123)}), speed<metre_per_second>>);
// static_assert(std::is_same_v<decltype(length{length<metre, int>(123)}), length<metre, int>>); // TODO gcc ICE
static_assert(std::is_same_v<decltype(quantity{123_q_m}), length<metre, std::int64_t>>);
static_assert(std::is_same_v<decltype(quantity{1}), dimensionless<one, int>>);
static_assert(std::is_same_v<decltype(quantity{1.23}), dimensionless<one, double>>);
static_assert(is_same_v<decltype(quantity{length<metre, int>(123)}), length<metre, int>>);
static_assert(is_same_v<decltype(quantity{speed<metre_per_second>(123)}), speed<metre_per_second>>);
// static_assert(is_same_v<decltype(length{length<metre, int>(123)}), length<metre, int>>); // TODO gcc ICE
static_assert(is_same_v<decltype(quantity{123_q_m}), length<metre, std::int64_t>>);
static_assert(is_same_v<decltype(quantity{1}), dimensionless<one, int>>);
static_assert(is_same_v<decltype(quantity{1.23}), dimensionless<one, double>>);
////////////////////////
@ -331,17 +331,17 @@ concept invalid_binary_operations = requires {
static_assert(invalid_binary_operations<metre>);
// same representation type
static_assert(std::is_same_v<decltype(1_q_m + 1_q_m), length<metre, std::int64_t>>);
static_assert(std::is_same_v<decltype(1_q_m - 1_q_m), length<metre, std::int64_t>>);
static_assert(std::is_same_v<decltype(1_q_m * 1), length<metre, std::int64_t>>);
static_assert(std::is_same_v<decltype(1_q_m * quantity{1}), length<metre, std::int64_t>>);
static_assert(std::is_same_v<decltype(1 * 1_q_m), length<metre, std::int64_t>>);
static_assert(std::is_same_v<decltype(quantity{1} * 1_q_m), length<metre, std::int64_t>>);
static_assert(std::is_same_v<decltype(1_q_m / 1), length<metre, std::int64_t>>);
static_assert(std::is_same_v<decltype(1_q_m / quantity{1}), length<metre, std::int64_t>>);
static_assert(std::is_same_v<decltype(1_q_m % 1), length<metre, std::int64_t>>);
static_assert(std::is_same_v<decltype(1_q_m % quantity{1}), length<metre, std::int64_t>>);
static_assert(std::is_same_v<decltype(1_q_m % 1_q_m), length<metre, std::int64_t>>);
static_assert(is_same_v<decltype(1_q_m + 1_q_m), length<metre, std::int64_t>>);
static_assert(is_same_v<decltype(1_q_m - 1_q_m), length<metre, std::int64_t>>);
static_assert(is_same_v<decltype(1_q_m * 1), length<metre, std::int64_t>>);
static_assert(is_same_v<decltype(1_q_m * quantity{1}), length<metre, std::int64_t>>);
static_assert(is_same_v<decltype(1 * 1_q_m), length<metre, std::int64_t>>);
static_assert(is_same_v<decltype(quantity{1} * 1_q_m), length<metre, std::int64_t>>);
static_assert(is_same_v<decltype(1_q_m / 1), length<metre, std::int64_t>>);
static_assert(is_same_v<decltype(1_q_m / quantity{1}), length<metre, std::int64_t>>);
static_assert(is_same_v<decltype(1_q_m % 1), length<metre, std::int64_t>>);
static_assert(is_same_v<decltype(1_q_m % quantity{1}), length<metre, std::int64_t>>);
static_assert(is_same_v<decltype(1_q_m % 1_q_m), length<metre, std::int64_t>>);
static_assert(compare<decltype(1_q_m * dimensionless<percent, std::int64_t>(1)), length<centimetre, std::int64_t>>);
static_assert(compare<decltype(dimensionless<percent, std::int64_t>(1) * 1_q_m), length<centimetre, std::int64_t>>);
static_assert(compare<decltype(1_q_m / dimensionless<percent, std::int64_t>(1)), length<hectometre, std::int64_t>>);
@ -353,14 +353,14 @@ static_assert(compare<decltype(quantity{1} / 1_q_s), frequency<hertz, std::int64
static_assert(compare<decltype(dimensionless<percent, std::int64_t>(1) / 1_q_s), frequency<scaled_unit<ratio(1, 100), hertz>, std::int64_t>>);
// different representation types
static_assert(std::is_same_v<decltype(1_q_m + 1._q_m), length<metre, long double>>);
static_assert(std::is_same_v<decltype(1_q_m - 1._q_m), length<metre, long double>>);
static_assert(std::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(std::is_same_v<decltype(1 * 1._q_m), length<metre, long double>>);
static_assert(std::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(std::is_same_v<decltype(quantity{1} * 1._q_m), length<metre, long double>>);
static_assert(std::is_same_v<decltype(1_q_m / 1.L), length<metre, long double>>);
static_assert(std::is_same_v<decltype(1_q_m / quantity{1.L}), 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._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 * 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(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>>);
static_assert(compare<decltype(1_q_m * dimensionless<percent, long double>(1)), length<centimetre, long double>>);
static_assert(compare<decltype(dimensionless<percent, std::int64_t>(1) * 1._q_m), length<centimetre, long double>>);
static_assert(compare<decltype(1_q_m * 1._q_m), area<square_metre, long double>>);
@ -374,14 +374,14 @@ static_assert(compare<decltype(1_q_m % quantity{short(1)}), length<metre, std::i
static_assert(compare<decltype(1_q_m % dimensionless<percent, short>(1)), length<centimetre, std::int64_t>>);
static_assert(compare<decltype(1_q_m % length<metre, short>(1)), length<metre, std::int64_t>>);
static_assert(std::is_same_v<decltype(1._q_m + 1_q_m), length<metre, long double>>);
static_assert(std::is_same_v<decltype(1._q_m - 1_q_m), length<metre, long double>>);
static_assert(std::is_same_v<decltype(1._q_m * 1), length<metre, long double>>);
static_assert(std::is_same_v<decltype(1.L * 1_q_m), length<metre, long double>>);
static_assert(std::is_same_v<decltype(1._q_m * quantity{1}), length<metre, long double>>);
static_assert(std::is_same_v<decltype(quantity{1.L} * 1_q_m), length<metre, long double>>);
static_assert(std::is_same_v<decltype(1._q_m / 1), length<metre, long double>>);
static_assert(std::is_same_v<decltype(1._q_m / quantity{1}), 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_q_m), length<metre, long double>>);
static_assert(is_same_v<decltype(1._q_m * 1), length<metre, long double>>);
static_assert(is_same_v<decltype(1.L * 1_q_m), length<metre, long double>>);
static_assert(is_same_v<decltype(1._q_m * quantity{1}), length<metre, long double>>);
static_assert(is_same_v<decltype(quantity{1.L} * 1_q_m), length<metre, long double>>);
static_assert(is_same_v<decltype(1._q_m / 1), length<metre, long double>>);
static_assert(is_same_v<decltype(1._q_m / quantity{1}), length<metre, long double>>);
static_assert(compare<decltype(1._q_m * dimensionless<percent, std::int64_t>(1)), length<centimetre, long double>>);
static_assert(compare<decltype(dimensionless<percent, long double>(1) * 1_q_m), length<centimetre, long double>>);
static_assert(compare<decltype(1._q_m / dimensionless<percent, std::int64_t>(1)), length<hectometre, long double>>);
@ -392,28 +392,28 @@ static_assert(compare<decltype(quantity{1.L} / 1_q_s), frequency<hertz, long dou
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(std::is_same_v<decltype(1_q_m + 1_q_km), length<metre, std::int64_t>>);
static_assert(std::is_same_v<decltype(1._q_m + 1_q_km), length<metre, long double>>);
static_assert(std::is_same_v<decltype(1_q_m + 1._q_km), length<metre, long double>>);
static_assert(std::is_same_v<decltype(1._q_m + 1._q_km), length<metre, long double>>);
static_assert(is_same_v<decltype(1_q_m + 1_q_km), length<metre, std::int64_t>>);
static_assert(is_same_v<decltype(1._q_m + 1_q_km), length<metre, long double>>);
static_assert(is_same_v<decltype(1_q_m + 1._q_km), length<metre, long double>>);
static_assert(is_same_v<decltype(1._q_m + 1._q_km), length<metre, long double>>);
static_assert(std::is_same_v<decltype(1_q_km + 1_q_m), length<metre, std::int64_t>>);
static_assert(std::is_same_v<decltype(1._q_km + 1_q_m), length<metre, long double>>);
static_assert(std::is_same_v<decltype(1_q_km + 1._q_m), length<metre, long double>>);
static_assert(std::is_same_v<decltype(1._q_km + 1._q_m), length<metre, long double>>);
static_assert(is_same_v<decltype(1_q_km + 1_q_m), length<metre, std::int64_t>>);
static_assert(is_same_v<decltype(1._q_km + 1_q_m), length<metre, long double>>);
static_assert(is_same_v<decltype(1_q_km + 1._q_m), length<metre, long double>>);
static_assert(is_same_v<decltype(1._q_km + 1._q_m), length<metre, long double>>);
static_assert(std::is_same_v<decltype(1_q_m - 1_q_km), length<metre, std::int64_t>>);
static_assert(std::is_same_v<decltype(1._q_m - 1_q_km), length<metre, long double>>);
static_assert(std::is_same_v<decltype(1_q_m - 1._q_km), length<metre, long double>>);
static_assert(std::is_same_v<decltype(1._q_m - 1._q_km), length<metre, long double>>);
static_assert(is_same_v<decltype(1_q_m - 1_q_km), length<metre, std::int64_t>>);
static_assert(is_same_v<decltype(1._q_m - 1_q_km), length<metre, long double>>);
static_assert(is_same_v<decltype(1_q_m - 1._q_km), length<metre, long double>>);
static_assert(is_same_v<decltype(1._q_m - 1._q_km), length<metre, long double>>);
static_assert(std::is_same_v<decltype(1_q_km - 1_q_m), length<metre, std::int64_t>>);
static_assert(std::is_same_v<decltype(1._q_km - 1_q_m), length<metre, long double>>);
static_assert(std::is_same_v<decltype(1_q_km - 1._q_m), length<metre, long double>>);
static_assert(std::is_same_v<decltype(1._q_km - 1._q_m), length<metre, long double>>);
static_assert(is_same_v<decltype(1_q_km - 1_q_m), length<metre, std::int64_t>>);
static_assert(is_same_v<decltype(1._q_km - 1_q_m), length<metre, long double>>);
static_assert(is_same_v<decltype(1_q_km - 1._q_m), length<metre, long double>>);
static_assert(is_same_v<decltype(1._q_km - 1._q_m), length<metre, long double>>);
static_assert(std::is_same_v<decltype(1_q_m % 1_q_km), length<metre, std::int64_t>>);
static_assert(std::is_same_v<decltype(1_q_km % 1_q_m), length<metre, std::int64_t>>);
static_assert(is_same_v<decltype(1_q_m % 1_q_km), length<metre, std::int64_t>>);
static_assert(is_same_v<decltype(1_q_km % 1_q_m), length<metre, std::int64_t>>);
// different dimensions
static_assert(compare<decltype(1_q_m_per_s * 1_q_s), length<metre, std::int64_t>>);
@ -687,13 +687,13 @@ static_assert(quantity_cast<dim_speed, kilometre_per_hour>(2000.0_q_m / 3600.0_q
#if UNITS_DOWNCAST_MODE == 0
static_assert(std::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(std::is_same_v<decltype(1_q_mm + 1_q_km), length<scaled_unit<ratio(1, 1, -3), metre>, 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
static_assert(std::is_same_v<decltype(10_q_m / 5_q_s), speed<metre_per_second, std::int64_t>>);
static_assert(std::is_same_v<decltype(1_q_mm + 1_q_km), length<millimetre, std::int64_t>>);
static_assert(is_same_v<decltype(10_q_m / 5_q_s), speed<metre_per_second, std::int64_t>>);
static_assert(is_same_v<decltype(1_q_mm + 1_q_km), length<millimetre, std::int64_t>>);
#endif

10
test/unit_test/static/unit_constants.cpp
View File

@ -59,7 +59,7 @@ static_assert(2 * m / s == 2_q_m_per_s);
static_assert(2 / s * m == 2_q_m_per_s);
static_assert(2 * (m / s) == 2_q_m_per_s);
static_assert(2 * ::m_per_s == 2_q_m_per_s);
static_assert(std::is_same_v<decltype(::m_per_s)::rep, decltype(m)::rep>);
static_assert(is_same_v<decltype(::m_per_s)::rep, decltype(m)::rep>);
static_assert(120 * km / (2 * h) == 60_q_km_per_h);
static_assert(120 * km / 2 / h == 60_q_km_per_h);
@ -68,9 +68,9 @@ static_assert([] {
const auto duration{2};
return length * km / (duration * h);
}() == 60_q_km_per_h);
static_assert(std::is_same_v<decltype(std::int64_t{120} * km / (2 * h)), decltype(60_q_km_per_h)>);
static_assert(std::is_same_v<decltype(std::int64_t{120} * km / 2 / h), decltype(60_q_km_per_h)>);
static_assert(std::is_same_v<decltype(120.L * km / 2 / h), decltype(60._q_km_per_h)>);
static_assert(is_same_v<decltype(std::int64_t{120} * km / (2 * h)), decltype(60_q_km_per_h)>);
static_assert(is_same_v<decltype(std::int64_t{120} * km / 2 / h), decltype(60_q_km_per_h)>);
static_assert(is_same_v<decltype(120.L * km / 2 / h), decltype(60._q_km_per_h)>);
static_assert(1. / 4 * m2 == 1._q_m2 / 4);
@ -79,7 +79,7 @@ static_assert([] {
signed s = 2; // hides ^
Length auto v = 20 * m / s;
/* */ v0 = 10 * m / ::s;
return !std::is_same_v<decltype(v0), decltype(v)>;
return !is_same_v<decltype(v0), decltype(v)>;
}());
int main() {}