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

All UDLs are now prefixed with q_

Browse Source
This commit is contained in:
Mateusz Pusz
2020-02-17 15:56:06 +01:00
parent 0566cc631d
commit 18620044c5
65 changed files with 768 additions and 768 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
README.md
View File

@@ -25,7 +25,7 @@ constexpr Velocity auto avg_speed(Length auto d, Time auto t)
int main() int main()
{ {
using namespace si::literals; using namespace si::literals;
Velocity auto v1 = avg_speed(220km, 2h); Velocity auto v1 = avg_speed(220q_km, 2q_h);
Velocity auto v2 = avg_speed(si::length<international::mile>(140), si::time<si::hour>(2)); Velocity auto v2 = avg_speed(si::length<international::mile>(140), si::time<si::hour>(2));
Velocity auto v3 = quantity_cast<si::metre_per_second>(v2); Velocity auto v3 = quantity_cast<si::metre_per_second>(v2);
Velocity auto v4 = quantity_cast<int>(v3); Velocity auto v4 = quantity_cast<int>(v3);
@@ -50,20 +50,20 @@ Here is a small example of possible operations:
```cpp ```cpp
// simple numeric operations // simple numeric operations
static_assert(10km / 2 == 5km); static_assert(10q_km / 2 == 5q_km);
// unit conversions // unit conversions
static_assert(1h == 3600s); static_assert(1q_h == 3600q_s);
static_assert(1km + 1m == 1001m); static_assert(1q_km + 1q_m == 1001q_m);
// dimension conversions // dimension conversions
static_assert(1km / 1s == 1000mps); static_assert(1q_km / 1q_s == 1000q_mps);
static_assert(2kmph * 2h == 4km); static_assert(2q_kmph * 2q_h == 4q_km);
static_assert(2km / 2kmph == 1h); static_assert(2q_km / 2q_kmph == 1q_h);
static_assert(1000 / 1s == 1kHz); static_assert(1000 / 1q_s == 1q_kHz);
static_assert(10km / 5km == 2); static_assert(10q_km / 5q_km == 2);
``` ```
@@ -90,7 +90,7 @@ Thanks to them the same code can be as simple as:
```cpp ```cpp
using namespace units::si::literals; using namespace units::si::literals;
auto d = 123km; // units::length<units::si::kilometre, std::int64_t> auto d = 123q_km; // units::length<units::si::kilometre, std::int64_t>
``` ```
For brevity, the next examples will assume: For brevity, the next examples will assume:
@@ -105,8 +105,8 @@ Let's assume that the user wants to write the following code:
int main() int main()
{ {
using namespace si::literals; using namespace si::literals;
auto v1 = avg_speed(220km, 2h); auto v1 = avg_speed(220q_km, 2q_h);
auto v2 = avg_speed(140mi, 2h); auto v2 = avg_speed(140q_mi, 2q_h);
// ... // ...
} }
``` ```
@@ -156,8 +156,8 @@ int main()
{ {
using namespace si::literals; using namespace si::literals;
using namespace international::literals; using namespace international::literals;
Velocity auto v1 = avg_speed(220km, 2h); Velocity auto v1 = avg_speed(220q_km, 2q_h);
Velocity auto v2 = avg_speed(140mi, 2h); Velocity auto v2 = avg_speed(140q_mi, 2q_h);
std::cout << v1 << '\n'; // 110 km/h std::cout << v1 << '\n'; // 110 km/h
std::cout << quantity_cast<si::metre_per_second>(speed) << '\n'; // 30.5556 m/s std::cout << quantity_cast<si::metre_per_second>(speed) << '\n'; // 30.5556 m/s

48
doc/DESIGN.md
View File

@@ -11,20 +11,20 @@ Here is a small example of possible operations:
```cpp ```cpp
// simple numeric operations // simple numeric operations
static_assert(10km / 2 == 5km); static_assert(10q_km / 2 == 5q_km);
// unit conversions // unit conversions
static_assert(1h == 3600s); static_assert(1q_h == 3600q_s);
static_assert(1km + 1m == 1001m); static_assert(1q_km + 1q_m == 1001q_m);
// dimension conversions // dimension conversions
static_assert(1km / 1s == 1000mps); static_assert(1q_km / 1q_s == 1000q_mps);
static_assert(2kmph * 2h == 4km); static_assert(2q_kmph * 2q_h == 4q_km);
static_assert(2km / 2kmph == 1h); static_assert(2q_km / 2q_kmph == 1q_h);
static_assert(1000 / 1s == 1kHz); static_assert(1000 / 1q_s == 1q_kHz);
static_assert(10km / 5km == 2); static_assert(10q_km / 5q_km == 2);
``` ```
@@ -458,12 +458,12 @@ has an associated UDL. For example:
namespace si::inline literals { namespace si::inline literals {
// m // m
constexpr auto operator"" m(unsigned long long l) { return length<metre, std::int64_t>(l); } constexpr auto operator"" q_m(unsigned long long l) { return length<metre, std::int64_t>(l); }
constexpr auto operator"" m(long double l) { return length<metre, long double>(l); } constexpr auto operator"" q_m(long double l) { return length<metre, long double>(l); }
// km // km
constexpr auto operator"" km(unsigned long long l) { return length<kilometre, std::int64_t>(l); } constexpr auto operator"" q_km(unsigned long long l) { return length<kilometre, std::int64_t>(l); }
constexpr auto operator"" km(long double l) { return length<kilometre, long double>(l); } constexpr auto operator"" q_km(long double l) { return length<kilometre, long double>(l); }
} }
``` ```
@@ -574,7 +574,7 @@ If the `units-specs` is omitted, the `quantity` object is formatted as if by str
additional padding and adjustments as specified by the format specifiers. additional padding and adjustments as specified by the format specifiers.
```cpp ```cpp
std::string s = fmt::format("{:=>12}", 120_kmph); // value of s is "====120 km/h" std::string s = fmt::format("{:=>12}", 120q_kmph); // value of s is "====120 km/h"
``` ```
@@ -732,14 +732,14 @@ predefined by the user in the downcasting facility. A typical example of such a
temporary results of calculations: temporary results of calculations:
```cpp ```cpp
units::Length auto d1 = 123m; units::Length auto d1 = 123q_m;
units::Time auto t1 = 10s; units::Time auto t1 = 10q_s;
units::Velocity auto v1 = avg_speed(d1, t1); units::Velocity auto v1 = avg_speed(d1, t1);
auto temp1 = v1 * 50m; // intermediate unknown dimension auto temp1 = v1 * 50q_m; // intermediate unknown dimension
units::Velocity auto v2 = temp1 / 100m; // back to known dimensions again units::Velocity auto v2 = temp1 / 100q_m; // back to known dimensions again
units::Length auto d2 = v2 * 60s; units::Length auto d2 = v2 * 60q_s;
``` ```
To provide support to form an unknown derived dimension that could be than be converted to a To provide support to form an unknown derived dimension that could be than be converted to a
@@ -825,12 +825,12 @@ adds support for digital information quantities. In summary it adds:
namespace units::data::inline literals { namespace units::data::inline literals {
// bits // bits
constexpr auto operator""b(unsigned long long l) { return information<bit, std::int64_t>(l); } constexpr auto operator"" q_b(unsigned long long l) { return information<bit, std::int64_t>(l); }
constexpr auto operator""Kib(unsigned long long l) { return information<kibibit, std::int64_t>(l); } constexpr auto operator"" q_Kib(unsigned long long l) { return information<kibibit, std::int64_t>(l); }
// bytes // bytes
constexpr auto operator""B(unsigned long long l) { return information<byte, std::int64_t>(l); } constexpr auto operator"" q_B(unsigned long long l) { return information<byte, std::int64_t>(l); }
constexpr auto operator""KiB(unsigned long long l) { return information<kibibyte, std::int64_t>(l); } constexpr auto operator"" q_KiB(unsigned long long l) { return information<kibibyte, std::int64_t>(l); }
} }
``` ```
@@ -854,8 +854,8 @@ adds support for digital information quantities. In summary it adds:
inline namespace literals { inline namespace literals {
// bits // bits
constexpr auto operator""_bps(unsigned long long l) { return bitrate<bit_per_second, std::int64_t>(l); } constexpr auto operator"" q_bps(unsigned long long l) { return bitrate<bit_per_second, std::int64_t>(l); }
constexpr auto operator""_Kibps(unsigned long long l) { return bitrate<kibibit_per_second, std::int64_t>(l); } constexpr auto operator"" q_Kibps(unsigned long long l) { return bitrate<kibibit_per_second, std::int64_t>(l); }
} }

18
example/avg_velocity.cpp
View File

@@ -68,7 +68,7 @@ void example()
// SI (int) // SI (int)
{ {
using namespace units::si::literals; using namespace units::si::literals;
constexpr Length AUTO distance = 220km; // constructed from a UDL constexpr Length AUTO distance = 220q_km; // constructed from a UDL
constexpr si::time<si::hour, int> duration(2); // constructed from a value constexpr si::time<si::hour, int> duration(2); // constructed from a value
std::cout << "SI units with 'int' as representation\n"; std::cout << "SI units with 'int' as representation\n";
@@ -82,8 +82,8 @@ void example()
// SI (double) // SI (double)
{ {
using namespace units::si::literals; using namespace units::si::literals;
constexpr Length AUTO distance = 220.km; // constructed from a UDL constexpr Length AUTO distance = 220.q_km; // constructed from a UDL
constexpr si::time<si::hour> duration(2); // constructed from a value constexpr si::time<si::hour> duration(2); // constructed from a value
std::cout << "\nSI units with 'double' as representation\n"; std::cout << "\nSI units with 'double' as representation\n";
@@ -98,7 +98,7 @@ void example()
// Customary Units (int) // Customary Units (int)
{ {
using namespace units::international::literals; using namespace units::international::literals;
constexpr Length AUTO distance = 140mi; // constructed from a UDL constexpr Length AUTO distance = 140q_mi; // constructed from a UDL
constexpr si::time<si::hour, int> duration(2); // constructed from a value constexpr si::time<si::hour, int> duration(2); // constructed from a value
std::cout << "\nUS Customary Units with 'int' as representation\n"; std::cout << "\nUS Customary Units with 'int' as representation\n";
@@ -114,7 +114,7 @@ void example()
// Customary Units (double) // Customary Units (double)
{ {
using namespace units::international::literals; using namespace units::international::literals;
constexpr Length AUTO distance = 140.mi; // constructed from a UDL constexpr Length AUTO distance = 140q_mi; // constructed from a UDL
constexpr si::time<si::hour> duration(2); // constructed from a value constexpr si::time<si::hour> duration(2); // constructed from a value
std::cout << "\nUS Customary Units with 'double' as representation\n"; std::cout << "\nUS Customary Units with 'double' as representation\n";
@@ -132,8 +132,8 @@ void example()
// CGS (int) // CGS (int)
{ {
using namespace units::cgs::literals; using namespace units::cgs::literals;
constexpr Length AUTO distance = 22'000'000cm; // constructed from a UDL constexpr Length AUTO distance = 22'000'000q_cm; // constructed from a UDL
constexpr cgs::time<si::hour, int> duration(2); // constructed from a value constexpr cgs::time<si::hour, int> duration(2); // constructed from a value
std::cout << "\nCGS units with 'int' as representation\n"; std::cout << "\nCGS units with 'int' as representation\n";
@@ -151,8 +151,8 @@ void example()
// CGS (double) // CGS (double)
{ {
using namespace units::cgs::literals; using namespace units::cgs::literals;
constexpr Length AUTO distance = 22'000'000.cm; // constructed from a UDL constexpr Length AUTO distance = 22'000'000q_cm; // constructed from a UDL
constexpr cgs::time<si::hour> duration(2); // constructed from a value constexpr cgs::time<si::hour> duration(2); // constructed from a value
std::cout << "\nCGS units with 'double' as representation\n"; std::cout << "\nCGS units with 'double' as representation\n";

8
example/box_example.cpp
View File

@@ -101,11 +101,11 @@ struct Box {
using namespace units::si::literals; using namespace units::si::literals;
int main() int main()
{ {
auto box = Box{1000.0mm, 500.0mm, 200.0mm}; auto box = Box{1000.0q_mm, 500.0q_mm, 200.0q_mm};
box.set_contents_density(1000.0kgpm3); box.set_contents_density(1000.0q_kgpm3);
auto fill_time = 200.0s; // time since starting fill auto fill_time = 200.0q_s; // time since starting fill
auto measured_mass = 20.0kg; // measured mass at fill_time auto measured_mass = 20.0q_kg; // measured mass at fill_time
std::cout << "mpusz/units box example...\n"; std::cout << "mpusz/units box example...\n";
std::cout << "fill height at " << fill_time << " = " << box.fill_level(measured_mass) << " (" std::cout << "fill height at " << fill_time << " = " << box.fill_level(measured_mass) << " ("

16
example/capacitor_time_curve.cpp
View File

@@ -56,22 +56,22 @@ int main()
std::cout.setf(std::ios_base::fixed, std::ios_base::floatfield); std::cout.setf(std::ios_base::fixed, std::ios_base::floatfield);
std::cout.precision(3); std::cout.precision(3);
constexpr auto C = 0.47uF; constexpr auto C = 0.47q_uF;
constexpr auto V0 = 5.0V; constexpr auto V0 = 5.0q_V;
constexpr auto R = 4.7kR; constexpr auto R = 4.7q_kR;
for (auto t = 0ms; t <= 50ms; ++t) { for (auto t = 0q_ms; t <= 50q_ms; ++t) {
const auto Vt = V0 * std::exp(-t / (R * C)); const auto Vt = V0 * std::exp(-t / (R * C));
std::cout << "at " << t << " voltage is "; std::cout << "at " << t << " voltage is ";
if (Vt >= 1V) if (Vt >= 1q_V)
std::cout << Vt; std::cout << Vt;
else if (Vt >= 1mV) else if (Vt >= 1q_mV)
std::cout << voltage::mV<>{Vt}; std::cout << voltage::mV<>{Vt};
else if (Vt >= 1uV) else if (Vt >= 1q_uV)
std::cout << voltage::uV<>{Vt}; std::cout << voltage::uV<>{Vt};
else if (Vt >= 1nV) else if (Vt >= 1q_nV)
std::cout << voltage::nV<>{Vt}; std::cout << voltage::nV<>{Vt};
else else
std::cout << voltage::pV<>{Vt}; std::cout << voltage::pV<>{Vt};

26
example/clcpp_response.cpp
View File

@@ -130,12 +130,12 @@ void simple_quantities()
using distance = length::m<>; using distance = length::m<>;
using time = time::s<>; using time = time::s<>;
constexpr distance km = 1.0km; constexpr distance km = 1.0q_km;
constexpr distance miles = 1.0mi; constexpr distance miles = 1.0q_mi;
constexpr time sec = 1s; constexpr time sec = 1q_s;
constexpr time min = 1min; constexpr time min = 1q_min;
constexpr time hr = 1h; constexpr time hr = 1q_h;
std::cout << "A physical quantities library can choose the simple\n"; std::cout << "A physical quantities library can choose the simple\n";
std::cout << "option to provide output using a single type for each base unit:\n\n"; std::cout << "option to provide output using a single type for each base unit:\n\n";
@@ -148,14 +148,14 @@ void simple_quantities()
void quantities_with_typed_units() void quantities_with_typed_units()
{ {
constexpr length::km<> km = 1.0km; constexpr length::km<> km = 1.0q_km;
constexpr length::mi<> miles = 1.0mi; constexpr length::mi<> miles = 1.0q_mi;
std::cout.precision(6); std::cout.precision(6);
constexpr time::s<> sec = 1s; constexpr time::s<> sec = 1q_s;
constexpr time::min<> min = 1min; constexpr time::min<> min = 1q_min;
constexpr time::h<> hr = 1h; constexpr time::h<> hr = 1q_h;
std::cout << "A more flexible option is to provide separate types for each unit,\n\n"; std::cout << "A more flexible option is to provide separate types for each unit,\n\n";
std::cout << km << '\n'; std::cout << km << '\n';
@@ -164,7 +164,7 @@ void quantities_with_typed_units()
std::cout << min << '\n'; std::cout << min << '\n';
std::cout << hr << "\n\n"; std::cout << hr << "\n\n";
constexpr length::m<> meter = 1m; constexpr length::m<> meter = 1q_m;
std::cout << "then a wide range of pre-defined units can be defined and converted,\n" std::cout << "then a wide range of pre-defined units can be defined and converted,\n"
" for consistency and repeatability across applications:\n\n"; " for consistency and repeatability across applications:\n\n";
@@ -197,8 +197,8 @@ void calcs_comparison()
"when adding two values of the same very big\n" "when adding two values of the same very big\n"
"or very small type:\n\n"; "or very small type:\n\n";
length::fm<float> L1A = 2fm; length::fm<float> L1A = 2q_fm;
length::fm<float> L2A = 3fm; length::fm<float> L2A = 3q_fm;
length::fm<float> LrA = L1A + L2A; length::fm<float> LrA = L1A + L2A;
std::cout << L1A << " + " << L2A << " = " << LrA << "\n\n"; std::cout << L1A << " + " << L2A << " = " << LrA << "\n\n";

2
example/conversion_factor.cpp
View File

@@ -64,7 +64,7 @@ int main()
{ {
std::cout << "conversion factor in mpusz/units...\n\n"; std::cout << "conversion factor in mpusz/units...\n\n";
constexpr length::m<> lengthA = 2.0m; constexpr length::m<> lengthA = 2.0q_m;
constexpr length::mm<> lengthB = lengthA; constexpr length::mm<> lengthB = lengthA;
std::cout << "lengthA( " << lengthA << " ) and lengthB( " << lengthB << " )\n" std::cout << "lengthA( " << lengthA << " ) and lengthB( " << lengthB << " )\n"

2
example/hello_units.cpp
View File

@@ -35,7 +35,7 @@ constexpr Velocity AUTO avg_speed(Length AUTO d, Time AUTO t)
int main() int main()
{ {
using namespace si::literals; using namespace si::literals;
Velocity AUTO v1 = avg_speed(220km, 2h); Velocity AUTO v1 = avg_speed(220q_km, 2q_h);
Velocity AUTO v2 = avg_speed(si::length<international::mile>(140), si::time<si::hour>(2)); Velocity AUTO v2 = avg_speed(si::length<international::mile>(140), si::time<si::hour>(2));
Velocity AUTO v3 = quantity_cast<si::metre_per_second>(v2); Velocity AUTO v3 = quantity_cast<si::metre_per_second>(v2);
Velocity AUTO v4 = quantity_cast<int>(v3); Velocity AUTO v4 = quantity_cast<int>(v3);

10
example/unknown_dimension.cpp
View File

@@ -35,13 +35,13 @@ void example()
{ {
using namespace units::si::literals; using namespace units::si::literals;
units::Length AUTO d1 = 123m; units::Length AUTO d1 = 123q_m;
units::Time AUTO t1 = 10s; units::Time AUTO t1 = 10q_s;
units::Velocity AUTO v1 = avg_speed(d1, t1); units::Velocity AUTO v1 = avg_speed(d1, t1);
auto temp1 = v1 * 50m; // produces intermediate unknown dimension with 'unknown_unit' as its 'coherent_unit' auto temp1 = v1 * 50q_m; // produces intermediate unknown dimension with 'unknown_unit' as its 'coherent_unit'
units::Velocity AUTO v2 = temp1 / 100m; // back to known dimensions again units::Velocity AUTO v2 = temp1 / 100q_m; // back to known dimensions again
units::Length AUTO d2 = v2 * 60s; units::Length AUTO d2 = v2 * 60q_s;
std::cout << "d1 = " << d1 << '\n'; std::cout << "d1 = " << d1 << '\n';
std::cout << "t1 = " << t1 << '\n'; std::cout << "t1 = " << t1 << '\n';

12
src/include/units/data/bitrate.h
View File

@@ -47,12 +47,12 @@ using bitrate = quantity<dim_bitrate, U, Rep>;
inline namespace literals { inline namespace literals {
// bits // bits
constexpr auto operator""bps(unsigned long long l) { return bitrate<bit_per_second, std::int64_t>(l); } constexpr auto operator"" q_bps(unsigned long long l) { return bitrate<bit_per_second, std::int64_t>(l); }
constexpr auto operator""Kibps(unsigned long long l) { return bitrate<kibibit_per_second, std::int64_t>(l); } constexpr auto operator"" q_Kibps(unsigned long long l) { return bitrate<kibibit_per_second, std::int64_t>(l); }
constexpr auto operator""Mibps(unsigned long long l) { return bitrate<mebibit_per_second, std::int64_t>(l); } constexpr auto operator"" q_Mibps(unsigned long long l) { return bitrate<mebibit_per_second, std::int64_t>(l); }
constexpr auto operator""Gibps(unsigned long long l) { return bitrate<gibibit_per_second, std::int64_t>(l); } constexpr auto operator"" q_Gibps(unsigned long long l) { return bitrate<gibibit_per_second, std::int64_t>(l); }
constexpr auto operator""Tibps(unsigned long long l) { return bitrate<tebibit_per_second, std::int64_t>(l); } constexpr auto operator"" q_Tibps(unsigned long long l) { return bitrate<tebibit_per_second, std::int64_t>(l); }
constexpr auto operator""sPibps(unsigned long long l) { return bitrate<pebibit_per_second, std::int64_t>(l); } constexpr auto operator"" q_sPibps(unsigned long long l) { return bitrate<pebibit_per_second, std::int64_t>(l); }
} // namespace literals } // namespace literals

24
src/include/units/data/information.h
View File

@@ -54,20 +54,20 @@ using information = quantity<dim_information, U, Rep>;
inline namespace literals { inline namespace literals {
// bits // bits
constexpr auto operator""b(unsigned long long l) { return information<bit, std::int64_t>(l); } constexpr auto operator"" q_b(unsigned long long l) { return information<bit, std::int64_t>(l); }
constexpr auto operator""Kib(unsigned long long l) { return information<kibibit, std::int64_t>(l); } constexpr auto operator"" q_Kib(unsigned long long l) { return information<kibibit, std::int64_t>(l); }
constexpr auto operator""Mib(unsigned long long l) { return information<mebibit, std::int64_t>(l); } constexpr auto operator"" q_Mib(unsigned long long l) { return information<mebibit, std::int64_t>(l); }
constexpr auto operator""Gib(unsigned long long l) { return information<gibibit, std::int64_t>(l); } constexpr auto operator"" q_Gib(unsigned long long l) { return information<gibibit, std::int64_t>(l); }
constexpr auto operator""Tib(unsigned long long l) { return information<tebibit, std::int64_t>(l); } constexpr auto operator"" q_Tib(unsigned long long l) { return information<tebibit, std::int64_t>(l); }
constexpr auto operator""Pib(unsigned long long l) { return information<pebibit, std::int64_t>(l); } constexpr auto operator"" q_Pib(unsigned long long l) { return information<pebibit, std::int64_t>(l); }
// bytes // bytes
constexpr auto operator""B(unsigned long long l) { return information<byte, std::int64_t>(l); } constexpr auto operator"" q_B(unsigned long long l) { return information<byte, std::int64_t>(l); }
constexpr auto operator""KiB(unsigned long long l) { return information<kibibyte, std::int64_t>(l); } constexpr auto operator"" q_KiB(unsigned long long l) { return information<kibibyte, std::int64_t>(l); }
constexpr auto operator""MiB(unsigned long long l) { return information<mebibyte, std::int64_t>(l); } constexpr auto operator"" q_MiB(unsigned long long l) { return information<mebibyte, std::int64_t>(l); }
constexpr auto operator""GiB(unsigned long long l) { return information<gibibyte, std::int64_t>(l); } constexpr auto operator"" q_GiB(unsigned long long l) { return information<gibibyte, std::int64_t>(l); }
constexpr auto operator""TiB(unsigned long long l) { return information<tebibyte, std::int64_t>(l); } constexpr auto operator"" q_TiB(unsigned long long l) { return information<tebibyte, std::int64_t>(l); }
constexpr auto operator""PiB(unsigned long long l) { return information<pebibyte, std::int64_t>(l); } constexpr auto operator"" q_PiB(unsigned long long l) { return information<pebibyte, std::int64_t>(l); }
} // namespace literals } // namespace literals

4
src/include/units/physical/cgs/acceleration.h
View File

@@ -37,8 +37,8 @@ using acceleration = quantity<dim_acceleration, U, Rep>;
inline namespace literals { inline namespace literals {
// Gal // Gal
constexpr auto operator""Gal(unsigned long long l) { return acceleration<gal, std::int64_t>(l); } constexpr auto operator"" q_Gal(unsigned long long l) { return acceleration<gal, std::int64_t>(l); }
constexpr auto operator""Gal(long double l) { return acceleration<gal, long double>(l); } constexpr auto operator"" q_Gal(long double l) { return acceleration<gal, long double>(l); }
} // namespace literals } // namespace literals

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

@@ -39,8 +39,8 @@ using area = quantity<dim_area, U, Rep>;
inline namespace literals { inline namespace literals {
// cm2 // cm2
constexpr auto operator"" cm2(unsigned long long l) { return area<square_centimetre, std::int64_t>(l); } constexpr auto operator"" q_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); } constexpr auto operator"" q_cm2(long double l) { return area<square_centimetre, long double>(l); }
} }

4
src/include/units/physical/cgs/energy.h
View File

@@ -39,8 +39,8 @@ using energy = quantity<dim_energy, U, Rep>;
inline namespace literals { inline namespace literals {
// erg // erg
constexpr auto operator""_erg(unsigned long long l) { return energy<erg, std::int64_t>(l); } constexpr auto operator"" q_erg(unsigned long long l) { return energy<erg, std::int64_t>(l); }
constexpr auto operator""_erg(long double l) { return energy<erg, long double>(l); } constexpr auto operator"" q_erg(long double l) { return energy<erg, long double>(l); }
} // namespace literals } // namespace literals

4
src/include/units/physical/cgs/force.h
View File

@@ -40,8 +40,8 @@ using force = quantity<dim_force, U, Rep>;
inline namespace literals { inline namespace literals {
// dyn // dyn
constexpr auto operator""dyn(unsigned long long l) { return force<dyne, std::int64_t>(l); } constexpr auto operator"" q_dyn(unsigned long long l) { return force<dyne, std::int64_t>(l); }
constexpr auto operator""dyn(long double l) { return force<dyne, long double>(l); } constexpr auto operator"" q_dyn(long double l) { return force<dyne, long double>(l); }
} // namespace literals } // namespace literals

4
src/include/units/physical/cgs/length.h
View File

@@ -38,8 +38,8 @@ using length = quantity<dim_length, U, Rep>;
inline namespace literals { inline namespace literals {
// cm // cm
constexpr auto operator"" cm(unsigned long long l) { return length<centimetre, std::int64_t>(l); } constexpr auto operator"" q_cm(unsigned long long l) { return length<centimetre, std::int64_t>(l); }
constexpr auto operator"" cm(long double l) { return length<centimetre, long double>(l); } constexpr auto operator"" q_cm(long double l) { return length<centimetre, long double>(l); }
} }

4
src/include/units/physical/cgs/mass.h
View File

@@ -38,8 +38,8 @@ using mass = quantity<dim_mass, U, Rep>;
inline namespace literals { inline namespace literals {
// g // g
constexpr auto operator""g(unsigned long long l) { return mass<gram, std::int64_t>(l); } constexpr auto operator"" q_g(unsigned long long l) { return mass<gram, std::int64_t>(l); }
constexpr auto operator""g(long double l) { return mass<gram, long double>(l); } constexpr auto operator"" q_g(long double l) { return mass<gram, long double>(l); }
} }

4
src/include/units/physical/cgs/power.h
View File

@@ -39,8 +39,8 @@ using power = quantity<dim_power, U, Rep>;
inline namespace literals { inline namespace literals {
// ergps // ergps
constexpr auto operator""_ergps(unsigned long long l) { return power<erg_per_second, std::int64_t>(l); } constexpr auto operator"" q_ergps(unsigned long long l) { return power<erg_per_second, std::int64_t>(l); }
constexpr auto operator""_ergps(long double l) { return power<erg_per_second, long double>(l); } constexpr auto operator"" q_ergps(long double l) { return power<erg_per_second, long double>(l); }
} // namespace literals } // namespace literals

4
src/include/units/physical/cgs/pressure.h
View File

@@ -40,8 +40,8 @@ using pressure = quantity<dim_pressure, U, Rep>;
inline namespace literals { inline namespace literals {
// Ba // Ba
constexpr auto operator""Ba(unsigned long long l) { return pressure<barye, std::int64_t>(l); } constexpr auto operator"" q_Ba(unsigned long long l) { return pressure<barye, std::int64_t>(l); }
constexpr auto operator""Ba(long double l) { return pressure<barye, long double>(l); } constexpr auto operator"" q_Ba(long double l) { return pressure<barye, long double>(l); }
} // namespace literals } // namespace literals

2
src/include/units/physical/cgs/time.h
View File

@@ -35,7 +35,7 @@ using si::time;
inline namespace literals { inline namespace literals {
using si::literals::operator"" s; using si::literals::operator"" q_s;
} }

4
src/include/units/physical/cgs/velocity.h
View File

@@ -38,8 +38,8 @@ using velocity = quantity<dim_velocity, U, Rep>;
inline namespace literals { inline namespace literals {
// cmps // cmps
constexpr auto operator"" cmps(unsigned long long l) { return velocity<centimetre_per_second, std::int64_t>(l); } constexpr auto operator"" q_cmps(unsigned long long l) { return velocity<centimetre_per_second, std::int64_t>(l); }
constexpr auto operator"" cmps(long double l) { return velocity<centimetre_per_second, long double>(l); } constexpr auto operator"" q_cmps(long double l) { return velocity<centimetre_per_second, long double>(l); }
} // namespace literals } // namespace literals

12
src/include/units/physical/iau/length.h
View File

@@ -38,14 +38,14 @@ struct angstrom : named_scaled_unit<angstrom, "angstrom", no_prefix, ratio<1, 1,
inline namespace literals { inline namespace literals {
constexpr auto operator"" ly(unsigned long long l) { return si::length<light_year, std::int64_t>(l); } constexpr auto operator"" q_ly(unsigned long long l) { return si::length<light_year, std::int64_t>(l); }
constexpr auto operator"" ly(long double l) { return si::length<light_year, long double>(l); } constexpr auto operator"" q_ly(long double l) { return si::length<light_year, long double>(l); }
constexpr auto operator"" pc(unsigned long long l) { return si::length<parsec, std::int64_t>(l); } constexpr auto operator"" q_pc(unsigned long long l) { return si::length<parsec, std::int64_t>(l); }
constexpr auto operator"" pc(long double l) { return si::length<parsec, long double>(l); } constexpr auto operator"" q_pc(long double l) { return si::length<parsec, long double>(l); }
constexpr auto operator"" angstrom(unsigned long long l) { return si::length<angstrom, std::int64_t>(l); } constexpr auto operator"" q_angstrom(unsigned long long l) { return si::length<angstrom, std::int64_t>(l); }
constexpr auto operator"" angstrom(long double l) { return si::length<angstrom, long double>(l); } constexpr auto operator"" q_angstrom(long double l) { return si::length<angstrom, long double>(l); }
} // namespace literals } // namespace literals

8
src/include/units/physical/imperial/length.h
View File

@@ -34,11 +34,11 @@ struct rod : named_scaled_unit<rod, "rd", no_prefix, ratio<1, 4>, chain> {};
inline namespace literals { inline namespace literals {
constexpr auto operator"" ch(unsigned long long l) { return si::length<chain, std::int64_t>(l); } constexpr auto operator"" q_ch(unsigned long long l) { return si::length<chain, std::int64_t>(l); }
constexpr auto operator"" ch(long double l) { return si::length<chain, long double>(l); } constexpr auto operator"" q_ch(long double l) { return si::length<chain, long double>(l); }
constexpr auto operator"" rd(unsigned long long l) { return si::length<rod, std::int64_t>(l); } constexpr auto operator"" q_rd(unsigned long long l) { return si::length<rod, std::int64_t>(l); }
constexpr auto operator"" rd(long double l) { return si::length<rod, long double>(l); } constexpr auto operator"" q_rd(long double l) { return si::length<rod, long double>(l); }
} // namespace literals } // namespace literals

4
src/include/units/physical/international/area.h
View File

@@ -32,8 +32,8 @@ struct square_foot : deduced_unit<square_foot, si::dim_area, international::foot
inline namespace literals { inline namespace literals {
// ft2 // ft2
constexpr auto operator"" ft2(unsigned long long l) { return si::area<square_foot, std::int64_t>(l); } constexpr auto operator"" q_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); } constexpr auto operator"" q_ft2(long double l) { return si::area<square_foot, long double>(l); }
} // namespace literals } // namespace literals

32
src/include/units/physical/international/length.h
View File

@@ -61,36 +61,36 @@ using mil = thou;
inline namespace literals { inline namespace literals {
// yd // yd
constexpr auto operator"" yd(unsigned long long l) { return si::length<yard, std::int64_t>(l); } constexpr auto operator"" q_yd(unsigned long long l) { return si::length<yard, std::int64_t>(l); }
constexpr auto operator"" yd(long double l) { return si::length<yard, long double>(l); } constexpr auto operator"" q_yd(long double l) { return si::length<yard, long double>(l); }
// ft // ft
constexpr auto operator"" ft(unsigned long long l) { return si::length<foot, std::int64_t>(l); } constexpr auto operator"" q_ft(unsigned long long l) { return si::length<foot, std::int64_t>(l); }
constexpr auto operator"" ft(long double l) { return si::length<foot, long double>(l); } constexpr auto operator"" q_ft(long double l) { return si::length<foot, long double>(l); }
// fathom // fathom
constexpr auto operator"" fathom(unsigned long long l) { return si::length<fathom, std::int64_t>(l); } constexpr auto operator"" q_fathom(unsigned long long l) { return si::length<fathom, std::int64_t>(l); }
constexpr auto operator"" fathom(long double l) { return si::length<fathom, long double>(l); } constexpr auto operator"" q_fathom(long double l) { return si::length<fathom, long double>(l); }
// in // in
constexpr auto operator"" in(unsigned long long l) { return si::length<inch, std::int64_t>(l); } constexpr auto operator"" q_in(unsigned long long l) { return si::length<inch, std::int64_t>(l); }
constexpr auto operator"" in(long double l) { return si::length<inch, long double>(l); } constexpr auto operator"" q_in(long double l) { return si::length<inch, long double>(l); }
// mi // mi
constexpr auto operator"" mi(unsigned long long l) { return si::length<mile, std::int64_t>(l); } constexpr auto operator"" q_mi(unsigned long long l) { return si::length<mile, std::int64_t>(l); }
constexpr auto operator"" mi(long double l) { return si::length<mile, long double>(l); } constexpr auto operator"" q_mi(long double l) { return si::length<mile, long double>(l); }
// mi_naut // mi_naut
constexpr auto operator"" naut_mi(unsigned long long l) { return si::length<nautical_mile, std::int64_t>(l); } constexpr auto operator"" q_naut_mi(unsigned long long l) { return si::length<nautical_mile, std::int64_t>(l); }
constexpr auto operator"" naut_mi(long double l) { return si::length<nautical_mile, long double>(l); } constexpr auto operator"" q_naut_mi(long double l) { return si::length<nautical_mile, long double>(l); }
// thou // thou
constexpr auto operator"" thou(unsigned long long l) { return si::length<thou, std::int64_t>(l); } constexpr auto operator"" q_thou(unsigned long long l) { return si::length<thou, std::int64_t>(l); }
constexpr auto operator"" thou(long double l) { return si::length<thou, long double>(l); } constexpr auto operator"" q_thou(long double l) { return si::length<thou, long double>(l); }
// mil // mil
constexpr auto operator"" mil(unsigned long long l) { return si::length<mil, std::int64_t>(l); } constexpr auto operator"" q_mil(unsigned long long l) { return si::length<mil, std::int64_t>(l); }
constexpr auto operator"" mil(long double l) { return si::length<mil, long double>(l); } constexpr auto operator"" q_mil(long double l) { return si::length<mil, long double>(l); }
} // namespace literals } // namespace literals

4
src/include/units/physical/international/velocity.h
View File

@@ -32,8 +32,8 @@ struct mile_per_hour : deduced_unit<mile_per_hour, si::dim_velocity, internation
inline namespace literals { inline namespace literals {
// mph // mph
constexpr auto operator"" mph(unsigned long long l) { return si::velocity<mile_per_hour, std::int64_t>(l); } constexpr auto operator"" q_mph(unsigned long long l) { return si::velocity<mile_per_hour, std::int64_t>(l); }
constexpr auto operator"" mph(long double l) { return si::velocity<mile_per_hour, long double>(l); } constexpr auto operator"" q_mph(long double l) { return si::velocity<mile_per_hour, long double>(l); }
} // namespace literals } // namespace literals

4
src/include/units/physical/international/volume.h
View File

@@ -32,8 +32,8 @@ struct cubic_foot : deduced_unit<cubic_foot, si::dim_volume, international::foot
inline namespace literals { inline namespace literals {
// ft3 // ft3
constexpr auto operator""ft3(unsigned long long l) { return si::volume<cubic_foot, std::int64_t>(l); } constexpr auto operator"" q_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); } constexpr auto operator"" q_ft3(long double l) { return si::volume<cubic_foot, long double>(l); }
} // namespace literals } // namespace literals

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

@@ -37,8 +37,8 @@ using acceleration = quantity<dim_acceleration, U, Rep>;
inline namespace literals { inline namespace literals {
// mps2 // mps2
constexpr auto operator""mps2(unsigned long long l) { return acceleration<metre_per_second_sq, std::int64_t>(l); } constexpr auto operator"" q_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); } constexpr auto operator"" q_mps2(long double l) { return acceleration<metre_per_second_sq, long double>(l); }
} // namespace literals } // namespace literals

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

@@ -44,28 +44,28 @@ using area = quantity<dim_area, U, Rep>;
inline namespace literals { inline namespace literals {
// m2 // m2
constexpr auto operator"" m2(unsigned long long l) { return area<square_metre, std::int64_t>(l); } constexpr auto operator"" q_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); } constexpr auto operator"" q_m2(long double l) { return area<square_metre, long double>(l); }
// mm2 // mm2
constexpr auto operator"" mm2(unsigned long long l) { return area<square_millimetre, std::int64_t>(l); } constexpr auto operator"" q_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); } constexpr auto operator"" q_mm2(long double l) { return area<square_millimetre, long double>(l); }
// cm2 // cm2
constexpr auto operator"" cm2(unsigned long long l) { return area<square_centimetre, std::int64_t>(l); } constexpr auto operator"" q_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); } constexpr auto operator"" q_cm2(long double l) { return area<square_centimetre, long double>(l); }
// fm2 // fm2
constexpr auto operator"" fm2(unsigned long long l) { return area<square_femtometre, std::int64_t>(l); } constexpr auto operator"" q_fm2(unsigned long long l) { return area<square_femtometre, std::int64_t>(l); }
constexpr auto operator"" fm2(long double l) { return area<square_femtometre, long double>(l); } constexpr auto operator"" q_fm2(long double l) { return area<square_femtometre, long double>(l); }
// km2 // km2
constexpr auto operator"" km2(unsigned long long l) { return area<square_kilometre, std::int64_t>(l); } constexpr auto operator"" q_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); } constexpr auto operator"" q_km2(long double l) { return area<square_kilometre, long double>(l); }
// ha // ha
constexpr auto operator"" ha(unsigned long long l) { return area<hectare, std::int64_t>(l); } constexpr auto operator"" q_ha(unsigned long long l) { return area<hectare, std::int64_t>(l); }
constexpr auto operator"" ha(long double l) { return area<hectare, long double>(l); } constexpr auto operator"" q_ha(long double l) { return area<hectare, long double>(l); }
} // namespace literals } // namespace literals

20
src/include/units/physical/si/capacitance.h
View File

@@ -45,20 +45,20 @@ using capacitance = quantity<dim_capacitance, U, Rep>;
inline namespace literals { inline namespace literals {
// F // F
constexpr auto operator""F(unsigned long long l) { return capacitance<farad, std::int64_t>(l); } constexpr auto operator"" q_F(unsigned long long l) { return capacitance<farad, std::int64_t>(l); }
constexpr auto operator""_F(long double l) { return capacitance<farad, long double>(l); } constexpr auto operator"" q_F(long double l) { return capacitance<farad, long double>(l); }
constexpr auto operator""mF(unsigned long long l) { return capacitance<millifarad, std::int64_t>(l); } constexpr auto operator"" q_mF(unsigned long long l) { return capacitance<millifarad, std::int64_t>(l); }
constexpr auto operator""mF(long double l) { return capacitance<millifarad, long double>(l); } constexpr auto operator"" q_mF(long double l) { return capacitance<millifarad, long double>(l); }
constexpr auto operator""uF(unsigned long long l) { return capacitance<microfarad, std::int64_t>(l); } constexpr auto operator"" q_uF(unsigned long long l) { return capacitance<microfarad, std::int64_t>(l); }
constexpr auto operator""uF(long double l) { return capacitance<microfarad, long double>(l); } constexpr auto operator"" q_uF(long double l) { return capacitance<microfarad, long double>(l); }
constexpr auto operator""nF(unsigned long long l) { return capacitance<nanofarad, std::int64_t>(l); } constexpr auto operator"" q_nF(unsigned long long l) { return capacitance<nanofarad, std::int64_t>(l); }
constexpr auto operator""nF(long double l) { return capacitance<nanofarad, long double>(l); } constexpr auto operator"" q_nF(long double l) { return capacitance<nanofarad, long double>(l); }
constexpr auto operator""pF(unsigned long long l) { return capacitance<picofarad, std::int64_t>(l); } constexpr auto operator"" q_pF(unsigned long long l) { return capacitance<picofarad, std::int64_t>(l); }
constexpr auto operator""pF(long double l) { return capacitance<picofarad, long double>(l); } constexpr auto operator"" q_pF(long double l) { return capacitance<picofarad, long double>(l); }
} // namespace literals } // namespace literals

4
src/include/units/physical/si/current.h
View File

@@ -38,8 +38,8 @@ using current = quantity<dim_electric_current, U, Rep>;
inline namespace literals { inline namespace literals {
// A // A
constexpr auto operator""A(unsigned long long l) { return current<ampere, std::int64_t>(l); } constexpr auto operator"" q_A(unsigned long long l) { return current<ampere, std::int64_t>(l); }
constexpr auto operator""A(long double l) { return current<ampere, long double>(l); } constexpr auto operator"" q_A(long double l) { return current<ampere, long double>(l); }
} // namespace literals } // namespace literals

4
src/include/units/physical/si/density.h
View File

@@ -39,8 +39,8 @@ using density = quantity<dim_density, U, Rep>;
inline namespace literals { inline namespace literals {
constexpr auto operator"" kgpm3(unsigned long long l) { return density<kilogram_per_metre_cub, std::int64_t>(l); } constexpr auto operator"" q_kgpm3(unsigned long long l) { return density<kilogram_per_metre_cub, std::int64_t>(l); }
constexpr auto operator"" kgpm3(long double l) { return density<kilogram_per_metre_cub, long double>(l); } constexpr auto operator"" q_kgpm3(long double l) { return density<kilogram_per_metre_cub, long double>(l); }
} // namespace literals } // namespace literals

4
src/include/units/physical/si/electric_charge.h
View File

@@ -39,8 +39,8 @@ using electric_charge = quantity<dim_electric_charge, U, Rep>;
inline namespace literals { inline namespace literals {
// C // C
constexpr auto operator""C(unsigned long long l) { return electric_charge<coulomb, std::int64_t>(l); } constexpr auto operator"" q_C(unsigned long long l) { return electric_charge<coulomb, std::int64_t>(l); }
constexpr auto operator""C(long double l) { return electric_charge<coulomb, long double>(l); } constexpr auto operator"" q_C(long double l) { return electric_charge<coulomb, long double>(l); }
} // namespace literals } // namespace literals

28
src/include/units/physical/si/energy.h
View File

@@ -46,32 +46,32 @@ using energy = quantity<dim_energy, U, Rep>;
inline namespace literals { inline namespace literals {
// J // J
constexpr auto operator""_J(unsigned long long l) { return energy<joule, std::int64_t>(l); } constexpr auto operator"" q_J(unsigned long long l) { return energy<joule, std::int64_t>(l); }
constexpr auto operator""_J(long double l) { return energy<joule, long double>(l); } constexpr auto operator"" q_J(long double l) { return energy<joule, long double>(l); }
// mJ // mJ
constexpr auto operator""mJ(unsigned long long l) { return energy<millijoule, std::int64_t>(l); } constexpr auto operator"" q_mJ(unsigned long long l) { return energy<millijoule, std::int64_t>(l); }
constexpr auto operator""mJ(long double l) { return energy<millijoule, long double>(l); } constexpr auto operator"" q_mJ(long double l) { return energy<millijoule, long double>(l); }
// kJ // kJ
constexpr auto operator""kJ(unsigned long long l) { return energy<kilojoule, std::int64_t>(l); } constexpr auto operator"" q_kJ(unsigned long long l) { return energy<kilojoule, std::int64_t>(l); }
constexpr auto operator""kJ(long double l) { return energy<kilojoule, long double>(l); } constexpr auto operator"" q_kJ(long double l) { return energy<kilojoule, long double>(l); }
// MJ // MJ
constexpr auto operator""MJ(unsigned long long l) { return energy<megajoule, std::int64_t>(l); } constexpr auto operator"" q_MJ(unsigned long long l) { return energy<megajoule, std::int64_t>(l); }
constexpr auto operator""MJ(long double l) { return energy<megajoule, long double>(l); } constexpr auto operator"" q_MJ(long double l) { return energy<megajoule, long double>(l); }
// GJ // GJ
constexpr auto operator""GJ(unsigned long long l) { return energy<gigajoule, std::int64_t>(l); } constexpr auto operator"" q_GJ(unsigned long long l) { return energy<gigajoule, std::int64_t>(l); }
constexpr auto operator""GJ(long double l) { return energy<gigajoule, long double>(l); } constexpr auto operator"" q_GJ(long double l) { return energy<gigajoule, long double>(l); }
// eV // eV
constexpr auto operator""eV(unsigned long long l) { return energy<electronvolt, std::int64_t>(l); } constexpr auto operator"" q_eV(unsigned long long l) { return energy<electronvolt, std::int64_t>(l); }
constexpr auto operator""eV(long double l) { return energy<electronvolt, long double>(l); } constexpr auto operator"" q_eV(long double l) { return energy<electronvolt, long double>(l); }
// GeV // GeV
constexpr auto operator""GeV(unsigned long long l) { return energy<gigaelectronvolt, std::int64_t>(l); } constexpr auto operator"" q_GeV(unsigned long long l) { return energy<gigaelectronvolt, std::int64_t>(l); }
constexpr auto operator""GeV(long double l) { return energy<gigaelectronvolt, long double>(l); } constexpr auto operator"" q_GeV(long double l) { return energy<gigaelectronvolt, long double>(l); }
} // namespace literals } // namespace literals

4
src/include/units/physical/si/force.h
View File

@@ -40,8 +40,8 @@ using force = quantity<dim_force, U, Rep>;
inline namespace literals { inline namespace literals {
// N // N
constexpr auto operator""N(unsigned long long l) { return force<newton, std::int64_t>(l); } constexpr auto operator"" q_N(unsigned long long l) { return force<newton, std::int64_t>(l); }
constexpr auto operator""N(long double l) { return force<newton, long double>(l); } constexpr auto operator"" q_N(long double l) { return force<newton, long double>(l); }
} // namespace literals } // namespace literals

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

@@ -43,28 +43,28 @@ using frequency = quantity<dim_frequency, U, Rep>;
inline namespace literals { inline namespace literals {
// Hz // Hz
constexpr auto operator"" Hz(unsigned long long l) { return frequency<hertz, std::int64_t>(l); } constexpr auto operator"" q_Hz(unsigned long long l) { return frequency<hertz, std::int64_t>(l); }
constexpr auto operator"" Hz(long double l) { return frequency<hertz, long double>(l); } constexpr auto operator"" q_Hz(long double l) { return frequency<hertz, long double>(l); }
// mHz // mHz
constexpr auto operator"" mHz(unsigned long long l) { return frequency<millihertz, std::int64_t>(l); } constexpr auto operator"" q_mHz(unsigned long long l) { return frequency<millihertz, std::int64_t>(l); }
constexpr auto operator"" mHz(long double l) { return frequency<millihertz, long double>(l); } constexpr auto operator"" q_mHz(long double l) { return frequency<millihertz, long double>(l); }
// kHz // kHz
constexpr auto operator"" kHz(unsigned long long l) { return frequency<kilohertz, std::int64_t>(l); } constexpr auto operator"" q_kHz(unsigned long long l) { return frequency<kilohertz, std::int64_t>(l); }
constexpr auto operator"" kHz(long double l) { return frequency<kilohertz, long double>(l); } constexpr auto operator"" q_kHz(long double l) { return frequency<kilohertz, long double>(l); }
// MHz // MHz
constexpr auto operator"" MHz(unsigned long long l) { return frequency<megahertz, std::int64_t>(l); } constexpr auto operator"" q_MHz(unsigned long long l) { return frequency<megahertz, std::int64_t>(l); }
constexpr auto operator"" MHz(long double l) { return frequency<megahertz, long double>(l); } constexpr auto operator"" q_MHz(long double l) { return frequency<megahertz, long double>(l); }
// GHz // GHz
constexpr auto operator"" GHz(unsigned long long l) { return frequency<gigahertz, std::int64_t>(l); } constexpr auto operator"" q_GHz(unsigned long long l) { return frequency<gigahertz, std::int64_t>(l); }
constexpr auto operator"" GHz(long double l) { return frequency<gigahertz, long double>(l); } constexpr auto operator"" q_GHz(long double l) { return frequency<gigahertz, long double>(l); }
// THz // THz
constexpr auto operator"" THz(unsigned long long l) { return frequency<terahertz, std::int64_t>(l); } constexpr auto operator"" q_THz(unsigned long long l) { return frequency<terahertz, std::int64_t>(l); }
constexpr auto operator"" THz(long double l) { return frequency<terahertz, long double>(l); } constexpr auto operator"" q_THz(long double l) { return frequency<terahertz, long double>(l); }
} // namespace literals } // namespace literals

32
src/include/units/physical/si/length.h
View File

@@ -46,36 +46,36 @@ using length = quantity<dim_length, U, Rep>;
inline namespace literals { inline namespace literals {
// m // m
constexpr auto operator"" m(unsigned long long l) { return length<metre, std::int64_t>(l); } constexpr auto operator"" q_m(unsigned long long l) { return length<metre, std::int64_t>(l); }
constexpr auto operator"" m(long double l) { return length<metre, long double>(l); } constexpr auto operator"" q_m(long double l) { return length<metre, long double>(l); }
// fm // fm
constexpr auto operator"" fm(unsigned long long l) { return length<femtometre, std::int64_t>(l); } constexpr auto operator"" q_fm(unsigned long long l) { return length<femtometre, std::int64_t>(l); }
constexpr auto operator"" fm(long double l) { return length<femtometre, long double>(l); } constexpr auto operator"" q_fm(long double l) { return length<femtometre, long double>(l); }
// mm // mm
constexpr auto operator"" mm(unsigned long long l) { return length<millimetre, std::int64_t>(l); } constexpr auto operator"" q_mm(unsigned long long l) { return length<millimetre, std::int64_t>(l); }
constexpr auto operator"" mm(long double l) { return length<millimetre, long double>(l); } constexpr auto operator"" q_mm(long double l) { return length<millimetre, long double>(l); }
// cm // cm
constexpr auto operator"" cm(unsigned long long l) { return length<centimetre, std::int64_t>(l); } constexpr auto operator"" q_cm(unsigned long long l) { return length<centimetre, std::int64_t>(l); }
constexpr auto operator"" cm(long double l) { return length<centimetre, long double>(l); } constexpr auto operator"" q_cm(long double l) { return length<centimetre, long double>(l); }
// dm // dm
constexpr auto operator"" dm(unsigned long long l) { return length<decimetre, std::int64_t>(l); } constexpr auto operator"" q_dm(unsigned long long l) { return length<decimetre, std::int64_t>(l); }
constexpr auto operator"" dm(long double l) { return length<decimetre, long double>(l); } constexpr auto operator"" q_dm(long double l) { return length<decimetre, long double>(l); }
// hm // hm
constexpr auto operator"" hm(unsigned long long l) { return length<hectometre, std::int64_t>(l); } constexpr auto operator"" q_hm(unsigned long long l) { return length<hectometre, std::int64_t>(l); }
constexpr auto operator"" hm(long double l) { return length<hectometre, long double>(l); } constexpr auto operator"" q_hm(long double l) { return length<hectometre, long double>(l); }
// km // km
constexpr auto operator"" km(unsigned long long l) { return length<kilometre, std::int64_t>(l); } constexpr auto operator"" q_km(unsigned long long l) { return length<kilometre, std::int64_t>(l); }
constexpr auto operator"" km(long double l) { return length<kilometre, long double>(l); } constexpr auto operator"" q_km(long double l) { return length<kilometre, long double>(l); }
// au // au
constexpr auto operator"" au(unsigned long long l) { return length<astronomical_unit, std::int64_t>(l); } constexpr auto operator"" q_au(unsigned long long l) { return length<astronomical_unit, std::int64_t>(l); }
constexpr auto operator"" au(long double l) { return length<astronomical_unit, long double>(l); } constexpr auto operator"" q_au(long double l) { return length<astronomical_unit, long double>(l); }
} // namespace literals } // namespace literals

4
src/include/units/physical/si/luminous_intensity.h
View File

@@ -38,8 +38,8 @@ using luminous_intensity = quantity<dim_luminous_intensity, U, Rep>;
inline namespace literals { inline namespace literals {
// cd // cd
constexpr auto operator""cd(unsigned long long l) { return luminous_intensity<candela, std::int64_t>(l); } constexpr auto operator"" q_cd(unsigned long long l) { return luminous_intensity<candela, std::int64_t>(l); }
constexpr auto operator""cd(long double l) { return luminous_intensity<candela, long double>(l); } constexpr auto operator"" q_cd(long double l) { return luminous_intensity<candela, long double>(l); }
} // namespace literals } // namespace literals

16
src/include/units/physical/si/mass.h
View File

@@ -42,20 +42,20 @@ using mass = quantity<dim_mass, U, Rep>;
inline namespace literals { inline namespace literals {
// g // g
constexpr auto operator""g(unsigned long long l) { return mass<gram, std::int64_t>(l); } constexpr auto operator"" q_g(unsigned long long l) { return mass<gram, std::int64_t>(l); }
constexpr auto operator""g(long double l) { return mass<gram, long double>(l); } constexpr auto operator"" q_g(long double l) { return mass<gram, long double>(l); }
// kg // kg
constexpr auto operator""kg(unsigned long long l) { return mass<kilogram, std::int64_t>(l); } constexpr auto operator"" q_kg(unsigned long long l) { return mass<kilogram, std::int64_t>(l); }
constexpr auto operator""kg(long double l) { return mass<kilogram, long double>(l); } constexpr auto operator"" q_kg(long double l) { return mass<kilogram, long double>(l); }
// t // t
constexpr auto operator""t(unsigned long long l) { return mass<tonne, std::int64_t>(l); } constexpr auto operator"" q_t(unsigned long long l) { return mass<tonne, std::int64_t>(l); }
constexpr auto operator""t(long double l) { return mass<tonne, long double>(l); } constexpr auto operator"" q_t(long double l) { return mass<tonne, long double>(l); }
// Da // Da
constexpr auto operator""Da(unsigned long long l) { return mass<dalton, std::int64_t>(l); } constexpr auto operator"" q_Da(unsigned long long l) { return mass<dalton, std::int64_t>(l); }
constexpr auto operator""Da(long double l) { return mass<dalton, long double>(l); } constexpr auto operator"" q_Da(long double l) { return mass<dalton, long double>(l); }
} // namespace literals } // namespace literals

20
src/include/units/physical/si/power.h
View File

@@ -43,24 +43,24 @@ using power = quantity<dim_power, U, Rep>;
inline namespace literals { inline namespace literals {
// W // W
constexpr auto operator""W(unsigned long long l) { return power<watt, std::int64_t>(l); } constexpr auto operator"" q_W(unsigned long long l) { return power<watt, std::int64_t>(l); }
constexpr auto operator""_W(long double l) { return power<watt, long double>(l); } constexpr auto operator"" q_W(long double l) { return power<watt, long double>(l); }
// mW // mW
constexpr auto operator""mW(unsigned long long l) { return power<milliwatt, std::int64_t>(l); } constexpr auto operator"" q_mW(unsigned long long l) { return power<milliwatt, std::int64_t>(l); }
constexpr auto operator""mW(long double l) { return power<milliwatt, long double>(l); } constexpr auto operator"" q_mW(long double l) { return power<milliwatt, long double>(l); }
// kW // kW
constexpr auto operator""kW(unsigned long long l) { return power<kilowatt, std::int64_t>(l); } constexpr auto operator"" q_kW(unsigned long long l) { return power<kilowatt, std::int64_t>(l); }
constexpr auto operator""kW(long double l) { return power<kilowatt, long double>(l); } constexpr auto operator"" q_kW(long double l) { return power<kilowatt, long double>(l); }
// MW // MW
constexpr auto operator""MW(unsigned long long l) { return power<megawatt, std::int64_t>(l); } constexpr auto operator"" q_MW(unsigned long long l) { return power<megawatt, std::int64_t>(l); }
constexpr auto operator""MW(long double l) { return power<megawatt, long double>(l); } constexpr auto operator"" q_MW(long double l) { return power<megawatt, long double>(l); }
// GW // GW
constexpr auto operator""GW(unsigned long long l) { return power<gigawatt, std::int64_t>(l); } constexpr auto operator"" q_GW(unsigned long long l) { return power<gigawatt, std::int64_t>(l); }
constexpr auto operator""GW(long double l) { return power<gigawatt, long double>(l); } constexpr auto operator"" q_GW(long double l) { return power<gigawatt, long double>(l); }
} // namespace literals } // namespace literals

4
src/include/units/physical/si/pressure.h
View File

@@ -40,8 +40,8 @@ using pressure = quantity<dim_pressure, U, Rep>;
inline namespace literals { inline namespace literals {
// Pa // Pa
constexpr auto operator""Pa(unsigned long long l) { return pressure<pascal, std::int64_t>(l); } constexpr auto operator"" q_Pa(unsigned long long l) { return pressure<pascal, std::int64_t>(l); }
constexpr auto operator""Pa(long double l) { return pressure<pascal, long double>(l); } constexpr auto operator"" q_Pa(long double l) { return pressure<pascal, long double>(l); }
} // namespace literals } // namespace literals

16
src/include/units/physical/si/resistance.h
View File

@@ -43,20 +43,20 @@ using resistance = quantity<dim_resistance, U, Rep>;
inline namespace literals { inline namespace literals {
// R // R
constexpr auto operator""_R(unsigned long long l) { return resistance<ohm, std::int64_t>(l); } constexpr auto operator"" q_R(unsigned long long l) { return resistance<ohm, std::int64_t>(l); }
constexpr auto operator""_R(long double l) { return resistance<ohm, long double>(l); } constexpr auto operator"" q_R(long double l) { return resistance<ohm, long double>(l); }
// mR // mR
constexpr auto operator""mR(unsigned long long l) { return resistance<milliohm, std::int64_t>(l); } constexpr auto operator"" q_mR(unsigned long long l) { return resistance<milliohm, std::int64_t>(l); }
constexpr auto operator""mR(long double l) { return resistance<milliohm, long double>(l); } constexpr auto operator"" q_mR(long double l) { return resistance<milliohm, long double>(l); }
// kR // kR
constexpr auto operator""kR(unsigned long long l) { return resistance<kiloohm, std::int64_t>(l); } constexpr auto operator"" q_kR(unsigned long long l) { return resistance<kiloohm, std::int64_t>(l); }
constexpr auto operator""kR(long double l) { return resistance<kiloohm, long double>(l); } constexpr auto operator"" q_kR(long double l) { return resistance<kiloohm, long double>(l); }
// MR // MR
constexpr auto operator""MR(unsigned long long l) { return resistance<megaohm, std::int64_t>(l); } constexpr auto operator"" q_MR(unsigned long long l) { return resistance<megaohm, std::int64_t>(l); }
constexpr auto operator""MR(long double l) { return resistance<megaohm, long double>(l); } constexpr auto operator"" q_MR(long double l) { return resistance<megaohm, long double>(l); }
} // namespace literals } // namespace literals

4
src/include/units/physical/si/substance.h
View File

@@ -38,8 +38,8 @@ using substance = quantity<dim_substance, U, Rep>;
inline namespace literals { inline namespace literals {
// mol // mol
constexpr auto operator"" mol(unsigned long long l) { return substance<mole, std::int64_t>(l); } constexpr auto operator"" q_mol(unsigned long long l) { return substance<mole, std::int64_t>(l); }
constexpr auto operator"" mol(long double l) { return substance<mole, long double>(l); } constexpr auto operator"" q_mol(long double l) { return substance<mole, long double>(l); }
} // namespace literals } // namespace literals

4
src/include/units/physical/si/surface_tension.h
View File

@@ -38,8 +38,8 @@ using surface_tension = quantity<dim_surface_tension, U, Rep>;
inline namespace literals { inline namespace literals {
// Nm // Nm
constexpr auto operator""Npm(unsigned long long l) { return surface_tension<newton_per_metre, std::int64_t>(l); } constexpr auto operator"" q_Npm(unsigned long long l) { return surface_tension<newton_per_metre, std::int64_t>(l); }
constexpr auto operator""Npm(long double l) { return surface_tension<newton_per_metre, long double>(l); } constexpr auto operator"" q_Npm(long double l) { return surface_tension<newton_per_metre, long double>(l); }
} // namespace literals } // namespace literals

4
src/include/units/physical/si/temperature.h
View File

@@ -37,8 +37,8 @@ using temperature = quantity<dim_thermodynamic_temperature, U, Rep>;
inline namespace literals { inline namespace literals {
// K // K
constexpr auto operator""K(unsigned long long l) { return temperature<kelvin, std::int64_t>(l); } constexpr auto operator"" q_K(unsigned long long l) { return temperature<kelvin, std::int64_t>(l); }
constexpr auto operator""_K(long double l) { return temperature<kelvin, long double>(l); } // TODO: conflicts with gcc GNU extension constexpr auto operator"" q_K(long double l) { return temperature<kelvin, long double>(l); } // TODO: conflicts with gcc GNU extension
} // namespace literals } // namespace literals

28
src/include/units/physical/si/time.h
View File

@@ -44,32 +44,32 @@ using time = quantity<dim_time, U, Rep>;
inline namespace literals { inline namespace literals {
// ns // ns
constexpr auto operator""ns(unsigned long long l) { return time<nanosecond, std::int64_t>(l); } constexpr auto operator"" q_ns(unsigned long long l) { return time<nanosecond, std::int64_t>(l); }
constexpr auto operator""ns(long double l) { return time<nanosecond, long double>(l); } constexpr auto operator"" q_ns(long double l) { return time<nanosecond, long double>(l); }
// us // us
constexpr auto operator""us(unsigned long long l) { return time<microsecond, std::int64_t>(l); } constexpr auto operator"" q_us(unsigned long long l) { return time<microsecond, std::int64_t>(l); }
constexpr auto operator""us(long double l) { return time<microsecond, long double>(l); } constexpr auto operator"" q_us(long double l) { return time<microsecond, long double>(l); }
// ms // ms
constexpr auto operator""ms(unsigned long long l) { return time<millisecond, std::int64_t>(l); } constexpr auto operator"" q_ms(unsigned long long l) { return time<millisecond, std::int64_t>(l); }
constexpr auto operator""ms(long double l) { return time<millisecond, long double>(l); } constexpr auto operator"" q_ms(long double l) { return time<millisecond, long double>(l); }
// s // s
constexpr auto operator""s(unsigned long long l) { return time<second, std::int64_t>(l); } constexpr auto operator"" q_s(unsigned long long l) { return time<second, std::int64_t>(l); }
constexpr auto operator""s(long double l) { return time<second, long double>(l); } constexpr auto operator"" q_s(long double l) { return time<second, long double>(l); }
// min // min
constexpr auto operator""min(unsigned long long l) { return time<minute, std::int64_t>(l); } constexpr auto operator"" q_min(unsigned long long l) { return time<minute, std::int64_t>(l); }
constexpr auto operator""min(long double l) { return time<minute, long double>(l); } constexpr auto operator"" q_min(long double l) { return time<minute, long double>(l); }
// h // h
constexpr auto operator""h(unsigned long long l) { return time<hour, std::int64_t>(l); } constexpr auto operator"" q_h(unsigned long long l) { return time<hour, std::int64_t>(l); }
constexpr auto operator""h(long double l) { return time<hour, long double>(l); } constexpr auto operator"" q_h(long double l) { return time<hour, long double>(l); }
// d // d
constexpr auto operator""_d(unsigned long long l) { return time<day, std::int64_t>(l); } constexpr auto operator"" q_d(unsigned long long l) { return time<day, std::int64_t>(l); }
constexpr auto operator""_d(long double l) { return time<day, long double>(l); } constexpr auto operator"" q_d(long double l) { return time<day, long double>(l); }
} // namespace literals } // namespace literals

8
src/include/units/physical/si/velocity.h
View File

@@ -40,12 +40,12 @@ using velocity = quantity<dim_velocity, U, Rep>;
inline namespace literals { inline namespace literals {
// mps // mps
constexpr auto operator"" mps(unsigned long long l) { return velocity<metre_per_second, std::int64_t>(l); } constexpr auto operator"" q_mps(unsigned long long l) { return velocity<metre_per_second, std::int64_t>(l); }
constexpr auto operator"" mps(long double l) { return velocity<metre_per_second, long double>(l); } constexpr auto operator"" q_mps(long double l) { return velocity<metre_per_second, long double>(l); }
// kmph // kmph
constexpr auto operator"" kmph(unsigned long long l) { return velocity<kilometre_per_hour, std::int64_t>(l); } constexpr auto operator"" q_kmph(unsigned long long l) { return velocity<kilometre_per_hour, std::int64_t>(l); }
constexpr auto operator"" kmph(long double l) { return velocity<kilometre_per_hour, long double>(l); } constexpr auto operator"" q_kmph(long double l) { return velocity<kilometre_per_hour, long double>(l); }
} // namespace literals } // namespace literals

20
src/include/units/physical/si/voltage.h
View File

@@ -44,20 +44,20 @@ using voltage = quantity<dim_voltage, U, Rep>;
inline namespace literals { inline namespace literals {
// V // V
constexpr auto operator""V(unsigned long long l) { return voltage<volt, std::int64_t>(l); } constexpr auto operator"" q_V(unsigned long long l) { return voltage<volt, std::int64_t>(l); }
constexpr auto operator""V(long double l) { return voltage<volt, long double>(l); } constexpr auto operator"" q_V(long double l) { return voltage<volt, long double>(l); }
constexpr auto operator""mV(unsigned long long l) { return voltage<millivolt, std::int64_t>(l); } constexpr auto operator"" q_mV(unsigned long long l) { return voltage<millivolt, std::int64_t>(l); }
constexpr auto operator""mV(long double l) { return voltage<millivolt, long double>(l); } constexpr auto operator"" q_mV(long double l) { return voltage<millivolt, long double>(l); }
constexpr auto operator""uV(unsigned long long l) { return voltage<microvolt, std::int64_t>(l); } constexpr auto operator"" q_uV(unsigned long long l) { return voltage<microvolt, std::int64_t>(l); }
constexpr auto operator""uV(long double l) { return voltage<microvolt, long double>(l); } constexpr auto operator"" q_uV(long double l) { return voltage<microvolt, long double>(l); }
constexpr auto operator""nV(unsigned long long l) { return voltage<nanovolt, std::int64_t>(l); } constexpr auto operator"" q_nV(unsigned long long l) { return voltage<nanovolt, std::int64_t>(l); }
constexpr auto operator""nV(long double l) { return voltage<nanovolt, long double>(l); } constexpr auto operator"" q_nV(long double l) { return voltage<nanovolt, long double>(l); }
constexpr auto operator""pV(unsigned long long l) { return voltage<picovolt, std::int64_t>(l); } constexpr auto operator"" q_pV(unsigned long long l) { return voltage<picovolt, std::int64_t>(l); }
constexpr auto operator""pV(long double l) { return voltage<picovolt, long double>(l); } constexpr auto operator"" q_pV(long double l) { return voltage<picovolt, long double>(l); }
} // namespace literals } // namespace literals

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

@@ -44,24 +44,24 @@ using volume = quantity<dim_volume, U, Rep>;
inline namespace literals { inline namespace literals {
// mm3 // mm3
constexpr auto operator""mm3(unsigned long long l) { return volume<cubic_millimetre, std::int64_t>(l); } constexpr auto operator"" q_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); } constexpr auto operator"" q_mm3(long double l) { return volume<cubic_millimetre, long double>(l); }
// cm3 // cm3
constexpr auto operator""cm3(unsigned long long l) { return volume<cubic_centimetre, std::int64_t>(l); } constexpr auto operator"" q_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); } constexpr auto operator"" q_cm3(long double l) { return volume<cubic_centimetre, long double>(l); }
// m3 // m3
constexpr auto operator""m3(unsigned long long l) { return volume<cubic_metre, std::int64_t>(l); } constexpr auto operator"" q_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); } constexpr auto operator"" q_m3(long double l) { return volume<cubic_metre, long double>(l); }
// km3 // km3
constexpr auto operator""km3(unsigned long long l) { return volume<cubic_kilometre, std::int64_t>(l); } constexpr auto operator"" q_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); } constexpr auto operator"" q_km3(long double l) { return volume<cubic_kilometre, long double>(l); }
// l // l
constexpr auto operator""_l(unsigned long long l) { return volume<litre, std::int64_t>(l); } constexpr auto operator"" q_l(unsigned long long l) { return volume<litre, std::int64_t>(l); }
constexpr auto operator""_l(long double l) { return volume<litre, long double>(l); } constexpr auto operator"" q_l(long double l) { return volume<litre, long double>(l); }
} // namespace literals } // namespace literals

16
src/include/units/physical/typographic/length.h
View File

@@ -36,20 +36,20 @@ struct point_prn : named_scaled_unit<point_prn, "point(prn)", no_prefix, ratio<1
inline namespace literals { inline namespace literals {
// pica comp // pica comp
constexpr auto operator"" pica_comp(unsigned long long l) { return si::length<pica_comp, std::int64_t>(l); } constexpr auto operator"" q_pica_comp(unsigned long long l) { return si::length<pica_comp, std::int64_t>(l); }
constexpr auto operator"" pica_comp(long double l) { return si::length<pica_comp, long double>(l); } constexpr auto operator"" q_pica_comp(long double l) { return si::length<pica_comp, long double>(l); }
// pica prn // pica prn
constexpr auto operator"" pica_prn(unsigned long long l) { return si::length<pica_prn, std::int64_t>(l); } constexpr auto operator"" q_pica_prn(unsigned long long l) { return si::length<pica_prn, std::int64_t>(l); }
constexpr auto operator"" pica_prn(long double l) { return si::length<pica_prn, long double>(l); } constexpr auto operator"" q_pica_prn(long double l) { return si::length<pica_prn, long double>(l); }
// point comp // point comp
constexpr auto operator"" point_comp(unsigned long long l) { return si::length<point_comp, std::int64_t>(l); } constexpr auto operator"" q_point_comp(unsigned long long l) { return si::length<point_comp, std::int64_t>(l); }
constexpr auto operator"" point_comp(long double l) { return si::length<point_comp, long double>(l); } constexpr auto operator"" q_point_comp(long double l) { return si::length<point_comp, long double>(l); }
// point prn // point prn
constexpr auto operator"" point_prn(unsigned long long l) { return si::length<point_prn, std::int64_t>(l); } constexpr auto operator"" q_point_prn(unsigned long long l) { return si::length<point_prn, std::int64_t>(l); }
constexpr auto operator"" point_prn(long double l) { return si::length<point_prn, long double>(l); } constexpr auto operator"" q_point_prn(long double l) { return si::length<point_prn, long double>(l); }
} // namespace literals } // namespace literals

12
src/include/units/physical/us/length.h
View File

@@ -40,16 +40,16 @@ struct mile : named_scaled_unit<mile, "mi(us)", no_prefix, ratio<5280>, us::foot
inline namespace literals { inline namespace literals {
// ft // ft
constexpr auto operator"" ft_us(unsigned long long l) { return si::length<units::us::foot, std::int64_t>(l); } constexpr auto operator"" q_ft_us(unsigned long long l) { return si::length<units::us::foot, std::int64_t>(l); }
constexpr auto operator"" ft_us(long double l) { return si::length<units::us::foot, long double>(l); } constexpr auto operator"" q_ft_us(long double l) { return si::length<units::us::foot, long double>(l); }
// fathom // fathom
constexpr auto operator"" fathom_us(unsigned long long l) { return si::length<units::us::fathom, std::int64_t>(l); } constexpr auto operator"" q_fathom_us(unsigned long long l) { return si::length<units::us::fathom, std::int64_t>(l); }
constexpr auto operator"" fathom_us(long double l) { return si::length<units::us::fathom, long double>(l); } constexpr auto operator"" q_fathom_us(long double l) { return si::length<units::us::fathom, long double>(l); }
// ft // ft
constexpr auto operator"" mi_us(unsigned long long l) { return si::length<units::us::mile, std::int64_t>(l); } constexpr auto operator"" q_mi_us(unsigned long long l) { return si::length<units::us::mile, std::int64_t>(l); }
constexpr auto operator"" mi_us(long double l) { return si::length<units::us::mile, long double>(l); } constexpr auto operator"" q_mi_us(long double l) { return si::length<units::us::mile, long double>(l); }
} // namespace literals } // namespace literals

8
src/include/units/quantity_cast.h
View File

@@ -157,7 +157,7 @@ struct cast_ratio<FromD, FromU, ToD, ToU> {
* *
* This cast gets the target quantity type to cast to. For example: * This cast gets the target quantity type to cast to. For example:
* *
* auto q1 = units::quantity_cast<units::si::time<units::si::second>>(1ms); * auto q1 = units::quantity_cast<units::si::time<units::si::second>>(1q_ms);
* *
* @tparam To a target quantity type to cast to * @tparam To a target quantity type to cast to
*/ */
@@ -182,7 +182,7 @@ template<Quantity To, typename D, typename U, typename Rep>
* *
* This cast gets only the target dimension to cast to. For example: * This cast gets only the target dimension to cast to. For example:
* *
* auto q1 = units::quantity_cast<units::si::acceleration>(200Gal); * auto q1 = units::quantity_cast<units::si::acceleration>(200q_Gal);
* *
* @tparam ToD a dimension type to use for a target quantity * @tparam ToD a dimension type to use for a target quantity
*/ */
@@ -201,7 +201,7 @@ template<Dimension ToD, typename D, typename U, typename Rep>
* *
* This cast gets only the target unit to cast to. For example: * This cast gets only the target unit to cast to. For example:
* *
* auto q1 = units::quantity_cast<units::si::second>(1ms); * auto q1 = units::quantity_cast<units::si::second>(1q_ms);
* *
* @tparam ToU a unit type to use for a target quantity * @tparam ToU a unit type to use for a target quantity
*/ */
@@ -220,7 +220,7 @@ template<Unit ToU, typename D, typename U, typename Rep>
* *
* This cast gets only representation to cast to. For example: * This cast gets only representation to cast to. For example:
* *
* auto q1 = units::quantity_cast<int>(1ms); * auto q1 = units::quantity_cast<int>(1q_ms);
* *
* @tparam ToRep a representation type to use for a target quantity * @tparam ToRep a representation type to use for a target quantity
*/ */

8
test/unit_test/runtime/digital_info_test.cpp
View File

@@ -34,25 +34,25 @@ TEST_CASE("operator<< on a data quantity", "[text][ostream]")
{ {
SECTION("named unit") SECTION("named unit")
{ {
stream << 64B; stream << 64q_B;
REQUIRE(stream.str() == "64 B"); REQUIRE(stream.str() == "64 B");
} }
SECTION("prefixed coherent unit") SECTION("prefixed coherent unit")
{ {
stream << 256Kib; stream << 256q_Kib;
REQUIRE(stream.str() == "256 Kib"); REQUIRE(stream.str() == "256 Kib");
} }
SECTION("prefixed non-coherent unit") SECTION("prefixed non-coherent unit")
{ {
stream << 1024KiB; stream << 1024q_KiB;
REQUIRE(stream.str() == "1024 KiB"); REQUIRE(stream.str() == "1024 KiB");
} }
SECTION("other unit matching prefix") SECTION("other unit matching prefix")
{ {
stream << 8Kib * 8Kib / 2b; stream << 8q_Kib * 8q_Kib / 2q_b;
REQUIRE(stream.str() == "32 Mib"); REQUIRE(stream.str() == "32 Mib");
} }
} }

218
test/unit_test/runtime/fmt_test.cpp
View File

@@ -46,7 +46,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
{ {
SECTION("integral representation") SECTION("integral representation")
{ {
const auto q = 60W; const auto q = 60q_W;
stream << q; stream << q;
SECTION("iostream") SECTION("iostream")
@@ -67,7 +67,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("floating-point representation") SECTION("floating-point representation")
{ {
const auto q = 1023.5Pa; const auto q = 1023.5q_Pa;
stream << q; stream << q;
SECTION("iostream") SECTION("iostream")
@@ -89,7 +89,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("quantity with a predefined prefixed unit") SECTION("quantity with a predefined prefixed unit")
{ {
const auto q = 125us; const auto q = 125q_us;
stream << q; stream << q;
SECTION("iostream") SECTION("iostream")
@@ -159,7 +159,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
{ {
SECTION("acceleration") SECTION("acceleration")
{ {
const auto q = 20m / 2s / 1s; const auto q = 20q_m / 2q_s / 1q_s;
stream << q; stream << q;
SECTION("iostream") SECTION("iostream")
@@ -180,7 +180,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("volume") SECTION("volume")
{ {
const auto q = 2m * 1m * 1m; const auto q = 2q_m * 1q_m * 1q_m;
stream << q; stream << q;
SECTION("iostream") SECTION("iostream")
@@ -201,7 +201,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("surface tension") SECTION("surface tension")
{ {
const auto q = 20N / 2m; const auto q = 20q_N / 2q_m;
stream << q; stream << q;
SECTION("iostream") SECTION("iostream")
@@ -225,12 +225,12 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
{ {
SECTION("velocity") SECTION("velocity")
{ {
const auto q = 20km / 2h; const auto q = 20q_km / 2q_h;
stream << q; stream << q;
SECTION("iostream") SECTION("iostream")
{ {
CHECK(stream.str() == "10 km/h"); CHECK(stream.str() == "10.q_km/h");
} }
SECTION("fmt with default format {} on a quantity") SECTION("fmt with default format {} on a quantity")
@@ -272,7 +272,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
{ {
SECTION("unit::ratio as an SI prefix for a dimension with a special symbol") SECTION("unit::ratio as an SI prefix for a dimension with a special symbol")
{ {
const auto q = 4N * 2cm; const auto q = 4q_N * 2q_cm;
stream << q; stream << q;
SECTION("iostream") SECTION("iostream")
@@ -293,7 +293,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("unit::ratio for a dimension without a special symbol") SECTION("unit::ratio for a dimension without a special symbol")
{ {
const auto q = 2cm * 2m * 2m; const auto q = 2q_cm * 2q_m * 2q_m;
stream << q; stream << q;
SECTION("iostream") SECTION("iostream")
@@ -314,7 +314,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("unit::ratio::num != 1 && unit::ratio::den == 1") SECTION("unit::ratio::num != 1 && unit::ratio::den == 1")
{ {
const auto q = 4 * 2min / (2s * 2s); const auto q = 4 * 2q_min / (2q_s * 2q_s);
stream << q; stream << q;
SECTION("iostream") SECTION("iostream")
@@ -335,7 +335,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("unit::ratio::num == 1 && unit::ratio::den != 1") SECTION("unit::ratio::num == 1 && unit::ratio::den != 1")
{ {
const auto q = 20_J / 2min; const auto q = 20q_J / 2q_min;
stream << q; stream << q;
SECTION("iostream") SECTION("iostream")
@@ -356,7 +356,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("unit::ratio::num != 1 && unit::ratio::den != 1") SECTION("unit::ratio::num != 1 && unit::ratio::den != 1")
{ {
const auto q = 60kJ / 2min; const auto q = 60q_kJ / 2q_min;
stream << q; stream << q;
SECTION("iostream") SECTION("iostream")
@@ -382,7 +382,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
{ {
SECTION("SI base units") SECTION("SI base units")
{ {
const auto q = 2s * 2m * 2kg; const auto q = 2q_s * 2q_m * 2q_kg;
stream << q; stream << q;
SECTION("iostream") SECTION("iostream")
@@ -403,7 +403,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("CGS base units") SECTION("CGS base units")
{ {
const auto q = 2s * cgs::length<cgs::centimetre>(2) * cgs::mass<cgs::gram>(2); const auto q = 2q_s * cgs::length<cgs::centimetre>(2) * cgs::mass<cgs::gram>(2);
stream << q; stream << q;
SECTION("iostream") SECTION("iostream")
@@ -425,7 +425,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("unit::ratio as an SI prefix") SECTION("unit::ratio as an SI prefix")
{ {
const auto q = 4km * 2s; const auto q = 4q_km * 2q_s;
stream << q; stream << q;
SECTION("iostream") SECTION("iostream")
@@ -446,7 +446,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("unit::ratio::num != 1 && unit::ratio::den == 1") SECTION("unit::ratio::num != 1 && unit::ratio::den == 1")
{ {
const auto q = 4kg * 2min / (2s * 2s); const auto q = 4q_kg * 2q_min / (2q_s * 2q_s);
stream << q; stream << q;
SECTION("iostream") SECTION("iostream")
@@ -467,7 +467,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("unit::ratio::num == 1 && unit::ratio::den != 1") SECTION("unit::ratio::num == 1 && unit::ratio::den != 1")
{ {
const auto q = 20kg / 2min; const auto q = 20q_kg / 2q_min;
stream << q; stream << q;
SECTION("iostream") SECTION("iostream")
@@ -488,7 +488,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("CGS base units") SECTION("CGS base units")
{ {
const auto q = 2s * cgs::length<si::metre>(2) * cgs::mass<si::kilogram>(2); const auto q = 2q_s * cgs::length<si::metre>(2) * cgs::mass<si::kilogram>(2);
stream << q; stream << q;
SECTION("iostream") SECTION("iostream")
@@ -509,7 +509,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("unit::ratio::num != 1 && unit::ratio::den != 1") SECTION("unit::ratio::num != 1 && unit::ratio::den != 1")
{ {
const auto q = 60min / 2km; const auto q = 60q_min / 2q_km;
stream << q; stream << q;
SECTION("iostream") SECTION("iostream")
@@ -530,7 +530,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("exp::num == 1 && exp::den == 1") SECTION("exp::num == 1 && exp::den == 1")
{ {
const auto q = 4m * 2s; const auto q = 4q_m * 2q_s;
stream << q; stream << q;
SECTION("iostream") SECTION("iostream")
@@ -551,7 +551,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("exp::num == 2 && exp::den == 1 for positive exponent") SECTION("exp::num == 2 && exp::den == 1 for positive exponent")
{ {
const auto q = 4m * 2s * 2s; const auto q = 4q_m * 2q_s * 2q_s;
stream << q; stream << q;
SECTION("iostream") SECTION("iostream")
@@ -572,7 +572,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("exp::num == 2 && exp::den == 1 for negative exponent (first dimension)") SECTION("exp::num == 2 && exp::den == 1 for negative exponent (first dimension)")
{ {
const auto q = 8s / 2m / 2m; const auto q = 8q_s / 2q_m / 2q_m;
stream << q; stream << q;
SECTION("iostream") SECTION("iostream")
@@ -593,7 +593,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("exp::num == 2 && exp::den == 1 for negative exponent (not first dimension)") SECTION("exp::num == 2 && exp::den == 1 for negative exponent (not first dimension)")
{ {
const auto q = 8m / 2kg / 2kg; const auto q = 8q_m / 2q_kg / 2q_kg;
stream << q; stream << q;
SECTION("iostream") SECTION("iostream")
@@ -614,7 +614,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("fractional positive exponent") SECTION("fractional positive exponent")
{ {
const auto q = sqrt(9m); const auto q = sqrt(9q_m);
stream << q; stream << q;
SECTION("iostream") SECTION("iostream")
@@ -635,7 +635,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
SECTION("fractional negative exponent") SECTION("fractional negative exponent")
{ {
const auto q = sqrt(9 / 1m); const auto q = sqrt(9 / 1q_m);
stream << q; stream << q;
SECTION("iostream") SECTION("iostream")
@@ -662,12 +662,12 @@ TEST_CASE("format string with only %Q should print quantity value only", "[text]
{ {
SECTION("positive value") SECTION("positive value")
{ {
CHECK(fmt::format("{:%Q}", 123kmph) == "123"); CHECK(fmt::format("{:%Q}", 123q_kmph) == "123");
} }
SECTION("negative value") SECTION("negative value")
{ {
CHECK(fmt::format("{:%Q}", 5m - 10m) == "-5"); CHECK(fmt::format("{:%Q}", 5q_m - 10q_m) == "-5");
} }
} }
@@ -675,12 +675,12 @@ TEST_CASE("format string with only %Q should print quantity value only", "[text]
{ {
SECTION("positive value") SECTION("positive value")
{ {
CHECK(fmt::format("{:%Q}", 221.km / 2h) == "110.5"); CHECK(fmt::format("{:%Q}", 221.q_km / 2q_h) == "110.5");
} }
SECTION("negative value") SECTION("negative value")
{ {
CHECK(fmt::format("{:%Q}", 3.14m - 10m) == "-6.86"); CHECK(fmt::format("{:%Q}", 3.14q_m - 10q_m) == "-6.86");
} }
SECTION("nan") SECTION("nan")
@@ -702,39 +702,39 @@ TEST_CASE("format string with only %Q should print quantity value only", "[text]
TEST_CASE("format string with only %q should print quantity unit symbol only", "[text][fmt]") TEST_CASE("format string with only %q should print quantity unit symbol only", "[text][fmt]")
{ {
CHECK(fmt::format("{:%q}", 123kmph) == "km/h"); CHECK(fmt::format("{:%q}", 123q_kmph) == "km/h");
} }
TEST_CASE("%q an %Q can be put anywhere in a format string", "[text][fmt]") TEST_CASE("%q an %Q can be put anywhere in a format string", "[text][fmt]")
{ {
SECTION("no space") SECTION("no space")
{ {
CHECK(fmt::format("{:%Q%q}", 123kmph) == "123km/h"); CHECK(fmt::format("{:%Q%q}", 123q_kmph) == "123q_km/h");
} }
SECTION("separator") SECTION("separator")
{ {
CHECK(fmt::format("{:%Q###%q}", 123kmph) == "123###km/h"); CHECK(fmt::format("{:%Q###%q}", 123q_kmph) == "123###km/h");
} }
SECTION("opposite order") SECTION("opposite order")
{ {
CHECK(fmt::format("{:%q %Q}", 123kmph) == "km/h 123"); CHECK(fmt::format("{:%q %Q}", 123q_kmph) == "km/h 123");
} }
SECTION("tabulator") SECTION("tabulator")
{ {
CHECK(fmt::format("{:%Q%t%q}", 123kmph) == "123\tkm/h"); CHECK(fmt::format("{:%Q%t%q}", 123q_kmph) == "123\tkm/h");
} }
SECTION("new line") SECTION("new line")
{ {
CHECK(fmt::format("{:%Q%n%q}", 123kmph) == "123\nkm/h"); CHECK(fmt::format("{:%Q%n%q}", 123q_kmph) == "123\nkm/h");
} }
SECTION("% sign") SECTION("% sign")
{ {
CHECK(fmt::format("{:%Q%% %q}", 123kmph) == "123% km/h"); CHECK(fmt::format("{:%Q%% %q}", 123q_kmph) == "123% km/h");
} }
} }
@@ -742,50 +742,50 @@ TEST_CASE("fill and align specification", "[text][fmt]")
{ {
SECTION("default format {} on a quantity") SECTION("default format {} on a quantity")
{ {
CHECK(fmt::format("|{:0}|", 123m) == "|123 m|"); CHECK(fmt::format("|{:0}|", 123q_m) == "|123 m|");
CHECK(fmt::format("|{:10}|", 123m) == "| 123 m|"); CHECK(fmt::format("|{:10}|", 123q_m) == "| 123 m|");
CHECK(fmt::format("|{:<10}|", 123m) == "|123 m |"); CHECK(fmt::format("|{:<10}|", 123q_m) == "|123 m |");
CHECK(fmt::format("|{:>10}|", 123m) == "| 123 m|"); CHECK(fmt::format("|{:>10}|", 123q_m) == "| 123 m|");
CHECK(fmt::format("|{:^10}|", 123m) == "| 123 m |"); CHECK(fmt::format("|{:^10}|", 123q_m) == "| 123 m |");
CHECK(fmt::format("|{:*<10}|", 123m) == "|123 m*****|"); CHECK(fmt::format("|{:*<10}|", 123q_m) == "|123 m*****|");
CHECK(fmt::format("|{:*>10}|", 123m) == "|*****123 m|"); CHECK(fmt::format("|{:*>10}|", 123q_m) == "|*****123 m|");
CHECK(fmt::format("|{:*^10}|", 123m) == "|**123 m***|"); CHECK(fmt::format("|{:*^10}|", 123q_m) == "|**123 m***|");
} }
SECTION("full format {:%Q %q} on a quantity") SECTION("full format {:%Q %q} on a quantity")
{ {
CHECK(fmt::format("|{:0%Q%q}|", 123m) == "|123m|"); CHECK(fmt::format("|{:0%Q%q}|", 123q_m) == "|123q_m|");
CHECK(fmt::format("|{:10%Q%q}|", 123m) == "| 123m|"); CHECK(fmt::format("|{:10%Q%q}|", 123q_m) == "| 123q_m|");
CHECK(fmt::format("|{:<10%Q%q}|", 123m) == "|123m |"); CHECK(fmt::format("|{:<10%Q%q}|", 123q_m) == "|123q_m |");
CHECK(fmt::format("|{:>10%Q%q}|", 123m) == "| 123m|"); CHECK(fmt::format("|{:>10%Q%q}|", 123q_m) == "| 123q_m|");
CHECK(fmt::format("|{:^10%Q%q}|", 123m) == "| 123m |"); CHECK(fmt::format("|{:^10%Q%q}|", 123q_m) == "| 123q_m |");
CHECK(fmt::format("|{:*<10%Q%q}|", 123m) == "|123m******|"); CHECK(fmt::format("|{:*<10%Q%q}|", 123q_m) == "|123q_m******|");
CHECK(fmt::format("|{:*>10%Q%q}|", 123m) == "|******123m|"); CHECK(fmt::format("|{:*>10%Q%q}|", 123q_m) == "|******123q_m|");
CHECK(fmt::format("|{:*^10%Q%q}|", 123m) == "|***123m***|"); CHECK(fmt::format("|{:*^10%Q%q}|", 123q_m) == "|***123q_m***|");
} }
SECTION("value only format {:%Q} on a quantity") SECTION("value only format {:%Q} on a quantity")
{ {
CHECK(fmt::format("|{:0%Q}|", 123m) == "|123|"); CHECK(fmt::format("|{:0%Q}|", 123q_m) == "|123|");
CHECK(fmt::format("|{:10%Q}|", 123m) == "| 123|"); CHECK(fmt::format("|{:10%Q}|", 123q_m) == "| 123|");
CHECK(fmt::format("|{:<10%Q}|", 123m) == "|123 |"); CHECK(fmt::format("|{:<10%Q}|", 123q_m) == "|123 |");
CHECK(fmt::format("|{:>10%Q}|", 123m) == "| 123|"); CHECK(fmt::format("|{:>10%Q}|", 123q_m) == "| 123|");
CHECK(fmt::format("|{:^10%Q}|", 123m) == "| 123 |"); CHECK(fmt::format("|{:^10%Q}|", 123q_m) == "| 123 |");
CHECK(fmt::format("|{:*<10%Q}|", 123m) == "|123*******|"); CHECK(fmt::format("|{:*<10%Q}|", 123q_m) == "|123*******|");
CHECK(fmt::format("|{:*>10%Q}|", 123m) == "|*******123|"); CHECK(fmt::format("|{:*>10%Q}|", 123q_m) == "|*******123|");
CHECK(fmt::format("|{:*^10%Q}|", 123m) == "|***123****|"); CHECK(fmt::format("|{:*^10%Q}|", 123q_m) == "|***123****|");
} }
SECTION("symbol only format {:%q} on a quantity") SECTION("symbol only format {:%q} on a quantity")
{ {
CHECK(fmt::format("|{:0%q}|", 123m) == "|m|"); CHECK(fmt::format("|{:0%q}|", 123q_m) == "|m|");
CHECK(fmt::format("|{:10%q}|", 123m) == "|m |"); CHECK(fmt::format("|{:10%q}|", 123q_m) == "|m |");
CHECK(fmt::format("|{:<10%q}|", 123m) == "|m |"); CHECK(fmt::format("|{:<10%q}|", 123q_m) == "|m |");
CHECK(fmt::format("|{:>10%q}|", 123m) == "| m|"); CHECK(fmt::format("|{:>10%q}|", 123q_m) == "| m|");
CHECK(fmt::format("|{:^10%q}|", 123m) == "| m |"); CHECK(fmt::format("|{:^10%q}|", 123q_m) == "| m |");
CHECK(fmt::format("|{:*<10%q}|", 123m) == "|m*********|"); CHECK(fmt::format("|{:*<10%q}|", 123q_m) == "|m*********|");
CHECK(fmt::format("|{:*>10%q}|", 123m) == "|*********m|"); CHECK(fmt::format("|{:*>10%q}|", 123q_m) == "|*********m|");
CHECK(fmt::format("|{:*^10%q}|", 123m) == "|****m*****|"); CHECK(fmt::format("|{:*^10%q}|", 123q_m) == "|****m*****|");
} }
} }
@@ -796,24 +796,24 @@ TEST_CASE("sign specification", "[text][fmt]")
SECTION("default format {} on a quantity") SECTION("default format {} on a quantity")
{ {
CHECK(fmt::format("{0:},{0:+},{0:-},{0: }", 1m) == "1 m,+1 m,1 m, 1 m"); CHECK(fmt::format("{0:},{0:+},{0:-},{0: }", 1q_m) == "1 m,+1 m,1 m, 1 m");
CHECK(fmt::format("{0:},{0:+},{0:-},{0: }", -1m) == "-1 m,-1 m,-1 m,-1 m"); CHECK(fmt::format("{0:},{0:+},{0:-},{0: }", -1q_m) == "-1 m,-1 m,-1 m,-1 m");
CHECK(fmt::format("{0:},{0:+},{0:-},{0: }", inf) == "inf m,+inf m,inf m, inf m"); CHECK(fmt::format("{0:},{0:+},{0:-},{0: }", inf) == "inf m,+inf m,inf m, inf m");
CHECK(fmt::format("{0:},{0:+},{0:-},{0: }", nan) == "nan m,+nan m,nan m, nan m"); CHECK(fmt::format("{0:},{0:+},{0:-},{0: }", nan) == "nan m,+nan m,nan m, nan m");
} }
SECTION("full format {:%Q %q} on a quantity") SECTION("full format {:%Q %q} on a quantity")
{ {
CHECK(fmt::format("{0:%Q%q},{0:+%Q%q},{0:-%Q%q},{0: %Q%q}", 1m) == "1m,+1m,1m, 1m"); CHECK(fmt::format("{0:%Q%q},{0:+%Q%q},{0:-%Q%q},{0: %Q%q}", 1q_m) == "1q_m,+1q_m,1q_m, 1q_m");
CHECK(fmt::format("{0:%Q%q},{0:+%Q%q},{0:-%Q%q},{0: %Q%q}", -1m) == "-1m,-1m,-1m,-1m"); CHECK(fmt::format("{0:%Q%q},{0:+%Q%q},{0:-%Q%q},{0: %Q%q}", -1q_m) == "-1q_m,-1q_m,-1q_m,-1q_m");
CHECK(fmt::format("{0:%Q%q},{0:+%Q%q},{0:-%Q%q},{0: %Q%q}", inf) == "infm,+infm,infm, infm"); CHECK(fmt::format("{0:%Q%q},{0:+%Q%q},{0:-%Q%q},{0: %Q%q}", inf) == "infm,+infm,infm, infm");
CHECK(fmt::format("{0:%Q%q},{0:+%Q%q},{0:-%Q%q},{0: %Q%q}", nan) == "nanm,+nanm,nanm, nanm"); CHECK(fmt::format("{0:%Q%q},{0:+%Q%q},{0:-%Q%q},{0: %Q%q}", nan) == "nanm,+nanm,nanm, nanm");
} }
SECTION("value only format {:%Q} on a quantity") SECTION("value only format {:%Q} on a quantity")
{ {
CHECK(fmt::format("{0:%Q},{0:+%Q},{0:-%Q},{0: %Q}", 1m) == "1,+1,1, 1"); CHECK(fmt::format("{0:%Q},{0:+%Q},{0:-%Q},{0: %Q}", 1q_m) == "1,+1,1, 1");
CHECK(fmt::format("{0:%Q},{0:+%Q},{0:-%Q},{0: %Q}", -1m) == "-1,-1,-1,-1"); CHECK(fmt::format("{0:%Q},{0:+%Q},{0:-%Q},{0: %Q}", -1q_m) == "-1,-1,-1,-1");
CHECK(fmt::format("{0:%Q},{0:+%Q},{0:-%Q},{0: %Q}", inf) == "inf,+inf,inf, inf"); CHECK(fmt::format("{0:%Q},{0:+%Q},{0:-%Q},{0: %Q}", inf) == "inf,+inf,inf, inf");
CHECK(fmt::format("{0:%Q},{0:+%Q},{0:-%Q},{0: %Q}", nan) == "nan,+nan,nan, nan"); CHECK(fmt::format("{0:%Q},{0:+%Q},{0:-%Q},{0: %Q}", nan) == "nan,+nan,nan, nan");
} }
@@ -821,8 +821,8 @@ TEST_CASE("sign specification", "[text][fmt]")
TEST_CASE("sign specification for unit only", "[text][fmt][exception]") TEST_CASE("sign specification for unit only", "[text][fmt][exception]")
{ {
CHECK_THROWS_MATCHES(fmt::format("{:+%q}", 1m), fmt::format_error, Message("sign not allowed for a quantity unit")); CHECK_THROWS_MATCHES(fmt::format("{:+%q}", 1q_m), fmt::format_error, Message("sign not allowed for a quantity unit"));
CHECK_THROWS_MATCHES(fmt::format("{:-%q}", 1m), fmt::format_error, Message("sign not allowed for a quantity unit")); CHECK_THROWS_MATCHES(fmt::format("{:-%q}", 1q_m), fmt::format_error, Message("sign not allowed for a quantity unit"));
} }
@@ -830,35 +830,35 @@ TEST_CASE("precision specification", "[text][fmt]")
{ {
SECTION("default format {} on a quantity") SECTION("default format {} on a quantity")
{ {
CHECK(fmt::format("{:.1}", 1.2345m) == "1.2 m"); CHECK(fmt::format("{:.1}", 1.2345q_m) == "1.2 m");
CHECK(fmt::format("{:.0}", 1.2345m) == "1 m"); CHECK(fmt::format("{:.0}", 1.2345q_m) == "1 m");
CHECK(fmt::format("{:.2}", 1.2345m) == "1.23 m"); CHECK(fmt::format("{:.2}", 1.2345q_m) == "1.23 m");
CHECK(fmt::format("{:.3}", 1.2345m) == "1.235 m"); CHECK(fmt::format("{:.3}", 1.2345q_m) == "1.235 m");
CHECK(fmt::format("{:.4}", 1.2345m) == "1.2345 m"); CHECK(fmt::format("{:.4}", 1.2345q_m) == "1.2345 m");
CHECK(fmt::format("{:.5}", 1.2345m) == "1.23450 m"); CHECK(fmt::format("{:.5}", 1.2345q_m) == "1.23450 m");
CHECK(fmt::format("{:.10}", 1.2345m) == "1.2345000000 m"); CHECK(fmt::format("{:.10}", 1.2345q_m) == "1.2345000000 m");
} }
SECTION("full format {:%Q %q} on a quantity") SECTION("full format {:%Q %q} on a quantity")
{ {
CHECK(fmt::format("{:.0%Q %q}", 1.2345m) == "1 m"); CHECK(fmt::format("{:.0%Q %q}", 1.2345q_m) == "1 m");
CHECK(fmt::format("{:.1%Q %q}", 1.2345m) == "1.2 m"); CHECK(fmt::format("{:.1%Q %q}", 1.2345q_m) == "1.2 m");
CHECK(fmt::format("{:.2%Q %q}", 1.2345m) == "1.23 m"); CHECK(fmt::format("{:.2%Q %q}", 1.2345q_m) == "1.23 m");
CHECK(fmt::format("{:.3%Q %q}", 1.2345m) == "1.235 m"); CHECK(fmt::format("{:.3%Q %q}", 1.2345q_m) == "1.235 m");
CHECK(fmt::format("{:.4%Q %q}", 1.2345m) == "1.2345 m"); CHECK(fmt::format("{:.4%Q %q}", 1.2345q_m) == "1.2345 m");
CHECK(fmt::format("{:.5%Q %q}", 1.2345m) == "1.23450 m"); CHECK(fmt::format("{:.5%Q %q}", 1.2345q_m) == "1.23450 m");
CHECK(fmt::format("{:.10%Q %q}", 1.2345m) == "1.2345000000 m"); CHECK(fmt::format("{:.10%Q %q}", 1.2345q_m) == "1.2345000000 m");
} }
SECTION("value only format {:%Q} on a quantity") SECTION("value only format {:%Q} on a quantity")
{ {
CHECK(fmt::format("{:.0%Q}", 1.2345m) == "1"); CHECK(fmt::format("{:.0%Q}", 1.2345q_m) == "1");
CHECK(fmt::format("{:.1%Q}", 1.2345m) == "1.2"); CHECK(fmt::format("{:.1%Q}", 1.2345q_m) == "1.2");
CHECK(fmt::format("{:.2%Q}", 1.2345m) == "1.23"); CHECK(fmt::format("{:.2%Q}", 1.2345q_m) == "1.23");
CHECK(fmt::format("{:.3%Q}", 1.2345m) == "1.235"); CHECK(fmt::format("{:.3%Q}", 1.2345q_m) == "1.235");
CHECK(fmt::format("{:.4%Q}", 1.2345m) == "1.2345"); CHECK(fmt::format("{:.4%Q}", 1.2345q_m) == "1.2345");
CHECK(fmt::format("{:.5%Q}", 1.2345m) == "1.23450"); CHECK(fmt::format("{:.5%Q}", 1.2345q_m) == "1.23450");
CHECK(fmt::format("{:.10%Q}", 1.2345m) == "1.2345000000"); CHECK(fmt::format("{:.10%Q}", 1.2345q_m) == "1.2345000000");
} }
} }
@@ -866,17 +866,17 @@ TEST_CASE("precision specification for integral representation should throw", "[
{ {
SECTION("default format {} on a quantity") SECTION("default format {} on a quantity")
{ {
REQUIRE_THROWS_MATCHES(fmt::format("{:.1}", 1m), fmt::format_error, Message("precision not allowed for integral quantity representation")); REQUIRE_THROWS_MATCHES(fmt::format("{:.1}", 1q_m), fmt::format_error, Message("precision not allowed for integral quantity representation"));
} }
SECTION("full format {:%Q %q} on a quantity") SECTION("full format {:%Q %q} on a quantity")
{ {
REQUIRE_THROWS_MATCHES(fmt::format("{:.1%Q %q}", 1m), fmt::format_error, Message("precision not allowed for integral quantity representation")); REQUIRE_THROWS_MATCHES(fmt::format("{:.1%Q %q}", 1q_m), fmt::format_error, Message("precision not allowed for integral quantity representation"));
} }
SECTION("value only format {:%Q} on a quantity") SECTION("value only format {:%Q} on a quantity")
{ {
REQUIRE_THROWS_MATCHES(fmt::format("{:.1%Q}", 1m), fmt::format_error, Message("precision not allowed for integral quantity representation")); REQUIRE_THROWS_MATCHES(fmt::format("{:.1%Q}", 1q_m), fmt::format_error, Message("precision not allowed for integral quantity representation"));
} }
} }
@@ -890,47 +890,47 @@ TEST_CASE("quantity_cast", "[text][ostream]")
SECTION("int to double representation") SECTION("int to double representation")
{ {
const auto q = 121km / 2h; const auto q = 121q_km / 2q_h;
SECTION("original") SECTION("original")
{ {
stream << q; stream << q;
CHECK(stream.str() == "60 km/h"); CHECK(stream.str() == "60.q_km/h");
} }
SECTION("int") SECTION("int")
{ {
stream << quantity_cast<int>(q); stream << quantity_cast<int>(q);
CHECK(stream.str() == "60 km/h"); CHECK(stream.str() == "60.q_km/h");
} }
SECTION("double") SECTION("double")
{ {
stream << quantity_cast<double>(q); stream << quantity_cast<double>(q);
CHECK(stream.str() == "60 km/h"); CHECK(stream.str() == "60.q_km/h");
} }
} }
SECTION("double to int representation") SECTION("double to int representation")
{ {
const auto q = 121.km / 2h; const auto q = 121.q_km / 2q_h;
SECTION("original") SECTION("original")
{ {
stream << q; stream << q;
CHECK(stream.str() == "60.5 km/h"); CHECK(stream.str() == "60.5.q_km/h");
} }
SECTION("int") SECTION("int")
{ {
stream << quantity_cast<int>(q); stream << quantity_cast<int>(q);
CHECK(stream.str() == "60 km/h"); CHECK(stream.str() == "60.q_km/h");
} }
SECTION("double") SECTION("double")
{ {
stream << quantity_cast<double>(q); stream << quantity_cast<double>(q);
CHECK(stream.str() == "60.5 km/h"); CHECK(stream.str() == "60.5.q_km/h");
} }
} }
} }

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

@@ -51,123 +51,123 @@ TEST_CASE("fmt::format on synthesized unit symbols", "[text][fmt]")
{ {
SECTION("time") SECTION("time")
{ {
CHECK(fmt::format("{}", 1ns) == "1 ns"); CHECK(fmt::format("{}", 1q_ns) == "1 ns");
CHECK(fmt::format("{}", 1us) == "1 µs"); CHECK(fmt::format("{}", 1q_us) == "1 µs");
CHECK(fmt::format("{}", 1ms) == "1 ms"); CHECK(fmt::format("{}", 1q_ms) == "1 ms");
} }
SECTION("length") SECTION("length")
{ {
CHECK(fmt::format("{}", 1mm) == "1 mm"); CHECK(fmt::format("{}", 1q_mm) == "1 mm");
CHECK(fmt::format("{}", 1cm) == "1 cm"); CHECK(fmt::format("{}", 1q_cm) == "1 cm");
CHECK(fmt::format("{}", 1km) == "1 km"); CHECK(fmt::format("{}", 1q_km) == "1.q_km");
CHECK(fmt::format("{}", 1ft) == "1 ft"); CHECK(fmt::format("{}", 1q_ft) == "1 ft");
CHECK(fmt::format("{}", 1ft_us) == "1 ft(us)"); CHECK(fmt::format("{}", 1q_ft_us) == "1 ft(us)");
CHECK(fmt::format("{}", 1yd) == "1 yd"); CHECK(fmt::format("{}", 1q_yd) == "1 yd");
CHECK(fmt::format("{}", 1in) == "1 in"); CHECK(fmt::format("{}", 1q_in) == "1 in");
CHECK(fmt::format("{}", 1fathom) == "1 fathom"); CHECK(fmt::format("{}", 1q_fathom) == "1 fathom");
CHECK(fmt::format("{}", 1fathom_us) == "1 fathom(us)"); CHECK(fmt::format("{}", 1q_fathom_us) == "1 fathom(us)");
CHECK(fmt::format("{}", 1mi) == "1 mi"); CHECK(fmt::format("{}", 1q_mi) == "1 mi");
CHECK(fmt::format("{}", 1mi_us) == "1 mi(us)"); CHECK(fmt::format("{}", 1q_mi_us) == "1 mi(us)");
CHECK(fmt::format("{}", 1naut_mi) == "1 mi(naut)"); CHECK(fmt::format("{}", 1q_naut_mi) == "1 mi(naut)");
CHECK(fmt::format("{}", 1ch) == "1 ch"); CHECK(fmt::format("{}", 1q_ch) == "1 ch");
CHECK(fmt::format("{}", 1rd) == "1 rd"); CHECK(fmt::format("{}", 1q_rd) == "1 rd");
CHECK(fmt::format("{}", 1thou) == "1 thou"); CHECK(fmt::format("{}", 1q_thou) == "1 thou");
CHECK(fmt::format("{}", 1pc) == "1 pc"); CHECK(fmt::format("{}", 1q_pc) == "1 pc");
CHECK(fmt::format("{}", 1ly) == "1 ly"); CHECK(fmt::format("{}", 1q_ly) == "1 ly");
CHECK(fmt::format("{}", 1pc) == "1 pc"); CHECK(fmt::format("{}", 1q_pc) == "1 pc");
CHECK(fmt::format("{}", 1angstrom) == "1 angstrom"); CHECK(fmt::format("{}", 1q_angstrom) == "1 angstrom");
CHECK(fmt::format("{}", 1au) == "1 au"); CHECK(fmt::format("{}", 1q_au) == "1 au");
CHECK(fmt::format("{}", 1pica_comp) == "1 pica(comp)"); CHECK(fmt::format("{}", 1q_pica_comp) == "1 pica(comp)");
CHECK(fmt::format("{}", 1pica_prn) == "1 pica(prn)"); CHECK(fmt::format("{}", 1q_pica_prn) == "1 pica(prn)");
CHECK(fmt::format("{}", 1point_comp) == "1 point(comp)"); CHECK(fmt::format("{}", 1q_point_comp) == "1 point(comp)");
CHECK(fmt::format("{}", 1point_prn) == "1 point(prn)"); CHECK(fmt::format("{}", 1q_point_prn) == "1 point(prn)");
} }
SECTION("mass") SECTION("mass")
{ {
CHECK(fmt::format("{}", 1kg) == "1 kg"); CHECK(fmt::format("{}", 1q_kg) == "1 kg");
} }
SECTION("area") SECTION("area")
{ {
CHECK(fmt::format("{}", 1m2) == "1 m²"); CHECK(fmt::format("{}", 1q_m2) == "1 m²");
CHECK(fmt::format("{}", 1mm2) == "1 mm²"); CHECK(fmt::format("{}", 1q_mm2) == "1 mm²");
CHECK(fmt::format("{}", 1cm2) == "1 cm²"); CHECK(fmt::format("{}", 1q_cm2) == "1 cm²");
CHECK(fmt::format("{}", 1km2) == "1 km²"); CHECK(fmt::format("{}", 1q_km2) == "1.q_km²");
CHECK(fmt::format("{}", 1ft2) == "1 ft²"); CHECK(fmt::format("{}", 1q_ft2) == "1 ft²");
} }
SECTION("density") SECTION("density")
{ {
CHECK(fmt::format("{}", 1kgpm3) == "1 kg/m³"); CHECK(fmt::format("{}", 1q_kgpm3) == "1 kg/m³");
} }
SECTION("resistance") SECTION("resistance")
{ {
CHECK(fmt::format("{}", 1_R) == "1 Ω"); CHECK(fmt::format("{}", 1q_R) == "1 Ω");
CHECK(fmt::format("{}", 1kR) == "1 kΩ"); CHECK(fmt::format("{}", 1q_kR) == "1 kΩ");
CHECK(fmt::format("{}", 1mR) == "1 mΩ"); CHECK(fmt::format("{}", 1q_mR) == "1 mΩ");
CHECK(fmt::format("{}", 1MR) == "1 MΩ"); CHECK(fmt::format("{}", 1q_MR) == "1 MΩ");
} }
SECTION("voltage") SECTION("voltage")
{ {
CHECK(fmt::format("{}", 1V) == "1 V"); CHECK(fmt::format("{}", 1q_V) == "1 V");
CHECK(fmt::format("{}", 1mV) == "1 mV"); CHECK(fmt::format("{}", 1q_mV) == "1 mV");
CHECK(fmt::format("{}", 1uV) == "1 µV"); CHECK(fmt::format("{}", 1q_uV) == "1 µV");
CHECK(fmt::format("{}", 1nV) == "1 nV"); CHECK(fmt::format("{}", 1q_nV) == "1 nV");
CHECK(fmt::format("{}", 1pV) == "1 pV"); CHECK(fmt::format("{}", 1q_pV) == "1 pV");
} }
SECTION("volume") SECTION("volume")
{ {
CHECK(fmt::format("{}", 1m3) == "1 m³"); CHECK(fmt::format("{}", 1q_m3) == "1 m³");
CHECK(fmt::format("{}", 1mm3) == "1 mm³"); CHECK(fmt::format("{}", 1q_mm3) == "1 mm³");
CHECK(fmt::format("{}", 1cm3) == "1 cm³"); CHECK(fmt::format("{}", 1q_cm3) == "1 cm³");
CHECK(fmt::format("{}", 1km3) == "1 km³"); CHECK(fmt::format("{}", 1q_km3) == "1.q_km³");
CHECK(fmt::format("{}", 1ft3) == "1 ft³"); CHECK(fmt::format("{}", 1q_ft3) == "1 ft³");
} }
SECTION("frequency") SECTION("frequency")
{ {
CHECK(fmt::format("{}", 1mHz) == "1 mHz"); CHECK(fmt::format("{}", 1q_mHz) == "1 mHz");
CHECK(fmt::format("{}", 1kHz) == "1 kHz"); CHECK(fmt::format("{}", 1q_kHz) == "1 kHz");
CHECK(fmt::format("{}", 1MHz) == "1 MHz"); CHECK(fmt::format("{}", 1q_MHz) == "1 MHz");
CHECK(fmt::format("{}", 1GHz) == "1 GHz"); CHECK(fmt::format("{}", 1q_GHz) == "1 GHz");
CHECK(fmt::format("{}", 1THz) == "1 THz"); CHECK(fmt::format("{}", 1q_THz) == "1 THz");
} }
SECTION("velocity") SECTION("velocity")
{ {
CHECK(fmt::format("{}", 1mps) == "1 m/s"); CHECK(fmt::format("{}", 1q_mps) == "1 m/s");
CHECK(fmt::format("{}", 1kmph) == "1 km/h"); CHECK(fmt::format("{}", 1q_kmph) == "1.q_km/h");
CHECK(fmt::format("{}", 1mph) == "1 mi/h"); CHECK(fmt::format("{}", 1q_mph) == "1 mi/h");
} }
SECTION("acceleration") SECTION("acceleration")
{ {
CHECK(fmt::format("{}", 1mps2) == "1 m/s²"); CHECK(fmt::format("{}", 1q_mps2) == "1 m/s²");
} }
SECTION("energy") SECTION("energy")
{ {
CHECK(fmt::format("{}", 1mJ) == "1 mJ"); CHECK(fmt::format("{}", 1q_mJ) == "1 mJ");
CHECK(fmt::format("{}", 1kJ) == "1 kJ"); CHECK(fmt::format("{}", 1q_kJ) == "1 kJ");
CHECK(fmt::format("{}", 1MJ) == "1 MJ"); CHECK(fmt::format("{}", 1q_MJ) == "1 MJ");
CHECK(fmt::format("{}", 1GJ) == "1 GJ"); CHECK(fmt::format("{}", 1q_GJ) == "1 GJ");
} }
SECTION("power") SECTION("power")
{ {
CHECK(fmt::format("{}", 1mW) == "1 mW"); CHECK(fmt::format("{}", 1q_mW) == "1 mW");
CHECK(fmt::format("{}", 1kW) == "1 kW"); CHECK(fmt::format("{}", 1q_kW) == "1 kW");
CHECK(fmt::format("{}", 1MW) == "1 MW"); CHECK(fmt::format("{}", 1q_MW) == "1 MW");
CHECK(fmt::format("{}", 1GW) == "1 GW"); CHECK(fmt::format("{}", 1q_GW) == "1 GW");
} }
SECTION("surface tension") SECTION("surface tension")
{ {
CHECK(fmt::format("{}", 1Npm) == "1 N/m"); CHECK(fmt::format("{}", 1q_Npm) == "1 N/m");
} }
} }

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

@@ -33,23 +33,23 @@ using namespace units::si;
TEST_CASE("'pow<N>()' on quantity changes the value and the dimension accordingly", "[math][pow]") TEST_CASE("'pow<N>()' on quantity changes the value and the dimension accordingly", "[math][pow]")
{ {
SECTION ("'pow<0>(q)' returns '1'") { SECTION ("'pow<0>(q)' returns '1'") {
CHECK(pow<0>(2m) == 1); CHECK(pow<0>(2q_m) == 1);
} }
SECTION ("'pow<1>(q)' returns 'q'") { SECTION ("'pow<1>(q)' returns 'q'") {
CHECK(pow<1>(2m) == 2m); CHECK(pow<1>(2q_m) == 2q_m);
} }
SECTION ("'pow<2>(q)' squares both the value and a dimension") { SECTION ("'pow<2>(q)' squares both the value and a dimension") {
CHECK(pow<2>(2m) == 4m2); CHECK(pow<2>(2q_m) == 4q_m2);
} }
SECTION ("'pow<3>(q)' cubes both the value and a dimension") { SECTION ("'pow<3>(q)' cubes both the value and a dimension") {
CHECK(pow<3>(2m) == 8m3); CHECK(pow<3>(2q_m) == 8q_m3);
} }
} }
TEST_CASE("'sqrt()' on quantity changes the value and the dimension accordingly", "[math][sqrt]") TEST_CASE("'sqrt()' on quantity changes the value and the dimension accordingly", "[math][sqrt]")
{ {
REQUIRE(sqrt(4m2) == 2m); REQUIRE(sqrt(4q_m2) == 2q_m);
} }

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

@@ -50,17 +50,17 @@ static_assert(centimetre::symbol == "cm");
// velocity // velocity
static_assert(10cm / 5s == 2cmps); static_assert(10q_cm / 5q_s == 2q_cmps);
static_assert(10cm / 2cmps == 5s); static_assert(10q_cm / 2q_cmps == 5q_s);
static_assert(10cm == 2cmps * 5s); static_assert(10q_cm == 2q_cmps * 5q_s);
static_assert(detail::unit_text<dim_velocity, centimetre_per_second>() == "cm/s"); static_assert(detail::unit_text<dim_velocity, centimetre_per_second>() == "cm/s");
// area // area
static_assert(std::is_same_v<ratio_divide<centimetre::ratio, dimension_unit<dim_length>::ratio>, ratio<1>>); static_assert(std::is_same_v<ratio_divide<centimetre::ratio, dimension_unit<dim_length>::ratio>, ratio<1>>);
static_assert(1cm * 1cm == 1cm2); static_assert(1q_cm * 1q_cm == 1q_cm2);
static_assert(100cm2 / 10cm == 10cm); static_assert(100q_cm2 / 10q_cm == 10q_cm);
static_assert(detail::unit_text<dim_area, square_centimetre>() == "cm²"); static_assert(detail::unit_text<dim_area, square_centimetre>() == "cm²");
@@ -68,35 +68,35 @@ static_assert(detail::unit_text<dim_area, square_centimetre>() == "cm²");
// acceleration // acceleration
static_assert(10cmps / 10s == 1Gal); static_assert(10q_cmps / 10q_s == 1q_Gal);
static_assert(10cmps / 1Gal == 10s); static_assert(10q_cmps / 1q_Gal == 10q_s);
static_assert(1Gal * 10s == 10cmps); static_assert(1q_Gal * 10q_s == 10q_cmps);
// force // force
static_assert(10g * 10Gal == 100dyn); static_assert(10q_g * 10q_Gal == 100q_dyn);
static_assert(100dyn / 10g == 10Gal); static_assert(100q_dyn / 10q_g == 10q_Gal);
static_assert(100dyn / 10Gal == 10g); static_assert(100q_dyn / 10q_Gal == 10q_g);
// pressure // pressure
static_assert(10dyn / 10cm2 == 1Ba); static_assert(10q_dyn / 10q_cm2 == 1q_Ba);
static_assert(10dyn / 1Ba == 10cm2); static_assert(10q_dyn / 1q_Ba == 10q_cm2);
static_assert(1Ba * 10cm2 == 10dyn); static_assert(1q_Ba * 10q_cm2 == 10q_dyn);
// energy // energy
static_assert(10dyn * 10cm == 100_erg); static_assert(10q_dyn * 10q_cm == 100q_erg);
static_assert(100_erg / 10cm == 10dyn); static_assert(100q_erg / 10q_cm == 10q_dyn);
static_assert(100_erg / 10dyn == 10cm); static_assert(100q_erg / 10q_dyn == 10q_cm);
/* ************** DERIVED DIMENSIONS IN TERMS OF OTHER UNITS **************** */ /* ************** DERIVED DIMENSIONS IN TERMS OF OTHER UNITS **************** */
// power // power
static_assert(10_erg / 10s == 1_ergps); static_assert(10q_erg / 10q_s == 1q_ergps);
static_assert(1_ergps * 10s == 10_erg); static_assert(1q_ergps * 10q_s == 10q_erg);
static_assert(10_erg / 1_ergps == 10s); static_assert(10q_erg / 1q_ergps == 10q_s);
static_assert(detail::unit_text<dim_power, erg_per_second>() == "erg/s"); static_assert(detail::unit_text<dim_power, erg_per_second>() == "erg/s");

2
test/unit_test/static/custom_unit_test.cpp
View File

@@ -62,7 +62,7 @@ namespace {
struct kilogram_per_second : unit<kilogram_per_second> {}; struct kilogram_per_second : unit<kilogram_per_second> {};
struct dim_mass_rate : derived_dimension<dim_mass_rate, kilogram_per_second, units::exp<si::dim_mass, 1>, units::exp<si::dim_time, -1>> {}; struct dim_mass_rate : derived_dimension<dim_mass_rate, kilogram_per_second, units::exp<si::dim_mass, 1>, units::exp<si::dim_time, -1>> {};
struct kilogram_per_hour : deduced_unit<kilogram_per_hour, dim_mass_rate, si::kilogram, si::hour> {}; struct kilogram_per_hour : deduced_unit<kilogram_per_hour, dim_mass_rate, si::kilogram, si::hour> {};
constexpr auto a = 1kg / 1h; constexpr auto a = 1q_kg / 1q_h;
static_assert(std::is_same_v<decltype(a)::unit, kilogram_per_hour>); static_assert(std::is_same_v<decltype(a)::unit, kilogram_per_hour>);
} }

20
test/unit_test/static/data_test.cpp
View File

@@ -31,17 +31,17 @@ using namespace units::data;
// information // information
static_assert(1B == 8b); static_assert(1q_B == 8q_b);
static_assert(1024b == 1Kib); static_assert(1024q_b == 1q_Kib);
static_assert(1024B == 1KiB); static_assert(1024q_B == 1q_KiB);
static_assert(8 * 1024b == 1KiB); static_assert(8 * 1024q_b == 1q_KiB);
static_assert(8 * 1Kib == 1KiB); static_assert(8 * 1q_Kib == 1q_KiB);
static_assert(1Kib == 1024b); static_assert(1q_Kib == 1024q_b);
static_assert(1Mib == 1024Kib); static_assert(1q_Mib == 1024q_Kib);
static_assert(1Gib == 1024Mib); static_assert(1q_Gib == 1024q_Mib);
static_assert(1Tib == 1024Gib); static_assert(1q_Tib == 1024q_Gib);
static_assert(1Pib == 1024Tib); static_assert(1q_Pib == 1024q_Tib);
// bitrate // bitrate

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

@@ -30,14 +30,14 @@ namespace {
using namespace units::si::literals; using namespace units::si::literals;
using namespace units::international::literals; using namespace units::international::literals;
static_assert(std::is_same_v<decltype(pow<0>(2m)), std::int64_t>); static_assert(std::is_same_v<decltype(pow<0>(2q_m)), std::int64_t>);
static_assert(std::is_same_v<decltype(pow<1>(2m)), decltype(2m)>); static_assert(std::is_same_v<decltype(pow<1>(2q_m)), decltype(2q_m)>);
static_assert(std::is_same_v<decltype(pow<2>(2m)), decltype(4m2)>); static_assert(std::is_same_v<decltype(pow<2>(2q_m)), decltype(4q_m2)>);
static_assert(std::is_same_v<decltype(pow<2>(2km)), decltype(4km2)>); static_assert(std::is_same_v<decltype(pow<2>(2q_km)), decltype(4q_km2)>);
static_assert(std::is_same_v<decltype(pow<2>(2ft)), decltype(4ft2)>); static_assert(std::is_same_v<decltype(pow<2>(2q_ft)), decltype(4q_ft2)>);
static_assert(std::is_same_v<decltype(sqrt(4m2)), decltype(2m)>); static_assert(std::is_same_v<decltype(sqrt(4q_m2)), decltype(2q_m)>);
static_assert(std::is_same_v<decltype(sqrt(4km2)), decltype(2km)>); static_assert(std::is_same_v<decltype(sqrt(4q_km2)), decltype(2q_km)>);
static_assert(std::is_same_v<decltype(sqrt(4ft2)), decltype(2ft)>); static_assert(std::is_same_v<decltype(sqrt(4q_ft2)), decltype(2q_ft)>);
} // namespace } // namespace

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

@@ -148,19 +148,19 @@ static_assert(length<metre, my_double>(3.14).count() == my_double{3.14});
static_assert(length<metre, int>(km).count() == 1000); static_assert(length<metre, int>(km).count() == 1000);
// static_assert(length<metre, int>(length<metre, double>(3.14)).count() == 3); // should not compile (truncating conversion) // static_assert(length<metre, int>(length<metre, double>(3.14)).count() == 3); // should not compile (truncating conversion)
static_assert(length<metre, int>(quantity_cast<length<metre, my_int>>(3.14m)).count() == 3); static_assert(length<metre, int>(quantity_cast<length<metre, my_int>>(3.14q_m)).count() == 3);
// static_assert(length<metre, int>(length<metre, my_double>(1000.0)).count() == 1000); // should not compile (truncating conversion) // static_assert(length<metre, int>(length<metre, my_double>(1000.0)).count() == 1000); // should not compile (truncating conversion)
// static_assert(length<metre, my_int>(1000.0m).count() == my_int{1000}); // should not compile (truncating conversion) // static_assert(length<metre, my_int>(1000.0q_m).count() == my_int{1000}); // should not compile (truncating conversion)
static_assert(length<metre, double>(1000.0m).count() == 1000.0); static_assert(length<metre, double>(1000.0q_m).count() == 1000.0);
static_assert(length<metre, double>(length<metre, my_double>(1000.0)).count() == 1000.0); static_assert(length<metre, double>(length<metre, my_double>(1000.0)).count() == 1000.0);
static_assert(length<metre, my_double>(1000.0m).count() == my_double{1000.0}); static_assert(length<metre, my_double>(1000.0q_m).count() == my_double{1000.0});
static_assert(length<metre, double>(km).count() == 1000.0); static_assert(length<metre, double>(km).count() == 1000.0);
static_assert(length<metre, my_double>(km).count() == my_double{1000.0}); static_assert(length<metre, my_double>(km).count() == my_double{1000.0});
static_assert(length<metre, int>(1km).count() == 1000); static_assert(length<metre, int>(1q_km).count() == 1000);
// static_assert(length<metre, int>(1s).count() == 1); // should not compile (different dimensions) // static_assert(length<metre, int>(1q_s).count() == 1); // should not compile (different dimensions)
//static_assert(length<kilometre, int>(1010m).count() == 1); // should not compile (truncating conversion) //static_assert(length<kilometre, int>(1010q_m).count() == 1); // should not compile (truncating conversion)
static_assert(length<kilometre, int>(quantity_cast<length<kilometre, my_int>>(1010m)).count() == 1); static_assert(length<kilometre, int>(quantity_cast<length<kilometre, my_int>>(1010q_m)).count() == 1);
static_assert(length<metre, int>(quantity_cast<length<kilometre, my_int>>(1010m)).count() == 1000); static_assert(length<metre, int>(quantity_cast<length<kilometre, my_int>>(1010q_m)).count() == 1000);
// assignment operator // assignment operator
@@ -209,19 +209,19 @@ static_assert([](auto v) {
// compound assignment // compound assignment
static_assert((1m += 1m).count() == 2); static_assert((1q_m += 1q_m).count() == 2);
static_assert((2m -= 1m).count() == 1); static_assert((2q_m -= 1q_m).count() == 1);
static_assert((1m *= 2).count() == 2); static_assert((1q_m *= 2).count() == 2);
static_assert((2m /= 2).count() == 1); static_assert((2q_m /= 2).count() == 1);
static_assert((7m %= 2).count() == 1); static_assert((7q_m %= 2).count() == 1);
static_assert((7m %= 2m).count() == 1); static_assert((7q_m %= 2q_m).count() == 1);
// static_assert((7.m %= 2.).count() == 1); // should not compile (operation not allowed for floating-point types) // static_assert((7.m %= 2.).count() == 1); // should not compile (operation not allowed for floating-point types)
// static_assert((7.m %= 2).count() == 1); // should not compile (operation not allowed for floating-point types) // static_assert((7.m %= 2).count() == 1); // should not compile (operation not allowed for floating-point types)
// static_assert((7m %= 2.).count() == 1); // should not compile (operation not allowed for floating-point types) // static_assert((7q_m %= 2.).count() == 1); // should not compile (operation not allowed for floating-point types)
static_assert((7m %= 2m).count() == 1); static_assert((7q_m %= 2q_m).count() == 1);
// static_assert((7.m %= 2.m).count() == 1); // should not compile (operation not allowed for floating-point types) // static_assert((7.m %= 2.m).count() == 1); // should not compile (operation not allowed for floating-point types)
// static_assert((7.m %= 2m).count() == 1); // should not compile (operation not allowed for floating-point types) // static_assert((7.m %= 2q_m).count() == 1); // should not compile (operation not allowed for floating-point types)
// static_assert((7m %= 2.m).count() == 1); // should not compile (operation not allowed for floating-point types) // static_assert((7q_m %= 2.m).count() == 1); // should not compile (operation not allowed for floating-point types)
// non-member arithmetic operators // non-member arithmetic operators
@@ -257,51 +257,51 @@ static_assert(std::is_same_v<decltype(si::time<minute>() / length<metre>()),
static_assert(std::is_same_v<decltype(length<metre, int>() % short(1)), length<metre, int>>); static_assert(std::is_same_v<decltype(length<metre, int>() % short(1)), length<metre, int>>);
static_assert(std::is_same_v<decltype(length<metre, int>() % length<metre, short>(1)), length<metre, int>>); static_assert(std::is_same_v<decltype(length<metre, int>() % length<metre, short>(1)), length<metre, int>>);
static_assert((1m + km).count() == 1001); static_assert((1q_m + km).count() == 1001);
static_assert((1m + 1km).count() == 1001); static_assert((1q_m + 1q_km).count() == 1001);
static_assert((km - 1m).count() == 999); static_assert((km - 1q_m).count() == 999);
static_assert((1km - 1m).count() == 999); static_assert((1q_km - 1q_m).count() == 999);
static_assert((2m * 2).count() == 4); static_assert((2q_m * 2).count() == 4);
static_assert((3 * 3m).count() == 9); static_assert((3 * 3q_m).count() == 9);
static_assert((4m / 2).count() == 2); static_assert((4q_m / 2).count() == 2);
static_assert(4m / 2m == 2); static_assert(4q_m / 2q_m == 2);
static_assert(4km / 2000m == 2); static_assert(4q_km / 2000q_m == 2);
static_assert((7m % 2).count() == 1); static_assert((7q_m % 2).count() == 1);
static_assert((7m % 2m).count() == 1); static_assert((7q_m % 2q_m).count() == 1);
static_assert((7km % 2000m).count() == 1000); static_assert((7q_km % 2000q_m).count() == 1000);
static_assert((10km2 * 10km2) / 50km2 == 2km2); static_assert((10q_km2 * 10q_km2) / 50q_km2 == 2q_km2);
// comparators // comparators
static_assert(2m + 1m == 3m); static_assert(2q_m + 1q_m == 3q_m);
static_assert(!(2m + 2m == 3m)); static_assert(!(2q_m + 2q_m == 3q_m));
static_assert(2m + 2m != 3m); static_assert(2q_m + 2q_m != 3q_m);
static_assert(!(2m + 2m != 4m)); static_assert(!(2q_m + 2q_m != 4q_m));
static_assert(2m > 1m); static_assert(2q_m > 1q_m);
static_assert(!(1m > 1m)); static_assert(!(1q_m > 1q_m));
static_assert(1m < 2m); static_assert(1q_m < 2q_m);
static_assert(!(2m < 2m)); static_assert(!(2q_m < 2q_m));
static_assert(2m >= 1m); static_assert(2q_m >= 1q_m);
static_assert(2m >= 2m); static_assert(2q_m >= 2q_m);
static_assert(!(2m >= 3m)); static_assert(!(2q_m >= 3q_m));
static_assert(1m <= 2m); static_assert(1q_m <= 2q_m);
static_assert(2m <= 2m); static_assert(2q_m <= 2q_m);
static_assert(!(3m <= 2m)); static_assert(!(3q_m <= 2q_m));
static_assert(3m == 3.0m); static_assert(3q_m == 3.0q_m);
static_assert(3m != 3.14m); static_assert(3q_m != 3.14q_m);
static_assert(2m > 1.0m); static_assert(2q_m > 1.0q_m);
static_assert(1.0m < 2m); static_assert(1.0q_m < 2q_m);
static_assert(2.0m >= 1m); static_assert(2.0q_m >= 1q_m);
static_assert(1m <= 2.0m); static_assert(1q_m <= 2.0q_m);
static_assert(1000m == 1km); static_assert(1000q_m == 1q_km);
static_assert(1001m != 1km); static_assert(1001q_m != 1q_km);
static_assert(1001m > 1km); static_assert(1001q_m > 1q_km);
static_assert(999m < 1km); static_assert(999q_m < 1q_km);
static_assert(1000m >= 1km); static_assert(1000q_m >= 1q_km);
static_assert(1000m <= 1km); static_assert(1000q_m <= 1q_km);
// is_quantity // is_quantity
@@ -317,35 +317,35 @@ static_assert(std::is_same_v<common_quantity<length<kilometre, long long>, lengt
// quantity_cast // quantity_cast
static_assert(std::is_same_v<decltype(quantity_cast<scaled_unit<ratio<1>, metre>>(2km))::unit, metre>); static_assert(std::is_same_v<decltype(quantity_cast<scaled_unit<ratio<1>, metre>>(2q_km))::unit, metre>);
static_assert(quantity_cast<length<metre, int>>(2km).count() == 2000); static_assert(quantity_cast<length<metre, int>>(2q_km).count() == 2000);
static_assert(quantity_cast<length<kilometre, int>>(2000m).count() == 2); static_assert(quantity_cast<length<kilometre, int>>(2000q_m).count() == 2);
static_assert(quantity_cast<length<metre, int>>(1.23m).count() == 1); static_assert(quantity_cast<length<metre, int>>(1.23q_m).count() == 1);
static_assert(quantity_cast<metre>(2km).count() == 2000); static_assert(quantity_cast<metre>(2q_km).count() == 2000);
static_assert(quantity_cast<kilometre>(2000m).count() == 2); static_assert(quantity_cast<kilometre>(2000q_m).count() == 2);
static_assert(quantity_cast<int>(1.23m).count() == 1); static_assert(quantity_cast<int>(1.23q_m).count() == 1);
// time // time
// static_assert(1s == 1m); // should not compile (different dimensions) // static_assert(1q_s == 1q_m); // should not compile (different dimensions)
static_assert(1h == 3600s); static_assert(1q_h == 3600q_s);
// length // length
static_assert(1km == 1000m); static_assert(1q_km == 1000q_m);
static_assert(1km + 1m == 1001m); static_assert(1q_km + 1q_m == 1001q_m);
static_assert(10km / 5km == 2); static_assert(10q_km / 5q_km == 2);
static_assert(10km / 2 == 5km); static_assert(10q_km / 2 == 5q_km);
// velocity // velocity
static_assert(10m / 5s == 2mps); static_assert(10q_m / 5q_s == 2q_mps);
static_assert(10 / 5s * 1m == 2mps); static_assert(10 / 5q_s * 1q_m == 2q_mps);
static_assert(1km / 1s == 1000mps); static_assert(1q_km / 1q_s == 1000q_mps);
static_assert(2kmph * 2h == 4km); static_assert(2q_kmph * 2q_h == 4q_km);
static_assert(2km / 2kmph == 1h); static_assert(2q_km / 2q_kmph == 1q_h);
static_assert(std::is_same_v<decltype(pow<2>(2m)), decltype(4m2)>); static_assert(std::is_same_v<decltype(pow<2>(2q_m)), decltype(4q_m2)>);
} // namespace } // namespace

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

@@ -61,15 +61,15 @@ namespace si_test {
using namespace units::si::literals; using namespace units::si::literals;
static_assert(cgs::length<cgs::centimetre>(100) == 1m); static_assert(cgs::length<cgs::centimetre>(100) == 1q_m);
static_assert(cgs::mass<cgs::gram>(1'000) == 1kg); static_assert(cgs::mass<cgs::gram>(1'000) == 1q_kg);
static_assert(cgs::time<cgs::second>(1) == 1s); static_assert(cgs::time<cgs::second>(1) == 1q_s);
static_assert(cgs::velocity<cgs::centimetre_per_second>(100) == 1mps); static_assert(cgs::velocity<cgs::centimetre_per_second>(100) == 1q_mps);
static_assert(cgs::acceleration<cgs::gal>(100) == 1mps2); static_assert(cgs::acceleration<cgs::gal>(100) == 1q_mps2);
static_assert(cgs::force<cgs::dyne>(100'000) == 1N); static_assert(cgs::force<cgs::dyne>(100'000) == 1q_N);
static_assert(cgs::energy<cgs::erg>(10'000'000) == 1_J); static_assert(cgs::energy<cgs::erg>(10'000'000) == 1q_J);
static_assert(cgs::power<cgs::erg_per_second>(10'000'000) == 1W); static_assert(cgs::power<cgs::erg_per_second>(10'000'000) == 1q_W);
static_assert(cgs::pressure<cgs::barye>(10) == 1Pa); static_assert(cgs::pressure<cgs::barye>(10) == 1q_Pa);
} }
@@ -77,15 +77,15 @@ namespace cgs_test {
using namespace units::cgs::literals; using namespace units::cgs::literals;
static_assert(100cm == si::length<si::metre>(1)); static_assert(100q_cm == si::length<si::metre>(1));
static_assert(1'000g == si::mass<si::kilogram>(1)); static_assert(1'000q_g == si::mass<si::kilogram>(1));
static_assert(1s == si::time<si::second>(1)); static_assert(1q_s == si::time<si::second>(1));
static_assert(100cmps == si::velocity<si::metre_per_second>(1)); static_assert(100q_cmps == si::velocity<si::metre_per_second>(1));
static_assert(100Gal == si::acceleration<si::metre_per_second_sq>(1)); static_assert(100q_Gal == si::acceleration<si::metre_per_second_sq>(1));
static_assert(100'000dyn == si::force<si::newton>(1)); static_assert(100'000q_dyn == si::force<si::newton>(1));
static_assert(10'000'000_erg == si::energy<si::joule>(1)); static_assert(10'000'000q_erg == si::energy<si::joule>(1));
static_assert(10'000'000_ergps == si::power<si::watt>(1)); static_assert(10'000'000q_ergps == si::power<si::watt>(1));
static_assert(10Ba == si::pressure<si::pascal>(1)); static_assert(10q_Ba == si::pressure<si::pascal>(1));
} }
@@ -94,15 +94,15 @@ namespace both_test {
using namespace units::si::literals; using namespace units::si::literals;
using namespace units::cgs::literals; using namespace units::cgs::literals;
// static_assert(100cm == 1m); // ambiguous // static_assert(100q_cm == 1q_m); // ambiguous
// static_assert(1'000g == 1kg); // ambiguous // static_assert(1'000q_g == 1q_kg); // ambiguous
static_assert(1s == 1s); static_assert(1q_s == 1q_s);
static_assert(100cmps == 1mps); static_assert(100q_cmps == 1q_mps);
static_assert(100Gal == 1mps2); static_assert(100q_Gal == 1q_mps2);
static_assert(100'000dyn == 1N); static_assert(100'000q_dyn == 1q_N);
static_assert(10'000'000_erg == 1_J); static_assert(10'000'000q_erg == 1q_J);
static_assert(10'000'000_ergps == 1W); static_assert(10'000'000q_ergps == 1q_W);
static_assert(10Ba == quantity_cast<double>(1Pa)); static_assert(10q_Ba == quantity_cast<double>(1q_Pa));
} }
@@ -110,41 +110,41 @@ namespace cgs_test {
// addition // addition
// static_assert(100cm + si::length<si::metre>(1) == si::length<si::metre>(2)); // should not compile (different dimensions) // static_assert(100q_cm + si::length<si::metre>(1) == si::length<si::metre>(2)); // should not compile (different dimensions)
// static_assert(si::length<si::metre>(1) + 100cm == si::length<si::metre>(2)); // should not compile (different dimensions) // static_assert(si::length<si::metre>(1) + 100q_cm == si::length<si::metre>(2)); // should not compile (different dimensions)
static_assert(quantity_cast<si::length<si::metre>>(100cm) + si::length<si::metre>(1) == si::length<si::metre>(2)); static_assert(quantity_cast<si::length<si::metre>>(100q_cm) + si::length<si::metre>(1) == si::length<si::metre>(2));
static_assert(si::length<si::metre>(1) + quantity_cast<si::length<si::metre>>(100cm) == si::length<si::metre>(2)); static_assert(si::length<si::metre>(1) + quantity_cast<si::length<si::metre>>(100q_cm) == si::length<si::metre>(2));
static_assert(100cm + quantity_cast<cgs::length<cgs::centimetre>>(si::length<si::metre>(1)) == 200cm); static_assert(100q_cm + quantity_cast<cgs::length<cgs::centimetre>>(si::length<si::metre>(1)) == 200q_cm);
static_assert(quantity_cast<cgs::length<cgs::centimetre>>(si::length<si::metre>(1)) + 100cm == 200cm); static_assert(quantity_cast<cgs::length<cgs::centimetre>>(si::length<si::metre>(1)) + 100q_cm == 200q_cm);
// substraction // substraction
// static_assert(500cm - si::length<si::metre>(1) == si::length<si::metre>(4)); // should not compile (different dimensions) // static_assert(500q_cm - si::length<si::metre>(1) == si::length<si::metre>(4)); // should not compile (different dimensions)
// static_assert(si::length<si::metre>(5) - 100cm == si::length<si::metre>(4)); // should not compile (different dimensions) // static_assert(si::length<si::metre>(5) - 100q_cm == si::length<si::metre>(4)); // should not compile (different dimensions)
static_assert(quantity_cast<si::length<si::metre>>(500cm) - si::length<si::metre>(1) == si::length<si::metre>(4)); static_assert(quantity_cast<si::length<si::metre>>(500q_cm) - si::length<si::metre>(1) == si::length<si::metre>(4));
static_assert(si::length<si::metre>(5) - quantity_cast<si::length<si::metre>>(100cm) == si::length<si::metre>(4)); static_assert(si::length<si::metre>(5) - quantity_cast<si::length<si::metre>>(100q_cm) == si::length<si::metre>(4));
static_assert(500cm - quantity_cast<cgs::length<cgs::centimetre>>(si::length<si::metre>(1)) == 400cm); static_assert(500q_cm - quantity_cast<cgs::length<cgs::centimetre>>(si::length<si::metre>(1)) == 400q_cm);
static_assert(quantity_cast<cgs::length<cgs::centimetre>>(si::length<si::metre>(5)) - 100cm == 400cm); static_assert(quantity_cast<cgs::length<cgs::centimetre>>(si::length<si::metre>(5)) - 100q_cm == 400q_cm);
// multiplication // multiplication
// static_assert(200cm * si::length<si::metre>(2) == si::area<si::square_metre>(4)); // should not compile (unknown dimension) // static_assert(200q_cm * 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(quantity_cast<si::dim_length>(200q_cm) * 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'000cm2); static_assert(200q_cm * quantity_cast<cgs::dim_length>(si::length<si::metre>(2)) == 40'000q_cm2);
// TODO Add support for quantity_cast on an unknown_dimension? // 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)); // static_assert(quantity_cast<si::area<si::square_metre>>(200q_cm * si::length<si::metre>(2)) == si::area<si::square_metre>(4));
// static_assert(quantity_cast<si::dim_area>(200cm * si::length<si::metre>(2)) == si::area<si::square_metre>(4)); // static_assert(quantity_cast<si::dim_area>(200q_cm * si::length<si::metre>(2)) == si::area<si::square_metre>(4));
// static_assert(quantity_cast<cgs::area<cgs::square_centimeters>>(200cm * si::length<si::metre>(2)) == 40'000sq_cm); // static_assert(quantity_cast<cgs::area<cgs::square_centimeters>>(200q_cm * si::length<si::metre>(2)) == 40'000q_sq_cm);
// static_assert(quantity_cast<cgs::dim_area>(200cm * si::length<si::metre>(2)) == 40'000sq_cm); // static_assert(quantity_cast<cgs::dim_area>(200q_cm * si::length<si::metre>(2)) == 40'000q_sq_cm);
// division // division
// static_assert(si::area<si::square_metre>(4) / 200cm == si::length<si::metre>(2)); // should not compile (unknown dimension) // static_assert(si::area<si::square_metre>(4) / 200q_cm == si::length<si::metre>(2)); // should not compile (unknown dimension)
static_assert(si::area<si::square_metre>(4) / quantity_cast<si::length<si::metre>>(200cm) == si::length<si::metre>(2)); static_assert(si::area<si::square_metre>(4) / quantity_cast<si::length<si::metre>>(200q_cm) == si::length<si::metre>(2));
static_assert(quantity_cast<cgs::area<cgs::square_centimetre>>(si::area<si::square_metre>(4)) / 200cm == 200cm); static_assert(quantity_cast<cgs::area<cgs::square_centimetre>>(si::area<si::square_metre>(4)) / 200q_cm == 200q_cm);
} }

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

@@ -51,16 +51,16 @@ using namespace units::si;
// length // length
static_assert(1km == 1000m); static_assert(1q_km == 1000q_m);
static_assert(1m == 100cm); static_assert(1q_m == 100q_cm);
static_assert(1m == 10dm); static_assert(1q_m == 10q_dm);
static_assert(1m == 1000mm); static_assert(1q_m == 1000q_mm);
static_assert(1hm == 100m); static_assert(1q_hm == 100q_m);
static_assert(1au == 149'597'870'700m); static_assert(1q_au == 149'597'870'700q_m);
static_assert(1km + 1m == 1001m); static_assert(1q_km + 1q_m == 1001q_m);
static_assert(10km / 5km == 2); static_assert(10q_km / 5q_km == 2);
static_assert(100mm / 5cm == 2); static_assert(100q_mm / 5q_cm == 2);
static_assert(10km / 2 == 5km); static_assert(10q_km / 2 == 5q_km);
static_assert(millimetre::symbol == "mm"); static_assert(millimetre::symbol == "mm");
static_assert(centimetre::symbol == "cm"); static_assert(centimetre::symbol == "cm");
@@ -69,21 +69,21 @@ static_assert(kilometre::symbol == "km");
// mass // mass
static_assert(1kg == 1000g); static_assert(1q_kg == 1000q_g);
static_assert(1t == 1000kg); static_assert(1q_t == 1000q_kg);
static_assert(kilogram::symbol == "kg"); static_assert(kilogram::symbol == "kg");
// time // time
static_assert(1us == 1000ns); static_assert(1q_us == 1000q_ns);
static_assert(1ms == 1000us); static_assert(1q_ms == 1000q_us);
static_assert(1s == 1000ms); static_assert(1q_s == 1000q_ms);
static_assert(1min == 60s); static_assert(1q_min == 60q_s);
static_assert(1h == 60min); static_assert(1q_h == 60q_min);
static_assert(1h == 3600s); static_assert(1q_h == 3600q_s);
static_assert(1_d == 24h); static_assert(1q_d == 24q_h);
static_assert(1_d == 86'400s); static_assert(1q_d == 86'400q_s);
static_assert(nanosecond::symbol == "ns"); static_assert(nanosecond::symbol == "ns");
static_assert(microsecond::symbol == "µs"); static_assert(microsecond::symbol == "µs");
@@ -101,11 +101,11 @@ static_assert(millisecond::symbol == "ms");
// frequency // frequency
static_assert(1000mHz == 1Hz); static_assert(1000q_mHz == 1q_Hz);
static_assert(1000Hz == 1kHz); static_assert(1000q_Hz == 1q_kHz);
static_assert(1000kHz == 1MHz); static_assert(1000q_kHz == 1q_MHz);
static_assert(1000MHz == 1GHz); static_assert(1000q_MHz == 1q_GHz);
static_assert(1000GHz == 1THz); static_assert(1000q_GHz == 1q_THz);
static_assert(millihertz::symbol == "mHz"); static_assert(millihertz::symbol == "mHz");
static_assert(kilohertz::symbol == "kHz"); static_assert(kilohertz::symbol == "kHz");
@@ -113,140 +113,140 @@ static_assert(megahertz::symbol == "MHz");
static_assert(gigahertz::symbol == "GHz"); static_assert(gigahertz::symbol == "GHz");
static_assert(terahertz::symbol == "THz"); static_assert(terahertz::symbol == "THz");
static_assert(2 / 1s == 2Hz); static_assert(2 / 1q_s == 2q_Hz);
static_assert(120 / 1min == 2Hz); static_assert(120 / 1q_min == 2q_Hz);
static_assert(1000 / 1s == 1kHz); static_assert(1000 / 1q_s == 1q_kHz);
static_assert(1 / 1ms == 1kHz); static_assert(1 / 1q_ms == 1q_kHz);
static_assert(3.2GHz == 3'200'000'000Hz); static_assert(3.2q_GHz == 3'200'000'000q_Hz);
static_assert(10Hz * 1min == 600); static_assert(10q_Hz * 1q_min == 600);
static_assert(2 / 1Hz == 2s); static_assert(2 / 1q_Hz == 2q_s);
// force // force
static_assert(10kg * 10mps2 == 100N); static_assert(10q_kg * 10q_mps2 == 100q_N);
static_assert(100N / 1mps2 == 100kg); static_assert(100q_N / 1q_mps2 == 100q_kg);
static_assert(100N / 1kg == 100mps2); static_assert(100q_N / 1q_kg == 100q_mps2);
// pressure // pressure
static_assert(10N / 10m2 == 1Pa); static_assert(10q_N / 10q_m2 == 1q_Pa);
static_assert(10N / 1Pa == 10m2); static_assert(10q_N / 1q_Pa == 10q_m2);
static_assert(1Pa * 10m2 == 10N); static_assert(1q_Pa * 10q_m2 == 10q_N);
// energy // energy
static_assert(1000mJ == 1_J); static_assert(1000q_mJ == 1q_J);
static_assert(1000_J == 1kJ); static_assert(1000q_J == 1q_kJ);
static_assert(1000kJ == 1MJ); static_assert(1000q_kJ == 1q_MJ);
static_assert(1000MJ == 1GJ); static_assert(1000q_MJ == 1q_GJ);
static_assert(millijoule::symbol == "mJ"); static_assert(millijoule::symbol == "mJ");
static_assert(kilojoule::symbol == "kJ"); static_assert(kilojoule::symbol == "kJ");
static_assert(megajoule::symbol == "MJ"); static_assert(megajoule::symbol == "MJ");
static_assert(gigajoule::symbol == "GJ"); static_assert(gigajoule::symbol == "GJ");
static_assert(10N * 10m == 100_J); static_assert(10q_N * 10q_m == 100q_J);
static_assert(100_J / 10m == 10N); static_assert(100q_J / 10q_m == 10q_N);
static_assert(100_J / 10N == 10m); static_assert(100q_J / 10q_N == 10q_m);
static_assert(10Pa * 10m3 == 100_J); static_assert(10q_Pa * 10q_m3 == 100q_J);
static_assert(100_J / 10Pa == 10m3); static_assert(100q_J / 10q_Pa == 10q_m3);
static_assert(100_J / 10m3 == 10Pa); static_assert(100q_J / 10q_m3 == 10q_Pa);
// power // power
static_assert(1000mW == 1W); static_assert(1000q_mW == 1q_W);
static_assert(1000W == 1kW); static_assert(1000q_W == 1q_kW);
static_assert(1000kW == 1MW); static_assert(1000q_kW == 1q_MW);
static_assert(1000MW == 1GW); static_assert(1000q_MW == 1q_GW);
static_assert(milliwatt::symbol == "mW"); static_assert(milliwatt::symbol == "mW");
static_assert(kilowatt::symbol == "kW"); static_assert(kilowatt::symbol == "kW");
static_assert(megawatt::symbol == "MW"); static_assert(megawatt::symbol == "MW");
static_assert(gigawatt::symbol == "GW"); static_assert(gigawatt::symbol == "GW");
static_assert(10_J / 10s == 1W); static_assert(10q_J / 10q_s == 1q_W);
static_assert(1W * 10s == 10_J); static_assert(1q_W * 10q_s == 10q_J);
static_assert(10_J / 1W == 10s); static_assert(10q_J / 1q_W == 10q_s);
// electric charge // electric charge
static_assert(10A * 10s == 100C); static_assert(10q_A * 10q_s == 100q_C);
static_assert(100C / 10A == 10s); static_assert(100q_C / 10q_A == 10q_s);
static_assert(100C / 10s == 10A); static_assert(100q_C / 10q_s == 10q_A);
// voltage // voltage
static_assert(10W / 10A == 1V); static_assert(10q_W / 10q_A == 1q_V);
static_assert(10W / 1V == 10A); static_assert(10q_W / 1q_V == 10q_A);
static_assert(1V * 10A == 10W); static_assert(1q_V * 10q_A == 10q_W);
static_assert(10_J / 10C == 1V); static_assert(10q_J / 10q_C == 1q_V);
static_assert(10_J / 1V == 10C); static_assert(10q_J / 1q_V == 10q_C);
static_assert(10C * 1V == 10_J); static_assert(10q_C * 1q_V == 10q_J);
// capacitance // capacitance
static_assert(10C / 10V == 1F); static_assert(10q_C / 10q_V == 1q_F);
static_assert(10C / 1F == 10V); static_assert(10q_C / 1q_F == 10q_V);
static_assert(10V * 1F == 10C); static_assert(10q_V * 1q_F == 10q_C);
/* ************** DERIVED DIMENSIONS IN TERMS OF BASE UNITS **************** */ /* ************** DERIVED DIMENSIONS IN TERMS OF BASE UNITS **************** */
// velocity // velocity
static_assert(std::is_same_v<decltype(1km / 1s), velocity<scaled_unit<ratio<1, 1, 3>, metre_per_second>, std::int64_t>>); static_assert(std::is_same_v<decltype(1q_km / 1q_s), velocity<scaled_unit<ratio<1, 1, 3>, metre_per_second>, std::int64_t>>);
static_assert(10m / 5s == 2mps); static_assert(10q_m / 5q_s == 2q_mps);
static_assert(10 / 5s * 1m == 2mps); static_assert(10 / 5q_s * 1q_m == 2q_mps);
static_assert(1km / 1s == 1000mps); static_assert(1q_km / 1q_s == 1000q_mps);
// static_assert(1km / 1h == 1kmph); // should not compile // static_assert(1q_km / 1q_h == 1q_kmph); // should not compile
static_assert(1.0km / 1h == 1kmph); static_assert(1.0q_km / 1q_h == 1q_kmph);
static_assert(1000.0m / 3600.0s == 1kmph); static_assert(1000.0q_m / 3600.0q_s == 1q_kmph);
static_assert(2kmph * 2h == 4km); static_assert(2q_kmph * 2q_h == 4q_km);
// static_assert(2kmph * 15min == 500m); // should not compile // static_assert(2q_kmph * 15q_min == 500q_m); // should not compile
static_assert(2kmph * 15.0min == 500m); static_assert(2q_kmph * 15.0q_min == 500q_m);
static_assert(2.0kmph * 15min == 500m); static_assert(2.0q_kmph * 15q_min == 500q_m);
static_assert(2km / 2kmph == 1h); static_assert(2q_km / 2q_kmph == 1q_h);
// static_assert(2000m / 2kmph == 1h); // should not compile // static_assert(2000q_m / 2q_kmph == 1q_h); // should not compile
static_assert(quantity_cast<kilometre>(2000m) / 2kmph == 1h); static_assert(quantity_cast<kilometre>(2000q_m) / 2q_kmph == 1q_h);
static_assert(detail::unit_text<dim_velocity, metre_per_second>() == "m/s"); static_assert(detail::unit_text<dim_velocity, metre_per_second>() == "m/s");
static_assert(kilometre_per_hour::symbol == "km/h"); static_assert(kilometre_per_hour::symbol == "km/h");
// acceleration // acceleration
static_assert(10mps / 10s == 1mps2); static_assert(10q_mps / 10q_s == 1q_mps2);
static_assert(10mps / 1mps2 == 10s); static_assert(10q_mps / 1q_mps2 == 10q_s);
static_assert(1mps2 * 10s == 10mps); static_assert(1q_mps2 * 10q_s == 10q_mps);
static_assert(detail::unit_text<dim_acceleration, metre_per_second_sq>() == "m/s²"); static_assert(detail::unit_text<dim_acceleration, metre_per_second_sq>() == "m/s²");
// area // area
static_assert(10m * 10m == 100m2); static_assert(10q_m * 10q_m == 100q_m2);
static_assert(100m2 / 10m == 10m); static_assert(100q_m2 / 10q_m == 10q_m);
static_assert(10km * 10km == 100km2); static_assert(10q_km * 10q_km == 100q_km2);
static_assert(1m2 == 10'000cm2); static_assert(1q_m2 == 10'000q_cm2);
static_assert(1ha == 10'000m2); static_assert(1q_ha == 10'000q_m2);
static_assert(detail::unit_text<dim_area, square_metre>() == "m²"); static_assert(detail::unit_text<dim_area, square_metre>() == "m²");
// volume // volume
static_assert(1m * 1m * 1m == 1m3); static_assert(1q_m * 1q_m * 1q_m == 1q_m3);
static_assert(10m2 * 10m == 100m3); static_assert(10q_m2 * 10q_m == 100q_m3);
static_assert(10km * 10km * 10km == 1000km3); static_assert(10q_km * 10q_km * 10q_km == 1000q_km3);
static_assert(1m3 == 1'000'000cm3); static_assert(1q_m3 == 1'000'000q_cm3);
static_assert(1dm * 1dm * 1dm == 1_l); static_assert(1q_dm * 1q_dm * 1q_dm == 1q_l);
static_assert(1000_l == 1m3); static_assert(1000q_l == 1q_m3);
static_assert(detail::unit_text<dim_volume, cubic_metre>() == "m³"); static_assert(detail::unit_text<dim_volume, cubic_metre>() == "m³");
/* ************** DERIVED DIMENSIONS IN TERMS OF OTHER UNITS **************** */ /* ************** DERIVED DIMENSIONS IN TERMS OF OTHER UNITS **************** */
static_assert(10N / 2m == 5Npm); static_assert(10q_N / 2q_m == 5q_Npm);
static_assert(10N / 5Npm == 2m); static_assert(10q_N / 5q_Npm == 2q_m);
static_assert(2m * 5Npm == 10N); static_assert(2q_m * 5q_Npm == 10q_N);
static_assert(detail::unit_text<dim_surface_tension, newton_per_metre>() == "N/m"); static_assert(detail::unit_text<dim_surface_tension, newton_per_metre>() == "N/m");

12
test/unit_test/static/us_test.cpp
View File

@@ -42,19 +42,19 @@ using namespace units::international;
// length // length
static_assert(1yd == 0.9144m); static_assert(1q_yd == 0.9144q_m);
static_assert(1yd == 3ft); static_assert(1q_yd == 3q_ft);
static_assert(1ft == 12in); static_assert(1q_ft == 12q_in);
static_assert(1mi == 1760yd); static_assert(1q_mi == 1760q_yd);
static_assert(5in + 8cm == 207mm); static_assert(5q_in + 8q_cm == 207q_mm);
/* ************** DERIVED DIMENSIONS IN TERMS OF BASE UNITS **************** */ /* ************** DERIVED DIMENSIONS IN TERMS OF BASE UNITS **************** */
// velocity // velocity
static_assert(10.0mi / 2h == 5mph); static_assert(10.0q_mi / 2q_h == 5q_mph);
static_assert(mile_per_hour::symbol == "mi/h"); static_assert(mile_per_hour::symbol == "mi/h");

2
test_package/test_package.cpp
View File

@@ -31,5 +31,5 @@ constexpr units::Velocity AUTO avg_speed(units::Length AUTO d, units::Time AUTO
int main() int main()
{ {
using namespace units::si::literals; using namespace units::si::literals;
std::cout << "Average speed = " << avg_speed(240.km, 2h) << '\n'; std::cout << "Average speed = " << avg_speed(240.q_km, 2q_h) << '\n';
} }