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

feat: equivalent support removed

Browse Source
This commit is contained in:
Mateusz Pusz
2022-10-18 22:57:02 +02:00
parent 6d898957ab
commit 03e064fccd
3 changed files with 0 additions and 36 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/core/include/units/dimension.h
View File

@@ -211,12 +211,6 @@ template<Dimension D1, Dimension D2>
return is_same_v<D1, D2>;
}
// template<Dimension D1, Dimension D2>
// [[nodiscard]] consteval bool equivalent(D1, D2)
// {
// return is_same_v<detail::dim_type<D1>, detail::dim_type<D2>>;
// }
template<Dimension D1, Dimension D2>
[[nodiscard]] consteval bool convertible(D1, D2)
{

6
src/core/include/units/reference.h
View File

@@ -136,12 +136,6 @@ template<Representation Rep, Reference R>
void /*Use `q * (1 * r)` rather than `q * r`.*/ operator*(Quantity auto, Reference auto) = delete;
// template<Reference R1, Reference R2>
// [[nodiscard]] consteval bool equivalent(R1, R2)
// {
// return equivalent(R1::dimension, R2::dimension) && R1::unit == R2::unit;
// }
template<Reference R1, Reference R2>
[[nodiscard]] consteval bool convertible(R1, R2)
{

24
test/unit_test/static/dimension_test.cpp
View File

@@ -120,7 +120,6 @@ static_assert(speed_dim == speed_dim);
static_assert(length_dim / length_dim == one_dim);
static_assert(1 / time_dim != frequency_dim);
// static_assert(equivalent(1 / time_dim, frequency_dim));
static_assert(convertible(1 / time_dim, frequency_dim));
static_assert(1 / frequency_dim == time_dim);
static_assert(frequency_dim * time_dim == one_dim);
@@ -128,7 +127,6 @@ static_assert(std::is_same_v<std::common_type_t<decltype(1 / time_dim), decltype
static_assert(std::is_same_v<std::common_type_t<decltype(frequency_dim), decltype(1 / time_dim)>, frequency_dim_>);
static_assert(length_dim * length_dim != area_dim);
// static_assert(equivalent(length_dim * length_dim, area_dim));
static_assert(convertible(length_dim * length_dim, area_dim));
static_assert(length_dim * length_dim != volume_dim);
static_assert(area_dim / length_dim == length_dim);
@@ -136,20 +134,14 @@ static_assert(std::is_same_v<std::common_type_t<decltype(length_dim * length_dim
static_assert(std::is_same_v<std::common_type_t<decltype(area_dim), decltype(length_dim * length_dim)>, area_dim_>);
static_assert(length_dim * length_dim * length_dim != volume_dim);
// static_assert(equivalent(length_dim * length_dim * length_dim, volume_dim));
static_assert(area_dim * length_dim != volume_dim);
// static_assert(equivalent(area_dim * length_dim, volume_dim));
static_assert(volume_dim / length_dim != area_dim);
// static_assert(equivalent(volume_dim / length_dim, area_dim));
static_assert(volume_dim / length_dim / length_dim == length_dim);
static_assert(area_dim * area_dim / length_dim != volume_dim);
// static_assert(equivalent(area_dim * area_dim / length_dim, volume_dim));
static_assert(area_dim * (area_dim / length_dim) != volume_dim);
// static_assert(equivalent(area_dim * (area_dim / length_dim), volume_dim));
static_assert(volume_dim / (length_dim * length_dim) == length_dim);
static_assert(length_dim / time_dim != speed_dim);
// static_assert(equivalent(length_dim / time_dim, speed_dim));
static_assert(length_dim * time_dim != speed_dim);
static_assert(length_dim / time_dim / time_dim != speed_dim);
static_assert(length_dim / speed_dim == time_dim);
@@ -160,34 +152,25 @@ static_assert(std::is_same_v<std::common_type_t<decltype(length_dim / time_dim),
decltype(length_dim / time_dim)>);
static_assert(length_dim / time_dim / time_dim != acceleration_dim);
// static_assert(equivalent(length_dim / time_dim / time_dim, acceleration_dim));
static_assert(length_dim / (time_dim * time_dim) != acceleration_dim);
// static_assert(equivalent(length_dim / (time_dim * time_dim), acceleration_dim));
static_assert(speed_dim / time_dim != acceleration_dim);
// static_assert(equivalent(speed_dim / time_dim, acceleration_dim));
static_assert(speed_dim / acceleration_dim == time_dim);
static_assert(acceleration_dim * time_dim != speed_dim);
// static_assert(equivalent(acceleration_dim * time_dim, speed_dim));
static_assert(acceleration_dim * (time_dim * time_dim) == length_dim);
static_assert(acceleration_dim / speed_dim != frequency_dim);
// static_assert(equivalent(acceleration_dim / speed_dim, frequency_dim));
// comparison of convertible named dimensions
static_assert(velocity_dim != speed_dim);
// static_assert(equivalent(velocity_dim, speed_dim));
static_assert(convertible(speed_dim, velocity_dim));
static_assert(std::is_same_v<std::common_type_t<decltype(velocity_dim), decltype(speed_dim)>, velocity_dim_>);
static_assert(std::is_same_v<std::common_type_t<decltype(speed_dim), decltype(velocity_dim)>, velocity_dim_>);
// comparisons of equivalent but not convertible dimensions
static_assert(energy_dim != torque_dim);
// static_assert(equivalent(energy_dim, torque_dim));
static_assert(!convertible(energy_dim, torque_dim));
static_assert(force_dim * length_dim != energy_dim);
static_assert(force_dim * length_dim != torque_dim);
// static_assert(equivalent(force_dim * length_dim, energy_dim));
// static_assert(equivalent(force_dim * length_dim, torque_dim));
static_assert(convertible(force_dim * length_dim, energy_dim));
static_assert(convertible(force_dim * length_dim, torque_dim));
template<auto T1, auto T2>
@@ -198,34 +181,27 @@ concept no_common_type = requires {
static_assert(no_common_type<energy_dim, torque_dim>);
static_assert(frequency_dim != action_dim);
// static_assert(equivalent(frequency_dim, action_dim));
static_assert(!convertible(frequency_dim, action_dim));
static_assert(no_common_type<frequency_dim, action_dim>);
// Dimensionless
// static_assert(equivalent(power_dim / power_dim, efficiency_dim));
static_assert(convertible(power_dim / power_dim, efficiency_dim));
static_assert(power_dim / power_dim != efficiency_dim);
static_assert(one_dim != efficiency_dim);
// static_assert(equivalent(efficiency_dim, strain_dim));
static_assert(!convertible(efficiency_dim, strain_dim));
static_assert(efficiency_dim != strain_dim);
static_assert(stress_dim / stress_dim != strain_dim);
static_assert(stress_dim / stress_dim != efficiency_dim);
// static_assert(equivalent(stress_dim / stress_dim, strain_dim));
// static_assert(equivalent(stress_dim / stress_dim, efficiency_dim));
static_assert(convertible(stress_dim / stress_dim, strain_dim));
static_assert(convertible(stress_dim / stress_dim, efficiency_dim));
// comparison of not equivalent dimensions
static_assert(length_dim != time_dim);
// static_assert(!equivalent(length_dim, time_dim));
static_assert(!convertible(length_dim, time_dim));
static_assert(acceleration_dim != speed_dim);
// static_assert(!equivalent(acceleration_dim, speed_dim));
static_assert(!convertible(acceleration_dim, speed_dim));
} // namespace