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

Square and cubic UDLs renamed

Browse Source
This commit is contained in:
Mateusz Pusz
2020-01-09 10:03:41 +01:00
parent 159e2c1c02
commit a01c811f5f
13 changed files with 84 additions and 84 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/include/units/physical/cgs/area.h
View File

@@ -38,9 +38,9 @@ using area = quantity<dim_area, U, Rep>;
inline namespace literals {
// sq_cm
constexpr auto operator"" sq_cm(unsigned long long l) { return area<square_centimetre, std::int64_t>(l); }
constexpr auto operator"" sq_cm(long double l) { return area<square_centimetre, long double>(l); }
// cm2
constexpr auto operator"" cm2(unsigned long long l) { return area<square_centimetre, std::int64_t>(l); }
constexpr auto operator"" cm2(long double l) { return area<square_centimetre, long double>(l); }
}

6
src/include/units/physical/si/acceleration.h
View File

@@ -36,9 +36,9 @@ using acceleration = quantity<dim_acceleration, U, Rep>;
inline namespace literals {
// mps_sq
constexpr auto operator""mps_sq(unsigned long long l) { return acceleration<metre_per_second_sq, std::int64_t>(l); }
constexpr auto operator""mps_sq(long double l) { return acceleration<metre_per_second_sq, long double>(l); }
// mps2
constexpr auto operator""mps2(unsigned long long l) { return acceleration<metre_per_second_sq, std::int64_t>(l); }
constexpr auto operator""mps2(long double l) { return acceleration<metre_per_second_sq, long double>(l); }
} // namespace literals

24
src/include/units/physical/si/area.h
View File

