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

refactor: 💥 common_XXX() functions renamed to get_common_XXX()

Browse Source 
This is needed to release a name for `common_unit` type that is coming soon.
This commit is contained in:
Mateusz Pusz
2024-09-24 09:36:59 +02:00
parent 5f9a6e4a20
commit dcab80525d
13 changed files with 120 additions and 115 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
test/static/quantity_point_test.cpp
View File

@@ -437,7 +437,7 @@ static_assert(!std::convertible_to<quantity<isq::height[m]>, quantity_point<isq:
static_assert(std::constructible_from<quantity_point<isq::height[m]>, quantity<special_height[m]>>);
static_assert(!std::convertible_to<quantity<special_height[m]>, quantity_point<isq::height[m]>>);
// quantity_specs with common_quantity_spec
// quantity_specs with get_common_quantity_spec
static_assert(!std::constructible_from<quantity_point<isq::width[m]>, quantity<isq::height[m]>>);
static_assert(!std::convertible_to<quantity<isq::height[m]>, quantity_point<isq::width[m]>>);
@@ -485,7 +485,7 @@ static_assert(!std::convertible_to<quantity<special_height[m]>, quantity_point<i
static_assert(!std::constructible_from<quantity_point<dimensionless[one], zero>, quantity<dimensionless[one]>>);
static_assert(!std::convertible_to<quantity<dimensionless[one]>, quantity_point<dimensionless[one], zero>>);
// quantity_specs with common_quantity_spec
// quantity_specs with get_common_quantity_spec
static_assert(!std::constructible_from<quantity_point<isq::width[m], zeroth_length>, quantity<isq::height[m]>>);
static_assert(!std::convertible_to<quantity<isq::height[m]>, quantity_point<isq::width[m], zeroth_length>>);
@@ -560,7 +560,7 @@ static_assert(!std::convertible_to<quantity_point<isq::height[m]>, quantity_poin
static_assert(!std::constructible_from<quantity_point<isq::height[m]>, quantity_point<special_height[m]>>);
static_assert(!std::convertible_to<quantity_point<special_height[m]>, quantity_point<isq::height[m]>>);
// quantity_specs with common_quantity_spec
// quantity_specs with get_common_quantity_spec
static_assert(!std::constructible_from<quantity_point<isq::width[m]>, quantity_point<isq::height[m]>>);
static_assert(!std::convertible_to<quantity_point<isq::height[m]>, quantity_point<isq::width[m]>>);
@@ -687,7 +687,7 @@ static_assert(std::constructible_from<quantity_point<isq::length[m], zeroth_leng
static_assert(
std::convertible_to<quantity_point<isq::height[m], zeroth_length>, quantity_point<isq::length[m], zeroth_length>>);
// quantity_specs with common_quantity_spec
// quantity_specs with get_common_quantity_spec
static_assert(!std::constructible_from<quantity_point<isq::width[m], zeroth_length>,
quantity_point<isq::height[m], zeroth_length>>);
static_assert(

44
test/static/quantity_spec_test.cpp
View File

@@ -783,35 +783,35 @@ static_assert((position_vector / time).character == quantity_character::vector);
static_assert((position_vector / position_vector * time).character == quantity_character::scalar);
static_assert((velocity / acceleration).character == quantity_character::scalar);
// common_quantity_spec
static_assert(common_quantity_spec(length, length) == length);
static_assert(common_quantity_spec(kind_of<length>, kind_of<length>) == kind_of<length>);
static_assert(common_quantity_spec(kind_of<length>, length) == length);
static_assert(common_quantity_spec(length, kind_of<length>) == length);
static_assert(common_quantity_spec(width, kind_of<length>) == width);
static_assert(common_quantity_spec(kind_of<length>, width) == width);
// get_common_quantity_spec
static_assert(get_common_quantity_spec(length, length) == length);
static_assert(get_common_quantity_spec(kind_of<length>, kind_of<length>) == kind_of<length>);
static_assert(get_common_quantity_spec(kind_of<length>, length) == length);
static_assert(get_common_quantity_spec(length, kind_of<length>) == length);
static_assert(get_common_quantity_spec(width, kind_of<length>) == width);
static_assert(get_common_quantity_spec(kind_of<length>, width) == width);
static_assert(common_quantity_spec(width, height) == length);
static_assert(common_quantity_spec(distance, path_length) == path_length);
static_assert(common_quantity_spec(potential_energy, kinetic_energy) == mechanical_energy);
static_assert(get_common_quantity_spec(width, height) == length);
static_assert(get_common_quantity_spec(distance, path_length) == path_length);
static_assert(get_common_quantity_spec(potential_energy, kinetic_energy) == mechanical_energy);
static_assert(common_quantity_spec(length / time, length / time) == length / time);
static_assert(common_quantity_spec(length / time, inverse(time / length)) == length / time);
static_assert(get_common_quantity_spec(length / time, length / time) == length / time);
static_assert(get_common_quantity_spec(length / time, inverse(time / length)) == length / time);
static_assert(common_quantity_spec(speed, length / time) == speed);
static_assert(common_quantity_spec(length / time, speed) == speed);
static_assert(common_quantity_spec(area, length* length) == area);
static_assert(common_quantity_spec(length * length, area) == area);
static_assert(common_quantity_spec(kinetic_energy, mass* pow<2>(length) / pow<2>(time)) == kinetic_energy);
static_assert(common_quantity_spec(mass * pow<2>(length) / pow<2>(time), kinetic_energy) == kinetic_energy);
static_assert(common_quantity_spec(gravitational_potential_energy, mass* acceleration_of_free_fall* height) ==
static_assert(get_common_quantity_spec(speed, length / time) == speed);
static_assert(get_common_quantity_spec(length / time, speed) == speed);
static_assert(get_common_quantity_spec(area, length* length) == area);
static_assert(get_common_quantity_spec(length * length, area) == area);
static_assert(get_common_quantity_spec(kinetic_energy, mass* pow<2>(length) / pow<2>(time)) == kinetic_energy);
static_assert(get_common_quantity_spec(mass * pow<2>(length) / pow<2>(time), kinetic_energy) == kinetic_energy);
static_assert(get_common_quantity_spec(gravitational_potential_energy, mass* acceleration_of_free_fall* height) ==
gravitational_potential_energy);
static_assert(common_quantity_spec(mass * acceleration_of_free_fall * height, gravitational_potential_energy) ==
static_assert(get_common_quantity_spec(mass * acceleration_of_free_fall * height, gravitational_potential_energy) ==
gravitational_potential_energy);
static_assert(common_quantity_spec(gravitational_potential_energy, mass* acceleration* length) ==
static_assert(get_common_quantity_spec(gravitational_potential_energy, mass* acceleration* length) ==
mass * acceleration * length);
static_assert(common_quantity_spec(mass * acceleration * length, gravitational_potential_energy) ==
static_assert(get_common_quantity_spec(mass * acceleration * length, gravitational_potential_energy) ==
mass * acceleration * length);
template<auto T1, auto T2>

22
test/static/reference_test.cpp
View File

@@ -273,22 +273,22 @@ static_assert(invalid_unit<solid_angular_measure, bit>);
static_assert(invalid_unit<storage_capacity, radian>);
static_assert(invalid_unit<storage_capacity, steradian>);
static_assert(is_of_type<common_reference(dimensionless[one], one), reference<dimensionless_, one_>>);
static_assert(is_of_type<common_reference(radian, one), radian_>);
static_assert(is_of_type<common_reference(one, radian), radian_>);
static_assert(is_of_type<common_reference(radian, dimensionless[one]), reference<angular_measure_, radian_>>);
static_assert(is_of_type<common_reference(dimensionless[one], radian), reference<angular_measure_, radian_>>);
static_assert(is_of_type<common_reference(angular_measure[radian], one), reference<angular_measure_, radian_>>);
static_assert(is_of_type<common_reference(one, angular_measure[radian]), reference<angular_measure_, radian_>>);
static_assert(is_of_type<get_common_reference(dimensionless[one], one), reference<dimensionless_, one_>>);
static_assert(is_of_type<get_common_reference(radian, one), radian_>);
static_assert(is_of_type<get_common_reference(one, radian), radian_>);
static_assert(is_of_type<get_common_reference(radian, dimensionless[one]), reference<angular_measure_, radian_>>);
static_assert(is_of_type<get_common_reference(dimensionless[one], radian), reference<angular_measure_, radian_>>);
static_assert(is_of_type<get_common_reference(angular_measure[radian], one), reference<angular_measure_, radian_>>);
static_assert(is_of_type<get_common_reference(one, angular_measure[radian]), reference<angular_measure_, radian_>>);
static_assert(
is_of_type<common_reference(angular_measure[radian], dimensionless[one]), reference<angular_measure_, radian_>>);
is_of_type<get_common_reference(angular_measure[radian], dimensionless[one]), reference<angular_measure_, radian_>>);
static_assert(
is_of_type<common_reference(dimensionless[one], angular_measure[radian]), reference<angular_measure_, radian_>>);
is_of_type<get_common_reference(dimensionless[one], angular_measure[radian]), reference<angular_measure_, radian_>>);
template<auto R1, auto R2>
concept no_common_reference = requires {
requires !requires { common_reference(R1, R2); };
requires !requires { common_reference(R2, R1); };
requires !requires { get_common_reference(R1, R2); };
requires !requires { get_common_reference(R2, R1); };
};
static_assert(no_common_reference<hertz, becquerel>);

49
test/static/unit_test.cpp
View File

@@ -511,32 +511,33 @@ static_assert(is_of_type<pow<2>(hour), derived_unit<power<hour_, 2>>>);
static_assert(
is_of_type<pow<2>(mag<3600>* second), scaled_unit<mag<3600> * mag<3600>, derived_unit<power<second_, 2>>>>);
// common_unit
static_assert(is_of_type<common_unit(gram, gram), gram_>);
static_assert(is_of_type<common_unit(kilogram, kilogram), si::kilo_<gram_>>);
static_assert(is_of_type<common_unit(si::kilo<gram>, kilogram), si::kilo_<gram_>>);
static_assert(is_of_type<common_unit(kilogram, si::kilo<gram>), si::kilo_<gram_>>);
static_assert(is_of_type<common_unit(mag<1000>* gram, kilogram), si::kilo_<gram_>>);
static_assert(is_of_type<common_unit(kilogram, mag<1000>* gram), si::kilo_<gram_>>);
static_assert(is_of_type<common_unit(one / second, hertz), hertz_>);
static_assert(is_of_type<common_unit(hertz, one / second), hertz_>);
static_assert(is_of_type<common_unit(gram, kilogram), gram_>);
static_assert(is_of_type<common_unit(kilogram, gram), gram_>);
static_assert(is_of_type<common_unit(second, hour), second_>);
static_assert(is_of_type<common_unit(hour, second), second_>);
static_assert(is_of_type<common_unit(minute, hour), minute_>);
static_assert(is_of_type<common_unit(hour, minute), minute_>);
static_assert(is_of_type<common_unit(si::kilo<metre>, si::milli<metre>), si::milli_<metre_>>);
static_assert(is_of_type<common_unit(si::milli<metre>, si::kilo<metre>), si::milli_<metre_>>);
static_assert(is_of_type<common_unit(yard, mile), yard_>);
static_assert(is_of_type<common_unit(mile, yard), yard_>);
// get_common_unit
static_assert(is_of_type<get_common_unit(gram, gram), gram_>);
static_assert(is_of_type<get_common_unit(kilogram, kilogram), si::kilo_<gram_>>);
static_assert(is_of_type<get_common_unit(si::kilo<gram>, kilogram), si::kilo_<gram_>>);
static_assert(is_of_type<get_common_unit(kilogram, si::kilo<gram>), si::kilo_<gram_>>);
static_assert(is_of_type<get_common_unit(mag<1000>* gram, kilogram), si::kilo_<gram_>>);
static_assert(is_of_type<get_common_unit(kilogram, mag<1000>* gram), si::kilo_<gram_>>);
static_assert(is_of_type<get_common_unit(one / second, hertz), hertz_>);
static_assert(is_of_type<get_common_unit(hertz, one / second), hertz_>);
static_assert(is_of_type<get_common_unit(gram, kilogram), gram_>);
static_assert(is_of_type<get_common_unit(kilogram, gram), gram_>);
static_assert(is_of_type<get_common_unit(second, hour), second_>);
static_assert(is_of_type<get_common_unit(hour, second), second_>);
static_assert(is_of_type<get_common_unit(minute, hour), minute_>);
static_assert(is_of_type<get_common_unit(hour, minute), minute_>);
static_assert(is_of_type<get_common_unit(si::kilo<metre>, si::milli<metre>), si::milli_<metre_>>);
static_assert(is_of_type<get_common_unit(si::milli<metre>, si::kilo<metre>), si::milli_<metre_>>);
static_assert(is_of_type<get_common_unit(yard, mile), yard_>);
static_assert(is_of_type<get_common_unit(mile, yard), yard_>);
// TODO The below have long/unreadable magnitude types
static_assert(is_of_type<common_unit(kilometre / hour, metre / second),
static_assert(is_of_type<get_common_unit(kilometre / hour, metre / second),
scaled_unit<mag_ratio<1, 18>, derived_unit<metre_, per<second_>>>>);
static_assert(is_of_type<common_unit(metre / second, kilometre / hour),
static_assert(is_of_type<get_common_unit(metre / second, kilometre / hour),
scaled_unit<mag_ratio<1, 18>, derived_unit<metre_, per<second_>>>>);
static_assert(is_of_type<common_unit(kilometre, mile), scaled_unit<mag_ratio<8, 125>, metre_>>);
static_assert(is_of_type<common_unit(mile, kilometre), scaled_unit<mag_ratio<8, 125>, metre_>>);
static_assert(is_of_type<common_unit(speed_of_light_in_vacuum, metre / second), derived_unit<metre_, per<second_>>>);
static_assert(is_of_type<get_common_unit(kilometre, mile), scaled_unit<mag_ratio<8, 125>, metre_>>);
static_assert(is_of_type<get_common_unit(mile, kilometre), scaled_unit<mag_ratio<8, 125>, metre_>>);
static_assert(
is_of_type<get_common_unit(speed_of_light_in_vacuum, metre / second), derived_unit<metre_, per<second_>>>);
} // namespace