@@ -42,21 +42,21 @@ using area = quantity<dim_area, U, Rep>;
inline namespace literals {
// sq_m
constexpr auto operator"" sq_m(unsigned long long l) { return area<square_metre, std::int64_t>(l); }
constexpr auto operator"" sq_m(long double l) { return area<square_metre, long double>(l); }
// m2
constexpr auto operator"" m2(unsigned long long l) { return area<square_metre, std::int64_t>(l); }
constexpr auto operator"" m2(long double l) { return area<square_metre, long double>(l); }
// sq_mm
constexpr auto operator"" sq_mm(unsigned long long l) { return area<square_millimetre, std::int64_t>(l); }
constexpr auto operator"" sq_mm(long double l) { return area<square_millimetre, long double>(l); }
// mm2
constexpr auto operator"" mm2(unsigned long long l) { return area<square_millimetre, std::int64_t>(l); }
constexpr auto operator"" mm2(long double l) { return area<square_millimetre, long double>(l); }
// sq_cm
constexpr auto operator"" sq_cm(unsigned long long l) { return area<square_centimetre, std::int64_t>(l); }
constexpr auto operator"" sq_cm(long double l) { return area<square_centimetre, long double>(l); }
// cm2
constexpr auto operator"" cm2(unsigned long long l) { return area<square_centimetre, std::int64_t>(l); }
constexpr auto operator"" cm2(long double l) { return area<square_centimetre, long double>(l); }
// sq_km
constexpr auto operator"" sq_km(unsigned long long l) { return area<square_kilometre, std::int64_t>(l); }
constexpr auto operator"" sq_km(long double l) { return area<square_kilometre, long double>(l); }
// km2
constexpr auto operator"" km2(unsigned long long l) { return area<square_kilometre, std::int64_t>(l); }
constexpr auto operator"" km2(long double l) { return area<square_kilometre, long double>(l); }
// ha
constexpr auto operator"" ha(unsigned long long l) { return area<hectare, std::int64_t>(l); }

24
src/include/units/physical/si/volume.h
View File

@@ -43,21 +43,21 @@ using volume = quantity<dim_volume, U, Rep>;
inline namespace literals {
// cub_mm
constexpr auto operator""cub_mm(unsigned long long l) { return volume<cubic_millimetre, std::int64_t>(l); }
constexpr auto operator""cub_mm(long double l) { return volume<cubic_millimetre, long double>(l); }
// mm3
constexpr auto operator""mm3(unsigned long long l) { return volume<cubic_millimetre, std::int64_t>(l); }
constexpr auto operator""mm3(long double l) { return volume<cubic_millimetre, long double>(l); }
// cub_cm
constexpr auto operator""cub_cm(unsigned long long l) { return volume<cubic_centimetre, std::int64_t>(l); }
constexpr auto operator""cub_cm(long double l) { return volume<cubic_centimetre, long double>(l); }
// cm3
constexpr auto operator""cm3(unsigned long long l) { return volume<cubic_centimetre, std::int64_t>(l); }
constexpr auto operator""cm3(long double l) { return volume<cubic_centimetre, long double>(l); }
// cub_m
constexpr auto operator""cub_m(unsigned long long l) { return volume<cubic_metre, std::int64_t>(l); }
constexpr auto operator""cub_m(long double l) { return volume<cubic_metre, long double>(l); }
// m3
constexpr auto operator""m3(unsigned long long l) { return volume<cubic_metre, std::int64_t>(l); }
constexpr auto operator""m3(long double l) { return volume<cubic_metre, long double>(l); }
// cub_km
constexpr auto operator""cub_km(unsigned long long l) { return volume<cubic_kilometre, std::int64_t>(l); }
constexpr auto operator""cub_km(long double l) { return volume<cubic_kilometre, long double>(l); }
// km3
constexpr auto operator""km3(unsigned long long l) { return volume<cubic_kilometre, std::int64_t>(l); }
constexpr auto operator""km3(long double l) { return volume<cubic_kilometre, long double>(l); }
// l
constexpr auto operator""_l(unsigned long long l) { return volume<litre, std::int64_t>(l); }

6
src/include/units/physical/us/area.h
View File

@@ -31,9 +31,9 @@ struct square_foot : deduced_unit<square_foot, si::dim_area, foot> {};
inline namespace literals {
// sq_ft
constexpr auto operator"" sq_ft(unsigned long long l) { return si::area<square_foot, std::int64_t>(l); }
constexpr auto operator"" sq_ft(long double l) { return si::area<square_foot, long double>(l); }
// ft2
constexpr auto operator"" ft2(unsigned long long l) { return si::area<square_foot, std::int64_t>(l); }
constexpr auto operator"" ft2(long double l) { return si::area<square_foot, long double>(l); }
} // namespace literals

6
src/include/units/physical/us/volume.h
View File

@@ -31,9 +31,9 @@ struct cubic_foot : deduced_unit<cubic_foot, si::dim_volume, foot> {};
inline namespace literals {
// cub_ft
constexpr auto operator""cub_ft(unsigned long long l) { return si::volume<cubic_foot, std::int64_t>(l); }
constexpr auto operator""cub_ft(long double l) { return si::volume<cubic_foot, long double>(l); }
// ft3
constexpr auto operator""ft3(unsigned long long l) { return si::volume<cubic_foot, std::int64_t>(l); }
constexpr auto operator""ft3(long double l) { return si::volume<cubic_foot, long double>(l); }
} // namespace literals

22
test/unit_test/runtime/fmt_units_test.cpp
View File

@@ -58,20 +58,20 @@ TEST_CASE("fmt::format on synthesized unit symbols", "[text][fmt]")
SECTION("area")
{
CHECK(fmt::format("{}", 1sq_m) == "1 m²");
CHECK(fmt::format("{}", 1sq_mm) == "1 mm²");
CHECK(fmt::format("{}", 1sq_cm) == "1 cm²");
CHECK(fmt::format("{}", 1sq_km) == "1 km²");
CHECK(fmt::format("{}", 1sq_ft) == "1 ft²");
CHECK(fmt::format("{}", 1m2) == "1 m²");
CHECK(fmt::format("{}", 1mm2) == "1 mm²");
CHECK(fmt::format("{}", 1cm2) == "1 cm²");
CHECK(fmt::format("{}", 1km2) == "1 km²");
CHECK(fmt::format("{}", 1ft2) == "1 ft²");
}
SECTION("volume")
{
CHECK(fmt::format("{}", 1cub_m) == "1 m³");
CHECK(fmt::format("{}", 1cub_mm) == "1 mm³");
CHECK(fmt::format("{}", 1cub_cm) == "1 cm³");
CHECK(fmt::format("{}", 1cub_km) == "1 km³");
CHECK(fmt::format("{}", 1cub_ft) == "1 ft³");
CHECK(fmt::format("{}", 1m3) == "1 m³");
CHECK(fmt::format("{}", 1mm3) == "1 mm³");
CHECK(fmt::format("{}", 1cm3) == "1 cm³");
CHECK(fmt::format("{}", 1km3) == "1 km³");
CHECK(fmt::format("{}", 1ft3) == "1 ft³");
}
SECTION("frequency")
@@ -92,7 +92,7 @@ TEST_CASE("fmt::format on synthesized unit symbols", "[text][fmt]")
SECTION("acceleration")
{
CHECK(fmt::format("{}", 1mps_sq) == "1 m/s²");
CHECK(fmt::format("{}", 1mps2) == "1 m/s²");
}
SECTION("energy")

6
test/unit_test/runtime/math_test.cpp
View File

@@ -41,15 +41,15 @@ TEST_CASE("'pow<N>()' on quantity changes the value and the dimension accordingl
}
SECTION ("'pow<2>(q)' squares both the value and a dimension") {
CHECK(pow<2>(2m) == 4sq_m);
CHECK(pow<2>(2m) == 4m2);
}
SECTION ("'pow<3>(q)' cubes both the value and a dimension") {
CHECK(pow<3>(2m) == 8cub_m);
CHECK(pow<3>(2m) == 8m3);
}
}
TEST_CASE("'sqrt()' on quantity changes the value and the dimension accordingly", "[math][sqrt]")
{
REQUIRE(sqrt(4sq_m) == 2m);
REQUIRE(sqrt(4m2) == 2m);
}

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

@@ -59,8 +59,8 @@ static_assert(detail::unit_text<dim_velocity, centimetre_per_second>() == "cm/s"
// area
static_assert(std::is_same_v<ratio_divide<centimetre::ratio, dimension_unit<dim_length>::ratio>, ratio<1>>);
static_assert(1cm * 1cm == 1sq_cm);
static_assert(100sq_cm / 10cm == 10cm);
static_assert(1cm * 1cm == 1cm2);
static_assert(100cm2 / 10cm == 10cm);
static_assert(detail::unit_text<dim_area, square_centimetre>() == "cm²");
@@ -80,9 +80,9 @@ static_assert(100dyn / 10Gal == 10g);
// pressure
static_assert(10dyn / 10sq_cm == 1Ba);
static_assert(10dyn / 1Ba == 10sq_cm);
static_assert(1Ba * 10sq_cm == 10dyn);
static_assert(10dyn / 10cm2 == 1Ba);
static_assert(10dyn / 1Ba == 10cm2);
static_assert(1Ba * 10cm2 == 10dyn);
// energy

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

@@ -29,7 +29,7 @@ namespace {
static_assert(std::is_same_v<decltype(pow<0>(2m)), std::int64_t>);
static_assert(std::is_same_v<decltype(pow<1>(2m)), decltype(2m)>);
static_assert(std::is_same_v<decltype(pow<2>(2m)), decltype(4sq_m)>);
static_assert(std::is_same_v<decltype(sqrt(4sq_m)), decltype(2m)>);
static_assert(std::is_same_v<decltype(pow<2>(2m)), decltype(4m2)>);
static_assert(std::is_same_v<decltype(sqrt(4m2)), decltype(2m)>);
} // namespace

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

@@ -270,7 +270,7 @@ static_assert((7m % 2).count() == 1);
static_assert((7m % 2m).count() == 1);
static_assert((7km % 2000m).count() == 1000);
static_assert((10sq_km * 10sq_km) / 50sq_km == 2sq_km);
static_assert((10km2 * 10km2) / 50km2 == 2km2);
// comparators
@@ -346,6 +346,6 @@ static_assert(1km / 1s == 1000mps);
static_assert(2kmph * 2h == 4km);
static_assert(2km / 2kmph == 1h);
static_assert(std::is_same_v<decltype(pow<2>(2m)), decltype(4sq_m)>);
static_assert(std::is_same_v<decltype(pow<2>(2m)), decltype(4m2)>);
} // namespace

6
test/unit_test/static/si_cgs_test.cpp
View File

@@ -65,7 +65,7 @@ static_assert(cgs::length<cgs::centimetre>(100) == 1m);
static_assert(cgs::mass<cgs::gram>(1'000) == 1kg);
static_assert(cgs::time<cgs::second>(1) == 1s);
static_assert(cgs::velocity<cgs::centimetre_per_second>(100) == 1mps);
static_assert(cgs::acceleration<cgs::gal>(100) == 1mps_sq);
static_assert(cgs::acceleration<cgs::gal>(100) == 1mps2);
static_assert(cgs::force<cgs::dyne>(100'000) == 1N);
static_assert(cgs::energy<cgs::erg>(10'000'000) == 1_J);
static_assert(cgs::power<cgs::erg_per_second>(10'000'000) == 1W);
@@ -98,7 +98,7 @@ using namespace units::cgs::literals;
// static_assert(1'000g == 1kg); // ambiguous
static_assert(1s == 1s);
static_assert(100cmps == 1mps);
static_assert(100Gal == 1mps_sq);
static_assert(100Gal == 1mps2);
static_assert(100'000dyn == 1N);
static_assert(10'000'000_erg == 1_J);
static_assert(10'000'000_ergps == 1W);
@@ -131,7 +131,7 @@ static_assert(quantity_cast<cgs::length<cgs::centimetre>>(si::length<si::metre>(
// static_assert(200cm * si::length<si::metre>(2) == si::area<si::square_metre>(4)); // should not compile (unknown dimension)
static_assert(quantity_cast<si::dim_length>(200cm) * si::length<si::metre>(2) == si::area<si::square_metre>(4));
static_assert(200cm * quantity_cast<cgs::dim_length>(si::length<si::metre>(2)) == 40'000sq_cm);
static_assert(200cm * quantity_cast<cgs::dim_length>(si::length<si::metre>(2)) == 40'000cm2);
// TODO Add support for quantity_cast on an unknown_dimension?
// static_assert(quantity_cast<si::area<si::square_metre>>(200cm * si::length<si::metre>(2)) == si::area<si::square_metre>(4));

44
test/unit_test/static/si_test.cpp
View File

@@ -122,15 +122,15 @@ static_assert(10Hz * 1min == 600);
static_assert(2 / 1Hz == 2s);
// force
static_assert(10kg * 10mps_sq == 100N);
static_assert(100N / 1mps_sq == 100kg);
static_assert(100N / 1kg == 100mps_sq);
static_assert(10kg * 10mps2 == 100N);
static_assert(100N / 1mps2 == 100kg);
static_assert(100N / 1kg == 100mps2);
// pressure
static_assert(10N / 10sq_m == 1Pa);
static_assert(10N / 1Pa == 10sq_m);
static_assert(1Pa * 10sq_m == 10N);
static_assert(10N / 10m2 == 1Pa);
static_assert(10N / 1Pa == 10m2);
static_assert(1Pa * 10m2 == 10N);
// energy
@@ -147,9 +147,9 @@ static_assert(gigajoule::symbol == "GJ");
static_assert(10N * 10m == 100_J);
static_assert(100_J / 10m == 10N);
static_assert(100_J / 10N == 10m);
static_assert(10Pa * 10cub_m == 100_J);
static_assert(100_J / 10Pa == 10cub_m);
static_assert(100_J / 10cub_m == 10Pa);
static_assert(10Pa * 10m3 == 100_J);
static_assert(100_J / 10Pa == 10m3);
static_assert(100_J / 10m3 == 10Pa);
// power
@@ -215,30 +215,30 @@ static_assert(kilometre_per_hour::symbol == "km/h");
// acceleration
static_assert(10mps / 10s == 1mps_sq);
static_assert(10mps / 1mps_sq == 10s);
static_assert(1mps_sq * 10s == 10mps);
static_assert(10mps / 10s == 1mps2);
static_assert(10mps / 1mps2 == 10s);
static_assert(1mps2 * 10s == 10mps);
static_assert(detail::unit_text<dim_acceleration, metre_per_second_sq>() == "m/s²");
// area
static_assert(10m * 10m == 100sq_m);
static_assert(100sq_m / 10m == 10m);
static_assert(10km * 10km == 100sq_km);
static_assert(1sq_m == 10'000sq_cm);
static_assert(1ha == 10'000sq_m);
static_assert(10m * 10m == 100m2);
static_assert(100m2 / 10m == 10m);
static_assert(10km * 10km == 100km2);
static_assert(1m2 == 10'000cm2);
static_assert(1ha == 10'000m2);
static_assert(detail::unit_text<dim_area, square_metre>() == "m²");
// volume
static_assert(1m * 1m * 1m == 1cub_m);
static_assert(10sq_m * 10m == 100cub_m);
static_assert(10km * 10km * 10km == 1000cub_km);
static_assert(1cub_m == 1'000'000cub_cm);
static_assert(1m * 1m * 1m == 1m3);
static_assert(10m2 * 10m == 100m3);
static_assert(10km * 10km * 10km == 1000km3);
static_assert(1m3 == 1'000'000cm3);
static_assert(1dm * 1dm * 1dm == 1_l);
static_assert(1000_l == 1cub_m);
static_assert(1000_l == 1m3);
static_assert(detail::unit_text<dim_volume, cubic_metre>() == "m³");